{
    "list":
    [
        {
            "key":"nop",
            "title":"nop",
            "demo":"无操作"
        },
        {
            "key":"move",
            "title":"move vx, vy",
            "demo":"移动 vy 的内容到 vx。两个寄存器都必须在最初的 256 寄存器范围以内。"
        },
        {
            "key":"move/from16",
            "title":"move/from16 vx, vy",
            "demo":"移动 vy 的内容到 vx。vy 可能在 64K 寄存器范围以内，而 vx 则是在最初的 256 寄存器范围以内。"
        },
        {
            "key":"move/16",
            "title":"move/16",
            "demo":"未知"
        },
        {
            "key":"move-wide",
            "title":"move-wide",
            "demo":"未知"
        },
        {
            "key":"move-wide/from16",
            "title":"move-wide/from16 vx, vy",
            "demo":"移动一个 long/double 值，从 vy 到 vx。vy 可能在 64K 寄存器范围以内，而 vx 则是在最初的 256 寄存器范围以内。"
        },
        {
            "key":"move-wide/16",
            "title":"move-wide/16",
            "demo":"未知"
        },
        {
            "key":"move-object",
            "title":"move-object vx, vy",
            "demo":"移动对象引用，从 vy 到 vx。"
        },
        {
            "key":"move-object/from16",
            "title":"move-object/from16 vx, vy",
            "demo":"移动对象引用，从 vy 到 vx。vy 可以处理 64K 寄存器地址，vx 可以处理 256 寄存器地址。"
        },
        {
            "key":"move-object/16",
            "title":"move-object/16",
            "demo":"未知"
        },
        {
            "key":"move-result",
            "title":"move-result vx",
            "demo":"移动上一次方法调用的返回值到 vx。"
        },
        {
            "key":"move-result-wide",
            "title":"move-result-wide vx",
            "demo":"移动上一次方法调用的 long/double 型返回值到 vx, vx+1。"
        },
        {
            "key":"move-result-object",
            "title":"move-result-object vx",
            "demo":"移动上一次方法调用的对象引用返回值到 vx。"
        },
        {
            "key":"move-exception",
            "title":"move-exception vx",
            "demo":"当方法调用抛出异常时移动异常对象引用到 vx。"
        },
        {
            "key":"return-void",
            "title":"return-void",
            "demo":"返回空值。"
        },
        {
            "key":"return",
            "title":"return vx",
            "demo":"返回在 vx 寄存器的值。"
        },
        {
            "key":"return-wide",
            "title":"return-wide vx",
            "demo":"返回在 vx, vx + 1 寄存器的 double/long 值。"
        },
        {
            "key":"return-object",
            "title":"return-object vx",
            "demo":"返回在 vx 寄存器的对象引用。"
        },
        {
            "key":"const/4",
            "title":"const/4 vx, lit4",
            "demo":"存入 4 位常量到 vx。"
        },
        {
            "key":"const/16",
            "title":"const/16 vx, lit16",
            "demo":"存入 16 位常量到 vx。"
        },
        {
            "key":"const",
            "title":"const vx, lit32",
            "demo":"存入 int 型常量到 vx。"
        },
        {
            "key":"const/high16",
            "title":"const/high16 v0, lit16",
            "demo":"存入 16 位常量到最高位寄存器，用于初始化 float 值。"
        },
        {
            "key":"const-wide/16",
            "title":"const-wide/16 vx, lit16",
            "demo":"存入 int 常量到 vx, vx + 1 寄存器，扩展 int 型常量为 long 常量。"
        },
        {
            "key":"const-wide/32",
            "title":"const-wide/32 vx, lit32",
            "demo":"存入 32 位常量到 vx, vx + 1 寄存器，扩展 int 型常量到 long 常量。"
        },
        {
            "key":"const-wide",
            "title":"const-wide vx, lit64",
            "demo":"存入 64 位常量到 vx, vx + 1 寄存器。"
        },
        {
            "key":"const-wide/high16",
            "title":"const-wide/high16 vx, lit16",
            "demo":"存入 16 位常量到最高 16 位的 vx, vx + 1 寄存器，用于初始化 double 值。"
        },
        {
            "key":"const-string",
            "title":"const-string vx, 字符串ID",
            "demo":"存入字符串常量引用到 vx，通过字符串ID或字符串。"
        },
        {
            "key":"const-string-jumbo",
            "title":"const-string-jumbo",
            "demo":"未知"
        },
        {
            "key":"const-class",
            "title":"const-class vx, 类型ID",
            "demo":"存入类对象常量到 vx，通过类型ID或类型（如 Object.class）。"
        },
        {
            "key":"monitor-enter",
            "title":"monitor-enter vx",
            "demo":"获得 vx 寄存器中的对象引用的监视器。"
        },
        {
            "key":"monitor-exit",
            "title":"monitor-exit vx",
            "demo":"释放 vx 寄存器中的对象引用的监视器。"
        },
        {
            "key":"check-cast",
            "title":"check-cast vx, 类型ID",
            "demo":"检查 vx 寄存器中的对象引用是否可以转换成类型ID对应类型的实例。如不可转换，抛出 ClassCastException 异常，否则继续执行。"
        },
        {
            "key":"instance-of",
            "title":"instance-of vx, vy, 类型ID",
            "demo":"检查 vy 寄存器中的对象引用是否是类型ID对应类型的实例，如果是，vx 存入非 0 值，否则 vx 存入 0。"
        },
        {
            "key":"array-length",
            "title":"array-length vx, vy",
            "demo":"计算 vy 寄存器中数组引用的元素长度并将长度存入 vx。"
        },
        {
            "key":"new-instance",
            "title":"new-instance vx, 类型ID",
            "demo":"根据类型ID或类型新建一个对象实例，并将新建的对象的引用存入 vx。"
        },
        {
            "key":"new-array",
            "title":"new-array vx, vy, 类型ID",
            "demo":"根据类型ID或类型新建一个数组，vy 存入数组的长度，vx 存入数组的引用。"
        },
        {
            "key":"filled-new-array",
            "title":"filled-new-array {参数}, 类型ID",
            "demo":"根据类型ID或类型新建一个数组并通过参数填充。新的数组引用可以得到一个 move-result-object 指令，前提是执行过 filled-new-array 指令。"
        },
        {
            "key":"filled-new-array-range",
            "title":"filled-new-array-range {vx..vy}, 类型ID",
            "demo":"根据类型ID或类型新建一个数组并以寄存器范围为参数填充。新的数组引用可以得到一个 move-result-object 指令，前提是执行过 filled-new-array 指令。"
        },
        {
            "key":"fill-array-data",
            "title":"fill-array-data vx, 偏移量",
            "demo":"用 vx 的静态数据填充数组引用。静态数据的位址是当前指令位置加偏移量的和。"
        },
        {
            "key":"throw",
            "title":"throw vx",
            "demo":"抛出异常对象，异常对象的引用在 vx 寄存器。"
        },
        {
            "key":"goto",
            "title":"goto 目标",
            "demo":"通过短偏移量无条件跳转到目标。"
        },
        {
            "key":"goto/16",
            "title":"goto/16 目标",
            "demo":"通过 16 位偏移量无条件跳转到目标。"
        },
        {
            "key":"goto/32",
            "title":"goto/32 目标",
            "demo":"通过 32 位偏移量无条件跳转到目标。"
        },
        {
            "key":"packed-switch",
            "title":"packed-switch vx, 索引表偏移量",
            "demo":"实现一个 switch 语句，case 常量是连续的。这个指令使用索引表，vx 是在表中找到具体 case 的指令偏移量的索引，如果无法在表中找到 vx 对应的索引将继续执行下一个指令（即 default case）。"
        },
        {
            "key":"sparse-switch",
            "title":"sparse-switch vx, 查询表偏移量",
            "demo":"实现一个 switch 语句，case 常量是非连续的。这个指令使用查询表，用于表示 case 常量和每个 case 常量的偏移量。如果 vx 无法在表中匹配将继续执行下一个指令（即 default case）。"
        },
        {
            "key":"cmpl-float",
            "title":"cmpl-float vx, vy, vz",
            "demo":"比较 vy 和 vz 的 float 值并在 vx 存入 int 型返回值。非数值默认为小于。如果参数为非数值将返回-1。"
        },
        {
            "key":"cmpg-float",
            "title":"cmpg-float vx, vy, vz",
            "demo":"比较 vy 和 vz 的 float 值并在 vx 存入 int 型返回值。非数值默认为大于。如果参数为非数值将返回1。"
        },
        {
            "key":"cmpl-double",
            "title":"cmpl-double vx, vy, vz",
            "demo":"比较 vy 和 vz 的 double 值并在 vx 存入 int 型返回值。非数值默认为小于。如果参数为非数值将返回-1。"
        },
        {
            "key":"cmpg-double",
            "title":"cmpg-double vx, vy, vz",
            "demo":"比较 vy 和 vz 的 double 值并在 vx 存入 int 型返回值。非数值默认为大于。如果参数为非数值将返回1。"
        },
        {
            "key":"cmp-long",
            "title":"cmp-long vx, vy, vz",
            "demo":"比较 vy 和 vz 的 long 值并在 vx 存入 int 型返回值。"
        },
        {
            "key":"if-eq",
            "title":"if-eq vx,vy, 目标",
            "demo":"如果 vx == vy，跳转到目标。vx 和 vy 是 int 型值。"
        },
        {
            "key":"if-ne",
            "title":"if-ne vx,vy, 目标",
            "demo":"如果 vx != vy，跳转到目标。vx 和 vy 是 int 型值。"
        },
        {
            "key":"if-lt",
            "title":"if-lt vx,vy, 目标",
            "demo":"如果 vx < vy，跳转到目标。vx 和 vy 是 int 型值。"
        },
        {
            "key":"if-ge",
            "title":"if-ge vx, vy, 目标",
            "demo":"如果 vx >= vy，跳转到目标。vx 和 vy 是 int 型值。"
        },
        {
            "key":"if-gt",
            "title":"if-gt vx,vy, 目标",
            "demo":"如果 vx > vy，跳转到目标。vx 和 vy 是 int 型值。"
        },
        {
            "key":"if-le",
            "title":"if-le vx,vy, 目标",
            "demo":"如果 vx <= vy，跳转到目标。vx 和 vy 是 int 型值。"
        },
        {
            "key":"if-eqz",
            "title":"if-eqz vx, 目标",
            "demo":"如果 vx == 0，跳转到目标。vx 是 int 型值。"
        },
        {
            "key":"if-nez",
            "title":"if-nez vx, 目标",
            "demo":"如果 vx != 0，跳转到目标。"
        },
        {
            "key":"if-ltz",
            "title":"if-ltz vx, 目标",
            "demo":"如果 vx < 0，跳转到目标。"
        },
        {
            "key":"if-gez",
            "title":"if-gez vx, 目标",
            "demo":"如果vx >= 0，跳转到目标。"
        },
        {
            "key":"if-gtz",
            "title":"if-gtz vx, 目标",
            "demo":"如果vx > 0，跳转到目标。"
        },
        {
            "key":"if-lez",
            "title":"if-lez vx, 目标",
            "demo":"如果vx <= 0，跳转到目标。"
        },
        {
            "key":"aget",
            "title":"aget vx, vy, vz",
            "demo":"从 int 数组获取一个 int 型值到 vx，对象数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aget-wide",
            "title":"aget-wide vx, vy, vz",
            "demo":"从 long/double 数组获取一个 long/double 值到 vx, vx + 1，数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aget-object",
            "title":"aget-object vx, vy, vz",
            "demo":"从对象引用数组获取一个对象引用到 vx，对象数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aget-boolean",
            "title":"aget-boolean vx, vy, vz",
            "demo":"从 boolean 数组获取一个 boolean 值到 vx，数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aget-byte",
            "title":"aget-byte vx, vy, vz",
            "demo":"从 byte 数组获取一个 byte 值到 vx，数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aget-char",
            "title":"aget-char vx, vy, vz",
            "demo":"从 char 数组获取一个 char 值到 vx，数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aget-short",
            "title":"aget-short vx, vy, vz",
            "demo":"从 short 数组获取一个 short 值到 vx，数组的引用位于 vy，需获取的元素的索引位于 vz。"
        },
        {
            "key":"aput",
            "title":"aput vx, vy, vz",
            "demo":"将 vx 的 int 值作为元素存入 int 数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"aput-wide",
            "title":"aput-wide vx, vy, vz",
            "demo":"将 vx, vx + 1的 double/long 值作为元素存入 double/long 数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"aput-object",
            "title":"aput-object vx, vy, vz",
            "demo":"将 vx 的对象引用作为元素存入对象引用数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"aput-boolean",
            "title":"aput-boolean vx, vy, vz",
            "demo":"将 vx 的 boolean 值作为元素存入 boolean 数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"aput-byte",
            "title":"aput-byte vx, vy, vz",
            "demo":"将 vx 的 byte 值作为元素存入 byte 数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"aput-char",
            "title":"aput-char vx, vy, vz",
            "demo":"将 vx 的 char 值作为元素存入 char 数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"aput-short",
            "title":"aput-short vx, vy, vz",
            "demo":"将 vx 的 short 值作为元素存入 short 数组，数组的引用位于 vy，元素的索引位于 vz。"
        },
        {
            "key":"iget",
            "title":"iget vx, vy, 字段ID",
            "demo":"根据字段ID读取实例的 int 型字段到 vx，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iget-wide",
            "title":"iget-wide vx, vy, 字段ID",
            "demo":"根据字段ID读取实例的 double/long 型字段到 vx, vx + 1，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iget-object",
            "title":"iget-object vx, vy, 字段ID",
            "demo":"根据字段ID读取一个实例的对象引用字段到 vx，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iget-boolean",
            "title":"iget-boolean vx, vy, 字段ID",
            "demo":"根据字段ID读取实例的 boolean 型字段到 vx，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iget-byte",
            "title":"iget-byte vx, vy, 字段ID",
            "demo":"根据字段ID读取实例的 byte 型字段到 vx，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iget-char",
            "title":"iget-char vx, vy, 字段ID",
            "demo":"根据字段ID读取实例的 char 型字段到 vx，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iget-short",
            "title":"iget-short vx, vy, 字段ID",
            "demo":"根据字段ID读取实例的 short 型字段到 vx，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput",
            "title":"iput vx, vy, 字段ID",
            "demo":"根据字段ID将 vx 寄存器的值存入实例的 int 型字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput-wide",
            "title":"iput-wide vx, vy, 字段ID",
            "demo":"根据字段ID将 vx, vx + 1 寄存器的值存入实例的 double/long 型字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput-object",
            "title":"iput-object vx, vy, 字段ID",
            "demo":"根据字段ID将 vx 寄存器的值存入实例的对象引用字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput-boolean",
            "title":"iput-boolean vx, vy, 字段ID",
            "demo":"根据字段ID将 vx 寄存器的值存入实例的 boolean 型字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput-byte",
            "title":"iput-byte vx, vy, 字段ID",
            "demo":"根据字段ID将 vx 寄存器的值存入实例的 byte 型字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput-char",
            "title":"iput-char vx, vy, 字段ID",
            "demo":"根据字段ID将 vx 寄存器的值存入实例的 char 型字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"iput-short",
            "title":"iput-short vx, vy, 字段ID",
            "demo":"根据字段ID将 vx 寄存器的值存入实例的 short 型字段，vy 寄存器中是该实例的引用。"
        },
        {
            "key":"sget",
            "title":"sget vx, 字段ID",
            "demo":"根据字段ID读取静态 int 型字段到 vx。"
        },
        {
            "key":"sget-wide",
            "title":"sget-wide vx, 字段ID",
            "demo":"根据字段ID读取静态 double/long 型字段到 vx, vx + 1。"
        },
        {
            "key":"sget-object",
            "title":"sget-object vx, 字段ID",
            "demo":"根据字段ID读取静态对象引用字段到 vx。"
        },
        {
            "key":"sget-boolean",
            "title":"sget-boolean vx, 字段ID",
            "demo":"根据字段ID读取静态 boolean 型字段到 vx。"
        },
        {
            "key":"sget-byte",
            "title":"sget-byte vx, 字段ID",
            "demo":"根据字段ID读取静态 byte 型字段到 vx。"
        },
        {
            "key":"sget-char",
            "title":"sget-char vx, 字段ID",
            "demo":"根据字段ID读取静态 char 型字段到 vx。"
        },
        {
            "key":"sget-short",
            "title":"sget-short vx, 字段ID",
            "demo":"根据字段ID读取静态 short 型字段到 vx。"
        },
        {
            "key":"sput",
            "title":"sput vx, 字段ID",
            "demo":"根据字段ID将 vx 寄存器中的值赋值到 int 型静态字段。"
        },
        {
            "key":"sput-wide",
            "title":"sput-wide vx, 字段ID",
            "demo":"根据字段ID将 vx, vx + 1 寄存器中的值赋值到 double/long 型静态字段。"
        },
        {
            "key":"sput-object",
            "title":"sput-object vx, 字段ID",
            "demo":"根据字段ID将 vx 寄存器中的对象引用赋值到对象引用静态字段。"
        },
        {
            "key":"sput-boolean",
            "title":"sput-boolean vx, 字段ID",
            "demo":"根据字段ID将 vx 寄存器中的值赋值到 boolean 型静态字段。"
        },
        {
            "key":"sput-byte",
            "title":"sput-byte vx, 字段ID",
            "demo":"根据字段ID将 vx 寄存器中的值赋值到 byte 型静态字段。"
        },
        {
            "key":"sput-char",
            "title":"sput-char vx, 字段ID",
            "demo":"根据字段ID将 vx 寄存器中的值赋值到 char 型静态字段。"
        },
        {
            "key":"sput-short",
            "title":"sput-short vx, 字段ID",
            "demo":"根据字段ID将 vx 寄存器中的值赋值到 short 型静态字段。"
        },
        {
            "key":"invoke-virtual",
            "title":"invoke-virtual {参数}, 方法名",
            "demo":"调用带参数的虚拟方法。"
        },
        {
            "key":"invoke-super",
            "title":"invoke-super {参数}, 方法名",
            "demo":"调用带参数的直接父类的虚拟方法。"
        },
        {
            "key":"invoke-direct",
            "title":"invoke-direct {参数}, 方法名",
            "demo":"不解析直接调用带参数的方法。"
        },
        {
            "key":"invoke-static",
            "title":"invoke-static {参数}, 方法名",
            "demo":"调用带参数的静态方法。"
        },
        {
            "key":"invoke-interface",
            "title":"invoke-interface {参数}, 方法名",
            "demo":"调用带参数的接口方法。"
        },
        {
            "key":"invoke-virtual/range",
            "title":"invoke-virtual/range {vx..vy}, 方法名",
            "demo":"调用以寄存器范围为参数的虚拟方法。该指令第一个寄存器和寄存器的数量将传递给方法。"
        },
        {
            "key":"invoke-super/range",
            "title":"invoke-super/range {vx..vy}, 方法名",
            "demo":"调用以寄存器范围为参数的直接父类的虚拟方法。该指令第一个寄存器和寄存器的数量将会传递给方法。"
        },
        {
            "key":"invoke-direct/range",
            "title":"invoke-direct/range {vx..vy}, 方法名",
            "demo":"不解析直接调用以寄存器范围为参数的方法。该指令第一个寄存器和寄存器的数量将会传递给方法。"
        },
        {
            "key":"invoke-static/range",
            "title":"invoke-static/range {vx..vy}, 方法名",
            "demo":"调用以寄存器范围为参数的静态方法。该指令第一个寄存器和寄存器的数量将会传递给方法。"
        },
        {
            "key":"invoke-interface-range",
            "title":"invoke-interface-range {vx..vy}, 方法名",
            "demo":"调用以寄存器范围为参数的接口方法。该指令第一个寄存器和寄存器的数量将会传递给方法。"
        },
        {
            "key":"neg-int",
            "title":"neg-int vx, vy",
            "demo":"计算 vx = -vy 并将结果存入 vx。"
        },
        {
            "key":"not-int",
            "title":"not-int vx, vy",
            "demo":"未知"
        },
        {
            "key":"neg-long",
            "title":"neg-long vx, vy",
            "demo":"计算 vx, vx + 1 = -(vy, vy + 1) 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"not-long",
            "title":"not-long vx, vy",
            "demo":"未知"
        },
        {
            "key":"neg-float",
            "title":"neg-float vx, vy",
            "demo":"计算 vx = -vy 并将结果存入 vx。"
        },
        {
            "key":"neg-double",
            "title":"neg-double vx, vy",
            "demo":"计算 vx, vx + 1 = -(vy, vy + 1) 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"int-to-long",
            "title":"int-to-long vx, vy",
            "demo":"转换 vy 寄存器中的 int 型值为 long 型值存入 vx, vx + 1。"
        },{
            "key":"int-to-float",
            "title":"int-to-float vx, vy",
            "demo":"转换 vy 寄存器中的 int 型值为 float 型值存入 vx。"
        },
        {
            "key":"int-to-double",
            "title":"int-to-double vx, vy",
            "demo":"转换 vy 寄存器中的 int 型值为 double 型值存入 vx, vx + 1。"
        },
        {
            "key":"long-to-int",
            "title":"long-to-int vx, vy",
            "demo":"转换 vy, vy + 1 寄存器中的 long 型值为 int 型值存入 vx。"
        },
        {
            "key":"long-to-float",
            "title":"long-to-float vx, vy",
            "demo":"转换 vy, vy + 1 寄存器中的 long 型值为 float 型值存入 vx。"
        },
        {
            "key":"long-to-double",
            "title":"long-to-double vx, vy",
            "demo":"转换 vy, vy + 1 寄存器中的 long 型值为 double 型值存入 vx, vx + 1。"
        },
        {
            "key":"float-to-int",
            "title":"float-to-int vx, vy",
            "demo":"转换 vy 寄存器中的 float 型值为 int 型值存入 vx。"
        },
        {
            "key":"float-to-long",
            "title":"float-to-long vx, vy",
            "demo":"转换 vy 寄存器中的 float 型值为 long 型值存入 vx, vx + 1。"
        },
        {
            "key":"float-to-double",
            "title":"float-to-double vx, vy",
            "demo":"转换 vy 寄存器中的 float 型值为 double 型值存入 vx, vx + 1。"
        },
        {
            "key":"double-to-int",
            "title":"double-to-int vx, vy",
            "demo":"转换 vy, vy + 1 寄存器中的 double 型值为 int 型值存入 vx。"
        },
        {
            "key":"double-to-long",
            "title":"double-to-long vx, vy",
            "demo":"转换 vy, vy + 1 寄存器中的 double 型值为 long 型值存入 vx, vx + 1。"
        },
        {
            "key":"double-to-float",
            "title":"double-to-float vx, vy",
            "demo":"转换 vy, vy + 1 寄存器中的 double 型值为 float 型值存入 vx。"
        },
        {
            "key":"int-to-byte",
            "title":"int-to-byte vx, vy",
            "demo":"转换 vy 寄存器中的 int 型值为 byte 型值存入 vx。"
        },
        {
            "key":"int-to-char",
            "title":"int-to-char vx, vy",
            "demo":"转换 vy 寄存器中的 int 型值为 char 型值存入 vx。"
        },
        {
            "key":"int-to-short",
            "title":"int-to-short vx, vy",
            "demo":"转换 vy 寄存器中的 int 型值为 short 型值存入 vx。"
        },
        {
            "key":"add-int",
            "title":"add-int vx, vy, vz",
            "demo":"计算 vy + vz 并将结果存入 vx。"
        },
        {
            "key":"sub-int",
            "title":"sub-int vx, vy, vz",
            "demo":"计算 vy - vz 并将结果存入 vx。"
        },
        {
            "key":"mul-int",
            "title":"mul-int vx, vy, vz",
            "demo":"计算 vy * vz 并将结果存入vx。"
        },
        {
            "key":"div-int",
            "title":"div-int vx, vy, vz",
            "demo":"计算 vy / vz 并将结果存入 vx。"
        },
        {
            "key":"rem-int",
            "title":"rem-int vx, vy, vz",
            "demo":"计算 vy 取模 vz 并将结果存入 vx。"
        },
        {
            "key":"and-int",
            "title":"and-int vx, vy, vz",
            "demo":"计算 vy 与 vz 并将结果存入 vx。"
        },
        {
            "key":"or-int",
            "title":"or-int vx, vy, vz",
            "demo":"计算 vy 或 vz 并将结果存入 vx。"
        },
        {
            "key":"xor-int",
            "title":"xor-int vx, vy, vz",
            "demo":"计算 vy 异或 vz 并将结果存入 vx。"
        },
        {
            "key":"shl-int",
            "title":"shl-int vx, vy, vz",
            "demo":"左移 vy，vz 指定移动的位置，结果存入 vx。"
        },
        {
            "key":"shr-int",
            "title":"shr-int vx, vy, vz",
            "demo":"右移 vy，vz 指定移动的位置，结果存入 vx。"
        },
        {
            "key":"ushr-int",
            "title":"ushr-int vx, vy, vz",
            "demo":"无符号右移 vy，vz 指定移动的位置，结果存入 vx。"
        },
        {
            "key":"add-long",
            "title":"add-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 + vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"sub-long",
            "title":"sub-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 - vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"mul-long",
            "title":"mul-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 * vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"div-long",
            "title":"div-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 / vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"rem-long",
            "title":"rem-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 % vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"and-long",
            "title":"and-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 与 vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"or-long",
            "title":"or-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 或 vz, vz + 1并将结果存入 vx, vx + 1。"
        },
        {
            "key":"xor-long",
            "title":"xor-long vx, vy, vz",
            "demo":"计算 vy, vy + 1 异或 vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"shl-long",
            "title":"shl-long vx, vy, vz",
            "demo":"左移 vy, vy + 1，vz 指定移动的位置，结果存入 vx, vx + 1。"
        },
        {
            "key":"shr-long",
            "title":"shr-long vx, vy, vz",
            "demo":"右移 vy, vy + 1，vz 指定移动的位置，结果存入 vx, vx + 1。"
        },
        {
            "key":"ushr-long",
            "title":"ushr-long vx, vy, vz",
            "demo":"无符号右移 vy, vy + 1，vz 指定移动的位置，结果存入 vx, vx + 1。"
        },
        {
            "key":"add-float",
            "title":"add-float vx, vy, vz",
            "demo":"计算 vy + vz 并将结果存入 vx。"
        },
        {
            "key":"sub-float",
            "title":"sub-float vx, vy, vz",
            "demo":"计算 vy - vz 并将结果存入 vx。"
        },
        {
            "key":"mul-float",
            "title":"mul-float vx, vy, vz",
            "demo":"计算 vy * vz 并将结果存入 vx。"
        },
        {
            "key":"div-float",
            "title":"div-float vx, vy, vz",
            "demo":"计算 vy / vz 并将结果存入 vx。"
        },
        {
            "key":"rem-float",
            "title":"rem-float vx, vy, vz",
            "demo":"计算 vy % vz 并将结果存入 vx。"
        },
        {
            "key":"add-double",
            "title":"add-double vx, vy, vz",
            "demo":"计算 vy,vy + 1 + vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"sub-double",
            "title":"sub-double vx, vy, vz",
            "demo":"计算 vy, vy + 1 - vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"mul-double",
            "title":"mul-double vx, vy, vz",
            "demo":"计算 vy, vy + 1 * vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"div-double",
            "title":"div-double vx, vy, vz",
            "demo":"计算 vy, vy + 1 / vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"rem-double",
            "title":"rem-double vx, vy, vz",
            "demo":"计算 vy, vy + 1 % vz, vz + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"add-int/2addr",
            "title":"add-int/2addr vx, vy",
            "demo":"计算 vx + vy 并将结果存入 vx。"
        },
        {
            "key":"sub-int/2addr",
            "title":"sub-int/2addr vx, vy",
            "demo":"计算 vx - vy 并将结果存入 vx。"
        },
        {
            "key":"mul-int/2addr",
            "title":"mul-int/2addr vx, vy",
            "demo":"计算 vx * vy 并将结果存入 vx。"
        },
        {
            "key":"div-int/2addr",
            "title":"div-int/2addr vx, vy",
            "demo":"计算 vx / vy 并将结果存入 vx。"
        },
        {
            "key":"rem-int/2addr",
            "title":"rem-int/2addr vx, vy",
            "demo":"计算 vx % vy 并将结果存入 vx。"
        },
        {
            "key":"and-int/2addr",
            "title":"and-int/2addr vx, vy",
            "demo":"计算 vx 与 vy 并将结果存入 vx。"
        },
        {
            "key":"or-int/2addr",
            "title":"or-int/2addr vx, vy",
            "demo":"计算 vx 或 vy 并将结果存入 vx。"
        },
        {
            "key":"xor-int/2addr",
            "title":"xor-int/2addr vx, vy",
            "demo":"计算 vx 异或 vy 并将结果存入 vx。"
        },
        {
            "key":"shl-int/2addr",
            "title":"shl-int/2addr vx, vy",
            "demo":"左移 vx，vy 指定移动的位置，并将结果存入 vx。"
        },
        {
            "key":"shr-int/2addr",
            "title":"shr-int/2addr vx, vy",
            "demo":"右移 vx，vy 指定移动的位置，并将结果存入 vx。"
        },
        {
            "key":"ushr-int/2addr",
            "title":"ushr-int/2addr vx, vy",
            "demo":"无符号右移 vx，vy 指定移动的位置，并将结果存入 vx。"
        },
        {
            "key":"add-long/2addr",
            "title":"add-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 + vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"sub-long/2addr",
            "title":"sub-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 - vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"mul-long/2addr",
            "title":"mul-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 * vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"div-long/2addr",
            "title":"div-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 / vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"rem-long/2addr",
            "title":"rem-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 % vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"and-long/2addr",
            "title":"and-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 与 vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"or-long/2addr",
            "title":"or-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 或 vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"xor-long/2addr",
            "title":"xor-long/2addr vx, vy",
            "demo":"计算 vx, vx + 1 异或 vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"shl-long/2addr",
            "title":"shl-long/2addr vx, vy",
            "demo":"左移 vx, vx + 1，vy 指定移动的位置，并将结果存入 vx, vx + 1。"
        },
        {
            "key":"shr-long/2addr",
            "title":"shr-long/2addr vx, vy",
            "demo":"右移 vx, vx + 1，vy 指定移动的位置，并将结果存入 vx, vx + 1。"
        },
        {
            "key":"ushr-long/2addr",
            "title":"ushr-long/2addr vx, vy",
            "demo":"无符号右移 vx, vx + 1，vy 指定移动的位置，并将结果存入 vx, vx + 1。"
        },
        {
            "key":"add-float/2addr",
            "title":"add-float/2addr vx, vy",
            "demo":"计算 vx + vy 并将结果存入 vx。"
        },
        {
            "key":"sub-float/2addr",
            "title":"sub-float/2addr vx, vy",
            "demo":"计算 vx - vy 并将结果存入 vx。"
        },
        {
            "key":"mul-float/2addr",
            "title":"mul-float/2addr vx, vy",
            "demo":"计算 vx * vy 并将结果存入 vx。"
        },
        {
            "key":"div-float/2addr",
            "title":"div-float/2addr vx, vy",
            "demo":"计算 vx / vy 并将结果存入 vx。"
        },
        {
            "key":"rem-float/2addr",
            "title":"rem-float/2addr vx, vy",
            "demo":"计算 vx % vy 并将结果存入 vx。"
        },
        {
            "key":"add-double/2addr",
            "title":"add-double/2addr vx, vy",
            "demo":"计算 vx, vx + 1 + vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"sub-double/2addr",
            "title":"sub-double/2addr vx, vy",
            "demo":"计算 vx, vx + 1 - vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"mul-double/2addr",
            "title":"mul-double/2addr vx, vy",
            "demo":"计算 vx, vx + 1 * vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"div-double/2addr",
            "title":"div-double/2addr vx, vy",
            "demo":"计算 vx, vx + 1 / vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"rem-double/2addr",
            "title":"rem-double/2addr vx, vy",
            "demo":"计算 vx, vx + 1 % vy, vy + 1 并将结果存入 vx, vx + 1。"
        },
        {
            "key":"add-int/lit16",
            "title":"add-int/lit16 vx, vy, lit16",
            "demo":"计算 vy + lit16 并将结果存入 vx。"
        },
        {
            "key":"sub-int/lit16",
            "title":"sub-int/lit16 vx, vy, lit16",
            "demo":"计算 vy - lit16 并将结果存入 vx。"
        },
        {
            "key":"mul-int/lit16",
            "title":"mul-int/lit16 vx, vy, lit16",
            "demo":"计算 vy * lit16 并将结果存入 vx。"
        },
        {
            "key":"div-int/lit16",
            "title":"div-int/lit16 vx, vy, lit16",
            "demo":"计算 vy / lit16 并将结果存入 vx。"
        },
        {
            "key":"rem-int/lit16",
            "title":"rem-int/lit16 vx, vy, lit16",
            "demo":"计算 vy % lit16 并将结果存入 vx。"
        },
        {
            "key":"and-int/lit16",
            "title":"and-int/lit16 vx, vy, lit16",
            "demo":"计算 vy 与 lit16 并将结果存入 vx。"
        },
        {
            "key":"or-int/lit16",
            "title":"or-int/lit16 vx, vy, lit16",
            "demo":"计算 vy 或 lit16 并将结果存入 vx。"
        },
        {
            "key":"xor-int/lit16",
            "title":"xor-int/lit16 vx, vy, lit16",
            "demo":"计算 vy 异或 lit16 并将结果存入 vx。"
        },
        {
            "key":"add-int/lit8",
            "title":"add-int/lit8 vx, vy, lit8",
            "demo":"计算 vy + lit8 并将结果存入 vx。"
        },
        {
            "key":"sub-int/lit8",
            "title":"sub-int/lit8 vx, vy, lit8",
            "demo":"计算 vy - lit8 并将结果存入 vx。"
        },
        {
            "key":"mul-int/lit8",
            "title":"mul-int/lit8 vx, vy, lit8",
            "demo":"计算 vy * lit8 并将结果存入 vx。"
        },
        {
            "key":"div-int/lit8",
            "title":"div-int/lit8 vx, vy, lit8",
            "demo":"计算 vy / lit8 并将结果存入 vx。"
        },
        {
            "key":"rem-int/lit8",
            "title":"rem-int/lit8 vx, vy, lit8",
            "demo":"计算 vy % lit8 并将结果存入 vx。"
        },
        {
            "key":"and-int/lit8",
            "title":"and-int/lit8 vx, vy, lit8",
            "demo":"计算 vy 与 lit8 并将结果存入 vx。"
        },
        {
            "key":"or-int/lit8",
            "title":"or-int/lit8 vx, vy, lit8",
            "demo":"计算 vy 或 lit8 并将结果存入 vx。"
        },
        {
            "key":"xor-int/lit8",
            "title":"xor-int/lit8 vx, vy, lit8",
            "demo":"计算 vy 异或 lit8 并将结果存入 vx。"
        },
        {
            "key":"shl-int/lit8",
            "title":"shl-int/lit8 vx, vy, lit8",
            "demo":"左移 vy，lit8 指定移动的位置，并将结果存入 vx。"
        },
        {
            "key":"shr-int/lit8",
            "title":"shr-int/lit8 vx, vy, lit8",
            "demo":"右移 vy，lit8 指定移动的位置，并将结果存入 vx。"
        },
        {
            "key":"ushr-int/lit8",
            "title":"ushr-int/lit8 vx, vy, lit8",
            "demo":"无符号右移 vy，lit8 指定移动的位置，并将结果存入 vx。"
        },
        {
            "key":"execute-inline",
            "title":"execute-inline {参数}, 内联ID",
            "demo":"根据内联ID执行内联方法。"
        },
        {
            "key":"invoke-direct-empty",
            "title":"invoke-direct-empty",
            "demo":"用于空方法的占位符，如 Object.<init>。这相当于正常执行了 nop 指令。"
        },
        {
            "key":"iget-quick",
            "title":"iget-quick vx, vy, 偏移量",
            "demo":"获取 vy 寄存器中实例指向 + 偏移位置的数据区的值，存入vx。"
        },
        {
            "key":"iget-wide-quick",
            "title":"iget-wide-quick vx, vy, 偏移量",
            "demo":"获取 vy 寄存器中实例指向 + 偏移位置的数据区的值，存入 vx, vx + 1。"
        },
        {
            "key":"iget-object-quick",
            "title":"iget-object-quick vx, vy, 偏移量",
            "demo":"获取 vy 寄存器中实例指向 + 偏移位置的数据区的对象引用，存入 vx。"
        },
        {
            "key":"iput-quick",
            "title":"iput-quick vx, vy, 偏移量",
            "demo":"将 vx 寄存器中的值存入 vy 寄存器中的实例指向 + 偏移位置的数据区。"
        },
        {
            "key":"iput-wide-quick",
            "title":"iput-wide-quick vx, vy, 偏移量",
            "demo":"将 vx, vx + 1 寄存器中的值存入 vy 寄存器中的实例指向 + 偏移位置的数据区。"
        },
        {
            "key":"iput-object-quick",
            "title":"iput-object-quick vx, vy, 偏移量",
            "demo":"将 vx 寄存器中的对象引用存入 vy 寄存器中的实例指向 + 偏移位置的数据区。"
        },
        {
            "key":"invoke-virtual-quick",
            "title":"invoke-virtual-quick {参数}, 虚拟表偏移量",
            "demo":"调用虚拟方法，使用目标对象虚拟表。"
        },
        {
            "key":"invoke-virtual-quick/range",
            "title":"invoke-virtual-quick/range {参数范围}, 虚拟表偏移量",
            "demo":"调用虚拟方法，使用目标对象虚拟表。"
        },
        {
            "key":"invoke-super-quick",
            "title":"invoke-super-quick {参数}, 虚拟表偏移量",
            "demo":"调用父类虚拟方法，使用目标对象的直接父类的虚拟表。"
        },
        {
            "key":"invoke-super-quick/range",
            "title":"invoke-super-quick/range {参数范围}, 虚拟表偏移量",
            "demo":"调用父类虚拟方法，使用目标对象的直接父类的虚拟表。"
        }
    ]
}