How to use org.jf.util

  @Override
  public boolean writeTo(IndentingWriter writer) throws IOException {
    writer.write("#@");
    writer.printUnsignedLongAsHex(codeAddress & 0xFFFFFFFFL);
    return true;
  }
});

public int getPackedSwitchBaseAddress(int packedSwitchPayloadCodeOffset) {
  return packedSwitchMap.get(packedSwitchPayloadCodeOffset, -1);
}

public List<AnalyzedInstruction> getAnalyzedInstructions() {
  return analyzedInstructions.getValues();
}

  protected void writeVtableIndex(IndentingWriter writer) throws IOException {
    writer.write("vtable@");
    writer.printSignedIntAsDec(((VtableIndexInstruction)instruction).getVtableIndex());
  }
}

@Override
public void write(char[] chars) throws IOException {
  //synchronized(lock) {
    for (char chr: chars) {
      write(chr);
    }
  //}
}

private static int getTypeSize(char type) {
  switch (type) {
    case 'J':
    case 'D':
      return 8;
    case '[':
    case 'L':
    case 'I':
    case 'F':
      return 4;
    case 'C':
    case 'S':
      return 2;
    case 'B':
    case 'Z':
      return 1;
  }
  throw new ExceptionWithContext("Invalid type: %s", type);
}

private static void usage(Options options) {
  HelpFormatter formatter = new HelpFormatter();
  int consoleWidth = ConsoleUtil.getConsoleWidth();
  if (consoleWidth <= 0) {
    consoleWidth = 80;
  }
  formatter.setWidth(consoleWidth);
  formatter.printHelp("java -jar simplify.jar <input> [options]", "deobfuscates a dalvik executable", options, "");
}

public ClassFileNameHandler(File path, String fileExtension) {
  this.top = new PackageNameEntry(path);
  this.fileExtension = fileExtension;
  this.modifyWindowsReservedFilenames = testForWindowsReservedFileNames(path);
}

@Override
public int getRegisterC() {
  return NibbleUtils.extractLowUnsignedNibble(dexFile.readUbyte(instructionStart + 4));
}

  public FileSystemEntry makeVirtual(File parent) {
    return new VirtualGroupEntry(this, parent);
  }
}

  @Override
  public boolean writeTo(IndentingWriter writer) throws IOException {
    writer.write("#@");
    writer.printUnsignedLongAsHex(codeAddress & 0xFFFFFFFFL);
    return true;
  }
});

protected void writeInlineIndex(IndentingWriter writer) throws IOException {
  writer.write("inline@");
  writer.printSignedIntAsDec(((InlineIndexInstruction)instruction).getInlineIndex());
}

@Override
public void write(char[] chars, int start, int len) throws IOException {
  //synchronized(lock) {
    len = start+len;
    while (start < len) {
      write(chars[start++]);
    }
  //}
}

public int getSparseSwitchBaseAddress(int sparseSwitchPayloadCodeOffset) {
  return sparseSwitchMap.get(sparseSwitchPayloadCodeOffset, -1);
}

@Override
public int getRegisterE() {
  return NibbleUtils.extractLowUnsignedNibble(dexFile.readUbyte(instructionStart + 5));
}

public List<Instruction> getInstructions() {
  return Lists.transform(analyzedInstructions.getValues(), new Function<AnalyzedInstruction, Instruction>() {
    @Nullable @Override public Instruction apply(@Nullable AnalyzedInstruction input) {
      if (input == null) {
        return null;
      }
      return input.instruction;
    }
  });
}

protected void writeFieldOffset(IndentingWriter writer) throws IOException {
  writer.write("field@0x");
  writer.printUnsignedLongAsHex(((FieldOffsetInstruction)instruction).getFieldOffset());
}

@Override
public Writer append(char c) throws IOException {
  write(c);
  return this;
}

@Override
public int getRegisterG() {
  return NibbleUtils.extractLowUnsignedNibble(dexFile.readUbyte(instructionStart + 1));
}

private static void writeAccessFlags(IndentingWriter writer, int accessFlags)
    throws IOException {
  for (AccessFlags accessFlag: AccessFlags.getAccessFlagsForMethod(accessFlags)) {
    writer.write(accessFlag.toString());
    writer.write(' ');
  }
}