public class MyExecution extends Execution {
	public MyExecution() {
		super(ExecutionCategory.CLEANING /* 类别 */, "My execution" /* 名称 */,
				"Executes something" /* 描述，可以使用 html */);
	}
	/**
	* 当用户点击运行按钮时调用此方法
	* @return 成功返回 true，失败返回 false
	*/
	@Override
	public boolean execute(Map<String, Clazz> classes, boolean verbose) {
		classes.values().stream().map(c -> c.node).forEach(c -> {
			// 在这里使用 ASM 的 tree-API 转换类
		});
		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);
			// 将字节码转换为 java.lang.Class
			Class<?> loadedClass = vm.loadClass(c.name.replace('/', '.'), true);
			// 在这里对你的类进行操作
			loadedClass.getMethods()[0].invoke(...);
			return true;
		});
	}
	/**
	* 当 VM.loadClass 被调用时，VM 会调用此方法
	*/
	@Override
	public ClassNode tryClassLoad(String name) {
		// 尝试在打开的 jar 存档中找到要加载的类
		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 -> {
			// 此分析器保留已知的栈值，例如可用于跳转预测
			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("在 " + cn.name + "." + m.name + " 中栈分析失败:" + e.getMessage());
				return;
			}
			Frame<ConstantValue>[] frames = a.getFrames();
			InsnList rewrittenCode = new InsnList();
			Map<LabelNode, LabelNode> labels = Instructions.cloneLabels(m.instructions);

			// 重写方法指令
			for (int i = 0; i < m.instructions.size(); i++) {
				AbstractInsnNode ain = m.instructions.get(i);
				Frame<ConstantValue> frame = frames[i];
				// 替换/修改指令等...
				if (frame.getStackSize() > 0) {
					ConstantValue top = frame.getStack(frame.getStackSize() - 1);
					if (top.isKnown() && top.isInteger()) {
						int knownTopStackValue = top.getInteger();
						// 使用已知栈值移除跳转，简化代码等...
						// if(...) { rewrittenCode.add(...); }
						continue;
					}
				}
				rewrittenCode.add(ain.clone(labels));
			}
			// 更新指令并修复 try-catch 块、局部变量等...
			Instructions.updateInstructions(m, labels, rewrittenCode);
		});
	}
	/**
	 * 使用此方法在加载字段时预测栈值
	 */
	@Override
	public Object getFieldValueOrNull(BasicValue v, String owner, String name, String desc) {
		return null;
	}
	/**
	 * 使用此方法在已知对象上调用方法时预测栈值
	 */
	@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()) {
				// 调用目标未知，无法计算返回值
				return null;
			}
			return ((String) values.get(0).getValue()).toCharArray();
		}
		return null;
	}
}