class ClassInformation {
    public DexEntry<? extends DexFile> dexEntry;
    public ClassDef classDefinition;

    public ClassInformation(DexEntry<? extends DexFile> entry, ClassDef classDef) {
      this.dexEntry = entry;
      this.classDefinition = classDef;
    }
  }

  private final Map<String, ClassInformation> classesToDefItems = new HashMap<String, ClassInformation>();
  private final Collection<DexEntry<? extends DexFile>> dexFiles;

  /**
   * Construct a DexlibWrapper from a dex file and stores its classes referenced by their name. No further process is done
   * here.
   */
  public DexlibWrapper(File dexSource) {
    try {
      List<DexFileProvider.DexContainer<? extends DexFile>> containers = DexFileProvider.v().getDexFromSource(dexSource);
      this.dexFiles = new ArrayList<>(containers.size());
      for (DexFileProvider.DexContainer<? extends DexFile> container : containers) {
        this.dexFiles.add(container.getBase());
      }
    } catch (IOException e) {
      throw new CompilationDeathException("IOException during dex parsing", e);
    }
  }

  /**
   * Allow custom implementations to use different class loading strategies. Do not remove this method.
   *
   * @return
   */
  protected DexClassLoader createDexClassLoader() {
    return new DexClassLoader();
  }

  public void initialize() {<FILL_FUNCTION_BODY>

    // resolve classes in dex files
    for (DexEntry<? extends DexFile> dexEntry : dexFiles) {
      final DexFile dexFile = dexEntry.getDexFile();
      for (ClassDef defItem : dexFile.getClasses()) {
        String forClassName = Util.dottedClassName(defItem.getType());
        classesToDefItems.put(forClassName, new ClassInformation(dexEntry, defItem));
      }
    }

    // It is important to first resolve the classes, otherwise we will
    // produce an error during type resolution.
    for (DexEntry<? extends DexFile> dexEntry : dexFiles) {
      final DexFile dexFile = dexEntry.getDexFile();
      if (dexFile instanceof DexBackedDexFile) {
        for (DexBackedTypeReference typeRef : ((DexBackedDexFile) dexFile).getTypeReferences()) {
          String t = typeRef.getType();

          Type st = DexType.toSoot(t);
          if (st instanceof ArrayType) {
            st = ((ArrayType) st).baseType;
          }
          String sootTypeName = st.toString();
          if (!Scene.v().containsClass(sootTypeName)) {
            if (st instanceof PrimType || st instanceof VoidType || systemAnnotationNames.contains(sootTypeName)) {
              // dex files contain references to the Type IDs of void
              // primitive types - we obviously do not want them
              // to be resolved
              /*
               * dex files contain references to the Type IDs of the system annotations. They are only visible to the Dalvik
               * VM (for reflection, see vm/reflect/Annotations.cpp), and not to the user - so we do not want them to be
               * resolved.
               */
              continue;
            }
            SootResolver.v().makeClassRef(sootTypeName);
          }
          SootResolver.v().resolveClass(sootTypeName, SootClass.SIGNATURES);
        }
      }
    }
  
<no_super_class>