content: package com.lody.virtual.server.pm;
  
  import android.content.Intent;
  import android.content.IntentFilter;
  import android.content.pm.ResolveInfo;
  import android.net.Uri;
  import android.os.Build;
  import com.lody.virtual.helper.utils.VLog;
  import com.lody.virtual.server.pm.parser.VPackage;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Set;
  
  public abstract class IntentResolver<F extends VPackage.IntentInfo, R> {
    private static final String TAG = "IntentResolver";
    
    private static final Comparator sResolvePrioritySorter = new Comparator() {
        public int compare(Object param1Object1, Object param1Object2) {
          int i;
          int j;
          byte b2;
          boolean bool = param1Object1 instanceof IntentFilter;
          byte b1 = 0;
          if (bool) {
            i = ((IntentFilter)param1Object1).getPriority();
            j = ((IntentFilter)param1Object2).getPriority();
          } else {
            b2 = b1;
            if (param1Object1 instanceof ResolveInfo) {
              param1Object1 = param1Object1;
              param1Object2 = param1Object2;
              if (((ResolveInfo)param1Object1).filter == null) {
                b2 = 0;
              } else {
                b2 = ((ResolveInfo)param1Object1).filter.getPriority();
              } 
              if (((ResolveInfo)param1Object2).filter == null) {
                j = 0;
                i = b2;
              } else {
                j = ((ResolveInfo)param1Object2).filter.getPriority();
                i = b2;
              } 
            } else {
              return b2;
            } 
          } 
          if (i > j) {
            b2 = -1;
          } else {
            b2 = b1;
            if (i < j)
              b2 = 1; 
          } 
          return b2;
        }
      };
    
    private HashMap<String, F[]> mActionToFilter = new HashMap<String, F>();
    
    private HashMap<String, F[]> mBaseTypeToFilter = new HashMap<String, F>();
    
    private HashSet<F> mFilters = new HashSet<F>();
    
    private HashMap<String, F[]> mSchemeToFilter = new HashMap<String, F>();
    
    private HashMap<String, F[]> mTypeToFilter = new HashMap<String, F>();
    
    private HashMap<String, F[]> mTypedActionToFilter = new HashMap<String, F>();
    
    private HashMap<String, F[]> mWildTypeToFilter = new HashMap<String, F>();
    
    private void addFilter(HashMap<String, F[]> paramHashMap, String paramString, F paramF) {
      VPackage.IntentInfo[] arrayOfIntentInfo = (VPackage.IntentInfo[])paramHashMap.get(paramString);
      if (arrayOfIntentInfo == null) {
        arrayOfIntentInfo = (VPackage.IntentInfo[])newArray(2);
        paramHashMap.put(paramString, (F[])arrayOfIntentInfo);
        arrayOfIntentInfo[0] = (VPackage.IntentInfo)paramF;
      } else {
        int i = arrayOfIntentInfo.length;
        int j;
        for (j = i; j > 0 && arrayOfIntentInfo[j - 1] == null; j--);
        if (j < i) {
          arrayOfIntentInfo[j] = (VPackage.IntentInfo)paramF;
        } else {
          F[] arrayOfF = newArray(i * 3 / 2);
          System.arraycopy(arrayOfIntentInfo, 0, arrayOfF, 0, i);
          arrayOfF[i] = paramF;
          paramHashMap.put(paramString, arrayOfF);
        } 
      } 
    }
    
    private void buildResolveList(Intent paramIntent, FastImmutableArraySet<String> paramFastImmutableArraySet, boolean paramBoolean, String paramString1, String paramString2, F[] paramArrayOfF, List<R> paramList, int paramInt) {
      byte b1;
      Object object;
      F[] arrayOfF = paramArrayOfF;
      String str2 = paramIntent.getAction();
      Uri uri = paramIntent.getData();
      String str1 = paramIntent.getPackage();
      if (arrayOfF != null) {
        b1 = arrayOfF.length;
      } else {
        b1 = 0;
      } 
      byte b2 = 0;
      boolean bool = false;
      while (b2 < b1) {
        F f = paramArrayOfF[b2];
        if (f != null) {
          if ((str1 == null || isPackageForFilter(str1, f)) && allowFilterResult(f, paramList)) {
            int i = ((VPackage.IntentInfo)f).filter.match(str2, paramString1, paramString2, uri, paramFastImmutableArraySet, "IntentResolver");
            if (i >= 0) {
              if (!paramBoolean || ((VPackage.IntentInfo)f).filter.hasCategory("android.intent.category.DEFAULT")) {
                f = (F)newResult(f, i, paramInt);
                Object object2 = object;
                if (f != null) {
                  paramList.add((R)f);
                  object2 = object;
                } 
              } else {
                i = 1;
              } 
              continue;
            } 
          } 
          Object object1 = object;
          continue;
        } 
        b2++;
        object = SYNTHETIC_LOCAL_VARIABLE_15;
      } 
      if (object != null)
        if (paramList.size() == 0) {
          VLog.w("IntentResolver", "resolveIntent failed: found match, but none with CATEGORY_DEFAULT", new Object[0]);
        } else if (paramList.size() > 1) {
          VLog.w("IntentResolver", "resolveIntent: multiple matches, only some with CATEGORY_DEFAULT", new Object[0]);
        }  
    }
    
    private ArrayList<F> collectFilters(F[] paramArrayOfF, IntentFilter paramIntentFilter) {
      ArrayList<F> arrayList1 = null;
      ArrayList<F> arrayList2 = null;
      if (paramArrayOfF != null) {
        byte b = 0;
        while (true) {
          arrayList1 = arrayList2;
          if (b < paramArrayOfF.length) {
            F f = paramArrayOfF[b];
            if (f == null) {
              arrayList1 = arrayList2;
              break;
            } 
            arrayList1 = arrayList2;
            if (filterEquals(((VPackage.IntentInfo)f).filter, paramIntentFilter)) {
              arrayList1 = arrayList2;
              if (arrayList2 == null)
                arrayList1 = new ArrayList(); 
              arrayList1.add(f);
            } 
            b++;
            arrayList2 = arrayList1;
            continue;
          } 
          break;
        } 
      } 
      return arrayList1;
    }
    
    private boolean filterEquals(IntentFilter paramIntentFilter1, IntentFilter paramIntentFilter2) {
      int i = paramIntentFilter1.countActions();
      if (i != paramIntentFilter2.countActions())
        return false; 
      byte b;
      for (b = 0; b < i; b++) {
        if (!paramIntentFilter2.hasAction(paramIntentFilter1.getAction(b)))
          return false; 
      } 
      i = paramIntentFilter1.countCategories();
      if (i != paramIntentFilter2.countCategories())
        return false; 
      for (b = 0; b < i; b++) {
        if (!paramIntentFilter2.hasCategory(paramIntentFilter1.getCategory(b)))
          return false; 
      } 
      if (paramIntentFilter1.countDataTypes() != paramIntentFilter2.countDataTypes())
        return false; 
      i = paramIntentFilter1.countDataSchemes();
      if (i != paramIntentFilter2.countDataSchemes())
        return false; 
      for (b = 0; b < i; b++) {
        if (!paramIntentFilter2.hasDataScheme(paramIntentFilter1.getDataScheme(b)))
          return false; 
      } 
      return (paramIntentFilter1.countDataAuthorities() != paramIntentFilter2.countDataAuthorities()) ? false : ((paramIntentFilter1.countDataPaths() != paramIntentFilter2.countDataPaths()) ? false : (!(Build.VERSION.SDK_INT >= 19 && paramIntentFilter1.countDataSchemeSpecificParts() != paramIntentFilter2.countDataSchemeSpecificParts())));
    }
    
    private static FastImmutableArraySet<String> getFastIntentCategories(Intent paramIntent) {
      Set set = paramIntent.getCategories();
      return (set == null) ? null : new FastImmutableArraySet<String>((String[])set.toArray((Object[])new String[set.size()]));
    }
    
    private int register_intent_filter(F paramF, Iterator<String> paramIterator, HashMap<String, F[]> paramHashMap, String paramString) {
      byte b = 0;
      if (paramIterator == null)
        return 0; 
      while (paramIterator.hasNext()) {
        paramString = paramIterator.next();
        b++;
        addFilter(paramHashMap, paramString, paramF);
      } 
      return b;
    }
    
    private int register_mime_types(F paramF, String paramString) {
      Iterator<String> iterator = ((VPackage.IntentInfo)paramF).filter.typesIterator();
      if (iterator == null)
        return 0; 
      byte b = 0;
      while (iterator.hasNext()) {
        String str;
        paramString = iterator.next();
        b++;
        int i = paramString.indexOf('/');
        if (i > 0) {
          str = paramString.substring(0, i).intern();
        } else {
          StringBuilder stringBuilder = new StringBuilder();
          stringBuilder.append(paramString);
          stringBuilder.append("/*");
          String str1 = stringBuilder.toString();
          str = paramString;
          paramString = str1;
        } 
        addFilter(this.mTypeToFilter, paramString, paramF);
        if (i > 0) {
          addFilter(this.mBaseTypeToFilter, str, paramF);
          continue;
        } 
        addFilter(this.mWildTypeToFilter, str, paramF);
      } 
      return b;
    }
    
    private void remove_all_objects(HashMap<String, F[]> paramHashMap, String paramString, Object paramObject) {
      VPackage.IntentInfo[] arrayOfIntentInfo = (VPackage.IntentInfo[])paramHashMap.get(paramString);
      if (arrayOfIntentInfo != null) {
        int i;
        for (i = arrayOfIntentInfo.length - 1; i >= 0 && arrayOfIntentInfo[i] == null; i--);
        int j;
        for (j = i; i >= 0; j = k) {
          int k = j;
          if (arrayOfIntentInfo[i] == paramObject) {
            k = j - i;
            if (k > 0)
              System.arraycopy(arrayOfIntentInfo, i + 1, arrayOfIntentInfo, i, k); 
            arrayOfIntentInfo[j] = null;
            k = j - 1;
          } 
          i--;
        } 
        if (j < 0) {
          paramHashMap.remove(paramString);
        } else if (j < arrayOfIntentInfo.length / 2) {
          paramObject = newArray(j + 2);
          System.arraycopy(arrayOfIntentInfo, 0, paramObject, 0, j + 1);
          paramHashMap.put(paramString, (F[])paramObject);
        } 
      } 
    }
    
    private int unregister_intent_filter(F paramF, Iterator<String> paramIterator, HashMap<String, F[]> paramHashMap, String paramString) {
      byte b = 0;
      if (paramIterator == null)
        return 0; 
      while (paramIterator.hasNext()) {
        paramString = paramIterator.next();
        b++;
        remove_all_objects(paramHashMap, paramString, paramF);
      } 
      return b;
    }
    
    private int unregister_mime_types(F paramF, String paramString) {
      Iterator<String> iterator = ((VPackage.IntentInfo)paramF).filter.typesIterator();
      if (iterator == null)
        return 0; 
      byte b = 0;
      while (iterator.hasNext()) {
        String str;
        paramString = iterator.next();
        b++;
        int i = paramString.indexOf('/');
        if (i > 0) {
          str = paramString.substring(0, i).intern();
        } else {
          StringBuilder stringBuilder = new StringBuilder();
          stringBuilder.append(paramString);
          stringBuilder.append("/*");
          String str1 = stringBuilder.toString();
          str = paramString;
          paramString = str1;
        } 
        remove_all_objects(this.mTypeToFilter, paramString, paramF);
        if (i > 0) {
          remove_all_objects(this.mBaseTypeToFilter, str, paramF);
          continue;
        } 
        remove_all_objects(this.mWildTypeToFilter, str, paramF);
      } 
      return b;
    }
    
    public void addFilter(F paramF) {
      this.mFilters.add(paramF);
      int i = register_intent_filter(paramF, ((VPackage.IntentInfo)paramF).filter.schemesIterator(), this.mSchemeToFilter, "      Scheme: ");
      int j = register_mime_types(paramF, "      Type: ");
      if (i == 0 && j == 0)
        register_intent_filter(paramF, ((VPackage.IntentInfo)paramF).filter.actionsIterator(), this.mActionToFilter, "      Action: "); 
      if (j != 0)
        register_intent_filter(paramF, ((VPackage.IntentInfo)paramF).filter.actionsIterator(), this.mTypedActionToFilter, "      TypedAction: "); 
    }
    
    protected boolean allowFilterResult(F paramF, List<R> paramList) {
      return true;
    }
    
    protected void dumpFilter(PrintWriter paramPrintWriter, String paramString, F paramF) {
      paramPrintWriter.print(paramString);
      paramPrintWriter.println(paramF);
    }
    
    protected void dumpFilterLabel(PrintWriter paramPrintWriter, String paramString, Object paramObject, int paramInt) {
      paramPrintWriter.print(paramString);
      paramPrintWriter.print(paramObject);
      paramPrintWriter.print(": ");
      paramPrintWriter.println(paramInt);
    }
    
    public Iterator<F> filterIterator() {
      return new IteratorWrapper(this.mFilters.iterator());
    }
    
    public Set<F> filterSet() {
      return Collections.unmodifiableSet(this.mFilters);
    }
    
    protected Object filterToLabel(F paramF) {
      return "IntentFilter";
    }
    
    public ArrayList<F> findFilters(IntentFilter paramIntentFilter) {
      if (paramIntentFilter.countDataSchemes() == 1)
        return collectFilters(this.mSchemeToFilter.get(paramIntentFilter.getDataScheme(0)), paramIntentFilter); 
      if (paramIntentFilter.countDataTypes() != 0 && paramIntentFilter.countActions() == 1)
        return collectFilters(this.mTypedActionToFilter.get(paramIntentFilter.getAction(0)), paramIntentFilter); 
      if (paramIntentFilter.countDataTypes() == 0 && paramIntentFilter.countDataSchemes() == 0 && paramIntentFilter.countActions() == 1)
        return collectFilters(this.mActionToFilter.get(paramIntentFilter.getAction(0)), paramIntentFilter); 
      ArrayList<VPackage.IntentInfo> arrayList = null;
      for (VPackage.IntentInfo intentInfo : this.mFilters) {
        if (filterEquals(intentInfo.filter, paramIntentFilter)) {
          ArrayList<VPackage.IntentInfo> arrayList1 = arrayList;
          if (arrayList == null)
            arrayList1 = new ArrayList(); 
          arrayList1.add(intentInfo);
          arrayList = arrayList1;
        } 
      } 
      return (ArrayList)arrayList;
    }
    
    protected boolean isFilterStopped(F paramF) {
      return false;
    }
    
    protected abstract boolean isPackageForFilter(String paramString, F paramF);
    
    protected abstract F[] newArray(int paramInt);
    
    protected R newResult(F paramF, int paramInt1, int paramInt2) {
      return (R)paramF;
    }
    
    public List<R> queryIntent(Intent paramIntent, String paramString, boolean paramBoolean, int paramInt) {
      // Byte code:
      //   0: aload_1
      //   1: invokevirtual getScheme : ()Ljava/lang/String;
      //   4: astore #5
      //   6: new java/util/ArrayList
      //   9: dup
      //   10: invokespecial <init> : ()V
      //   13: astore #6
      //   15: aconst_null
      //   16: astore #7
      //   18: aload_2
      //   19: ifnull -> 192
      //   22: aload_2
      //   23: bipush #47
      //   25: invokevirtual indexOf : (I)I
      //   28: istore #8
      //   30: iload #8
      //   32: ifle -> 192
      //   35: aload_2
      //   36: iconst_0
      //   37: iload #8
      //   39: invokevirtual substring : (II)Ljava/lang/String;
      //   42: astore #9
      //   44: aload #9
      //   46: ldc_w '*'
      //   49: invokevirtual equals : (Ljava/lang/Object;)Z
      //   52: ifne -> 166
      //   55: aload_2
      //   56: invokevirtual length : ()I
      //   59: iload #8
      //   61: iconst_2
      //   62: iadd
      //   63: if_icmpne -> 113
      //   66: aload_2
      //   67: iload #8
      //   69: iconst_1
      //   70: iadd
      //   71: invokevirtual charAt : (I)C
      //   74: bipush #42
      //   76: if_icmpeq -> 82
      //   79: goto -> 113
      //   82: aload_0
      //   83: getfield mBaseTypeToFilter : Ljava/util/HashMap;
      //   86: aload #9
      //   88: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   91: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   94: astore #10
      //   96: aload_0
      //   97: getfield mWildTypeToFilter : Ljava/util/HashMap;
      //   100: aload #9
      //   102: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   105: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   108: astore #9
      //   110: goto -> 140
      //   113: aload_0
      //   114: getfield mTypeToFilter : Ljava/util/HashMap;
      //   117: aload_2
      //   118: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   121: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   124: astore #10
      //   126: aload_0
      //   127: getfield mWildTypeToFilter : Ljava/util/HashMap;
      //   130: aload #9
      //   132: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   135: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   138: astore #9
      //   140: aload_0
      //   141: getfield mWildTypeToFilter : Ljava/util/HashMap;
      //   144: ldc_w '*'
      //   147: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   150: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   153: astore #11
      //   155: aload #9
      //   157: astore #12
      //   159: aload #11
      //   161: astore #9
      //   163: goto -> 201
      //   166: aload_1
      //   167: invokevirtual getAction : ()Ljava/lang/String;
      //   170: ifnull -> 192
      //   173: aload_0
      //   174: getfield mTypedActionToFilter : Ljava/util/HashMap;
      //   177: aload_1
      //   178: invokevirtual getAction : ()Ljava/lang/String;
      //   181: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   184: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   187: astore #10
      //   189: goto -> 195
      //   192: aconst_null
      //   193: astore #10
      //   195: aconst_null
      //   196: astore #12
      //   198: aconst_null
      //   199: astore #9
      //   201: aload #7
      //   203: astore #11
      //   205: aload #5
      //   207: ifnull -> 224
      //   210: aload_0
      //   211: getfield mSchemeToFilter : Ljava/util/HashMap;
      //   214: aload #5
      //   216: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   219: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   222: astore #11
      //   224: aload_2
      //   225: ifnonnull -> 259
      //   228: aload #5
      //   230: ifnonnull -> 259
      //   233: aload_1
      //   234: invokevirtual getAction : ()Ljava/lang/String;
      //   237: ifnull -> 259
      //   240: aload_0
      //   241: getfield mActionToFilter : Ljava/util/HashMap;
      //   244: aload_1
      //   245: invokevirtual getAction : ()Ljava/lang/String;
      //   248: invokevirtual get : (Ljava/lang/Object;)Ljava/lang/Object;
      //   251: checkcast [Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;
      //   254: astore #10
      //   256: goto -> 259
      //   259: aload_1
      //   260: invokestatic getFastIntentCategories : (Landroid/content/Intent;)Lcom/lody/virtual/server/pm/FastImmutableArraySet;
      //   263: astore #7
      //   265: aload #10
      //   267: ifnull -> 287
      //   270: aload_0
      //   271: aload_1
      //   272: aload #7
      //   274: iload_3
      //   275: aload_2
      //   276: aload #5
      //   278: aload #10
      //   280: aload #6
      //   282: iload #4
      //   284: invokespecial buildResolveList : (Landroid/content/Intent;Lcom/lody/virtual/server/pm/FastImmutableArraySet;ZLjava/lang/String;Ljava/lang/String;[Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;Ljava/util/List;I)V
      //   287: aload #12
      //   289: ifnull -> 309
      //   292: aload_0
      //   293: aload_1
      //   294: aload #7
      //   296: iload_3
      //   297: aload_2
      //   298: aload #5
      //   300: aload #12
      //   302: aload #6
      //   304: iload #4
      //   306: invokespecial buildResolveList : (Landroid/content/Intent;Lcom/lody/virtual/server/pm/FastImmutableArraySet;ZLjava/lang/String;Ljava/lang/String;[Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;Ljava/util/List;I)V
      //   309: aload #9
      //   311: ifnull -> 331
      //   314: aload_0
      //   315: aload_1
      //   316: aload #7
      //   318: iload_3
      //   319: aload_2
      //   320: aload #5
      //   322: aload #9
      //   324: aload #6
      //   326: iload #4
      //   328: invokespecial buildResolveList : (Landroid/content/Intent;Lcom/lody/virtual/server/pm/FastImmutableArraySet;ZLjava/lang/String;Ljava/lang/String;[Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;Ljava/util/List;I)V
      //   331: aload #11
      //   333: ifnull -> 353
      //   336: aload_0
      //   337: aload_1
      //   338: aload #7
      //   340: iload_3
      //   341: aload_2
      //   342: aload #5
      //   344: aload #11
      //   346: aload #6
      //   348: iload #4
      //   350: invokespecial buildResolveList : (Landroid/content/Intent;Lcom/lody/virtual/server/pm/FastImmutableArraySet;ZLjava/lang/String;Ljava/lang/String;[Lcom/lody/virtual/server/pm/parser/VPackage$IntentInfo;Ljava/util/List;I)V
      //   353: aload_0
      //   354: aload #6
      //   356: invokevirtual sortResults : (Ljava/util/List;)V
      //   359: aload #6
      //   361: areturn
    }
    
    public List<R> queryIntentFromList(Intent paramIntent, String paramString, boolean paramBoolean, ArrayList<F[]> paramArrayList, int paramInt) {
      ArrayList<R> arrayList = new ArrayList();
      FastImmutableArraySet<String> fastImmutableArraySet = getFastIntentCategories(paramIntent);
      String str = paramIntent.getScheme();
      int i = paramArrayList.size();
      for (byte b = 0; b < i; b++)
        buildResolveList(paramIntent, fastImmutableArraySet, paramBoolean, paramString, str, paramArrayList.get(b), arrayList, paramInt); 
      sortResults(arrayList);
      return arrayList;
    }
    
    public void removeFilter(F paramF) {
      removeFilterInternal(paramF);
      this.mFilters.remove(paramF);
    }
    
    void removeFilterInternal(F paramF) {
      int i = unregister_intent_filter(paramF, ((VPackage.IntentInfo)paramF).filter.schemesIterator(), this.mSchemeToFilter, "      Scheme: ");
      int j = unregister_mime_types(paramF, "      Type: ");
      if (i == 0 && j == 0)
        unregister_intent_filter(paramF, ((VPackage.IntentInfo)paramF).filter.actionsIterator(), this.mActionToFilter, "      Action: "); 
      if (j != 0)
        unregister_intent_filter(paramF, ((VPackage.IntentInfo)paramF).filter.actionsIterator(), this.mTypedActionToFilter, "      TypedAction: "); 
    }
    
    protected void sortResults(List<R> paramList) {
      Collections.sort(paramList, sResolvePrioritySorter);
    }
    
    private class IteratorWrapper implements Iterator<F> {
      private F mCur;
      
      private Iterator<F> mI;
      
      IteratorWrapper(Iterator<F> param1Iterator) {
        this.mI = param1Iterator;
      }
      
      public boolean hasNext() {
        return this.mI.hasNext();
      }
      
      public F next() {
        VPackage.IntentInfo intentInfo = (VPackage.IntentInfo)this.mI.next();
        this.mCur = (F)intentInfo;
        return (F)intentInfo;
      }
      
      public void remove() {
        F f = this.mCur;
        if (f != null)
          IntentResolver.this.removeFilterInternal(f); 
        this.mI.remove();
      }
    }
  }
  
  
  /* Location:              F:\何章易\项目文件夹\项目24\va\classes_merge.jar!\com\lody\virtual\server\pm\IntentResolver.class
   * Java compiler version: 6 (50.0)
   * JD-Core Version:       1.1.3
   */