public class MyExecution extends Execution {
 public MyExecution() {
  super(ExecutionCategory.CLEANING /* category */, "My execution" /* name */,
    "Executes something" /* description, can use html */);
 }
 /**
 * This method is invoked when the user clicks on the Run button
 * @return true if success, false if failure
 */
 @Override
 public boolean execute(Map<String, Clazz> classes, boolean verbose) {
  classes.values().stream().map(c -> c.node).forEach(c -> {
   //transform the classes here using the tree-API of ASM
  });
  return false;
 }
}

public class MyExecution extends Execution implements IVMReferenceHandler {
 public MyExecution() {
  super(ExecutionCategory.GENERIC, "My execution", "Loads ClassNodes at runtime");
 }
 @Override
 public boolean execute(Map<String, Clazz> classes, boolean verbose) {
  classes.values().stream().map(c -> c.node).forEach(c -> {
   VM vm = VM.constructVM(this);
   //transform bytecode to java.lang.Class
   Class<?> loadedClass = vm.loadClass(c.name.replace('/', '.'), true);
   //do stuff with your class here
   loadedClass.getMethods[0].invoke(...);
   return true;
  });
 }
 /**
 * Will get invoked by VM, when VM.loadClass is called
 */
 @Override
 public ClassNode tryClassLoad(String name) {
  //try to find the class to be loaded in open jar archive
  return classes.containsKey(name) ? classes.get(name).node : null;
 }
}

public class MyExecution extends Execution implements IConstantReferenceHandler {
 public MyExecution() {
  super(ExecutionCategory.GENERIC, "My execution", "Performs stack analysis and replaces code.");
 }
 @Override
 public boolean execute(Map<String, Clazz> classes, boolean verbose) {
  classes.values().stream().map(c -> c.node).forEach(this::analyzeAndRewrite);
  return true;
 }
 public void analyzeAndRewrite(ClassNode cn) {
  cn.methods.forEach(m -> {
   // this analyzer keeps known stack values, e.g. can be useful for jump prediction
   Analyzer<ConstantValue> a = new Analyzer<ConstantValue>(new ConstantTracker(this, Access.isStatic(m.access), m.maxLocals, m.desc, new Object[0]));
   try {
    a.analyze(cn.name, m);
   } catch (AnalyzerException e) {
    logger.severe("Failed stack analysis in " + cn.name + "." + m.name + ":" + e.getMessage());
    return;
   }
      Frame<ConstantValue>[] frames = a.getFrames();
   InsnList rewrittenCode = new InsnList();
   Map<LabelNode, LabelNode> labels = Instructions.cloneLabels(m.instructions);

   // rewrite method instructions
   for (int i = 0; i < m.instructions.size(); i++) {
    AbstractInsnNode ain = m.instructions.get(i);
    Frame<ConstantValue> frame = frames[i];
    // replace / modify instructions, etc...
    if (frame.getStackSize() > 0) {
     ConstantValue top = frame.getStack(frame.getStackSize() - 1);
     if (top.isKnown() && top.isInteger()) {
      int knownTopStackValue = top.getInteger();
      // use the known stack to remove jumps, simplify code, etc...
      // if(...) { rewrittenCode.add(...); }
      continue;
     }
    }
    rewrittenCode.add(ain.clone(labels));
   }
   // update instructions and fix try catch blocks, local variables, etc...
   Instructions.upda   teInstructions(m, labels, rewrittenCode);
  });
 }
 /**
  * Use this method to predict stack values if fields are loaded
  */
 @Override
 public Object getFieldValueOrNull(BasicValue v, String owner, String name, String desc) {
  return null;
 }
 /**
  * Use this method to predict stack values if methods are invoked on known objects
  */
 @Override
 public Object getMethodReturnOrNull(BasicValue v, String owner, String name, String desc, List<? extends ConstantValue> values) {
  if (name.equals("toCharArray") && owner.equals("java/lang/String")) {
   if (!values.get(0).isKnown()) {
    // invocation target is not known, we can't compute the return
    return null;
   }
   return ((String) values.get(0).getValue()).toCharArray();
  }
  return null;
 }
}