[转载]Dalvik指令集

这篇文章是转载的，为了便于查找一些指令，贴在这里。

转自：http://blog.csdn.net/canfengxiliu/article/details/20144119

---------------------

声明 ： 文章是看<<Android软件安全与逆向分析>>的所写笔记。

Dalvik指令格式

一段Dalvik汇编代码由一系列Dalvik指令组成，指令语法由指令的位描述与指令格式标识来决定。位描述约定如下：

     ● 每16位的字采用空格分隔开来。

     ● 每个字母表示4位，每个字母按顺序从高字节开始，排列到低字节。每4位之间可能使用竖线 “|” 来表示不同的内容。

     ● 顺序采用 A ~ Z 的单个大写字幕作为一个4位的操作码，op表示一个8位的操作码。

     ● “Φ” 来表示这字段所有位为0值。

以指令格式 “A|G|op BBBB F|E|D|C” 为例

指令中间有两个空格，每个分开的部分大小为16位，所以这条指令由三个16位的字组成。

第一个16位是 “A|G|op”，高8位由A与G组成，低字节由操作码op组成。

第二个16位由 BBBB 组成，它表示一个16位的偏移值。

第三个16位分别由F、E、D、C 共4个4字节组成，在这里他们表示寄存器参数。

 

单独使用位表示还无法确定一条指令，必须通过指令格式标识来指定格式的格式编码。它的约定如下：

     ● 指令格式标识大多由三个字符组成，前两个是数字，最后一个是字母。

     ● 第一个数字是表示指令有多少个16位的字组成。

     ● 第二个数字是表示指令最多使用寄存器的个数。特殊标记 “r” 标识使用一定范围内的寄存器。

     ● 第三个字母为类型码，表示指令用到的额外数据的类型。取值见如下表。

助记符	位大小	说　明
b	8	8位有符号立即数
c	16,32	常量池索引
f	16	接口常量（仅对静态链接格式有效）
h	16	有符号立即数（32位或64位数的高值位，低值位为0）
i	32	立即数，有符号整数或32位浮点数
l	64	立即数，有符号整数或64位双精度浮点数
m	16	方法常量（仅对静态链接格式有效）
n	4	4位的立即数
s	16	短整型立即数
t	8, 16, 32	跳转，分支
x	0	无额外数据

以指令格式标识22x 为例：

第一个数字2表示有2个16位字组成，第二个数字2表示指令使用到2个寄存器，第三个字母x表示没有使用到额外的数据。

 

Dalvik指令对语法做了一些说明，它约定如下：

     ● 每条指令从操作码开始，后面紧跟参数，参数个数不定，每个参数之间采用逗号分开。

     ● 每条指令的参数从指令第一部分开始，op位于低8位，高8位可以是一个8位的参数，也可以是两个4位的参数，还可以为空，如果指令超过16位，则后面部分一次作为参数

     ● 如果参数采用 “vX” 的方式表示，表示它是一个寄存器，如v0、v1等。这里采用v而不用r是为了避免与基于该虚拟机架构本身的寄存器名字产生冲突，如ARM架构寄存器命名采用r开头。

     ● 如果参数采用 “#+X” 的方式表示，表明它是一个常量数字。

     ● 如果参数采用 “+X” 的方式表示，表明它是一个相对指令的地址偏移。

     ● 如果参数采用 “kind@X” 的方式表示，表明它是一个常量池的索引值。其中kind表示常量池类型，它可以是 “string” 字符串常量池索引）、“type”（类型常量池索引）、“field”（字段常量池索引）或者 “meth”（方法常量池索引）。

 

在Andorid4.0源码Dalvik/docs 目录下提供了一份文档 instruction-formats.html，里面详细列举了Dalvik指令的所有格式。

 

Dalvik 字节码的类型、方法与字段表示方法

1.类型

语法	含义
V	void, 只用于返回值类型
Z	boolean
B	byte
S	short
C	char
I	int
J	long
F	float
D	double
L	Java类类型
[	数组类型

 

L类型可以表示Java类型中的任何类。这些类在Java代码以package.name.ObjectName方式因一哦那个，到了Dalvik汇编代码中，它们以Lpackage/name/ObjectName;形式表示，注意最后有个分号。

[类型可以表示所有基本类型的数组。[后面紧跟基本类型描述符。如 [I 表示 int [] , [[I 表示 int [][], 以此类推。注意多维数组的维数最大为255个。

 

2.方法

方法格式举例如下：

Lpackage/name/ObjectName;->MethodName（III）Z 

Lpackage/name/ObjectName 为函数属于哪个类的方法。

MethodName为具体的方法名。

(iii)Z 是方法的签名部分，其中III 为方法的参数（在此表示有三个int类型的参数）， Z表示方法的返回类型（boolean类型）

 

3.字段

字段的格式如下：

Lpackage/name/ObjectName;->FieldNmae:Lpackage/name/ObjectName;

字段由类型（Lpackage/name/ObjectName;）、字段名（FieldName）与字段类型（Lpackage/name/ObjectName;）组成。

其中字段名与字段类型中间用冒号 “:” 隔开

BakSmali 生成的字段代码以。field指令开头，根据字段类型的不同，在字段指令的开头可能会用井号 “#” 加以注释， 如 

“# instance fields” 表示这是一个实例字段

“# static fields” 表示这是个静态字段 

 

Dalvik指令的语法与助词符有如下特点：

     1 .参数采用从目标到源的方式。
     2. 根据字节码的大小与类型不同，一些字节码添加了名称后缀以消除歧义
          ● 32位常规类型的字节码未添加任何后缀

● 64常规类型的字节码添加 -wide 后缀
          ● 特殊类型的字节码根据具体类型添加后缀。它们可以是 -boolean、-byte、-char、-short、 -int、-long、-float、-double、-object、-string、-void之一。

     3. 根据字节码的布局与选项不同，一些字节码添加了字节码后缀以消除歧义。这些后缀通过在字节码主名称后缀添加斜杠“/”来分割开。
     4. 在指令集的描述中，宽度值中每个字幕表示宽度为4位。

 

例如这条指令： “move-wide/from16 vAA, vBBBB”

move 为基础字节码。标识这是基本操作。

wide 为名称后缀。标识指令操作的数据宽度（64位）。

from16 为字节码后缀。标识源为一个16位的寄存器引用变量。

vAA 为目的寄存器。它始终在源的前面，取值范围为v0~v255。

vBBBB 为源寄存器。取值范围为v0~v65535

 

Dalvik 指令集中大多数指令用到了寄存器作为目的操作数或源操作数，其中 A/B/C/D/E/F/G/H 代表一个4位的数值， 可用来表示v0~v15的寄存器。 AA/BB/.../HH代表一个8位的数值。 AAAA/BBBB/.../HHHH 代表一个16位的数值

 

空操作指令

空操作指令的助记符为nop。它的值为00，通知被用来作对齐代码之用，无实际操作。

 

数据操作指令

数据操作指令为move。move指令的原型为 move 目标，源。 move 指令根据字节码大小与类型不同，后面会跟上不同的后缀。

move-object/from16 vAA, vBBBB 为对象赋值。源寄存器为8位，目的寄存器为16位。

move-object/16 vAAAA,vBBBB 为对象复制。源寄存器与目的寄存器都为16位

move-result-wide vAA 将上一个invoke类型指令操作的双（没有-wide则是 单 ）字非对象结果赋给vAA寄存器

move-result-object vAA 将上一个invoke类型指令操作的非对象结果赋给vAA寄存器

move-exception vAA 保存一个运行时发生的异常到vAA寄存器。这条指令必须是异常发生屎的异常处理器的一条指令。否则的话，指令无效。

 

返回指令

返回指令指的是函数结尾时运行的最后一条指令。共有以下四条返回指令：

return-void

return vAA

return-wide vAA

return-object vAA

 

数据定义指令

数据定义指令用来定义程序中用到的常量、字符串、类等数据。它的基础字节码为const。

const/4 vA,#+B 将数值符号扩展为32位后赋给寄存器 vA

const/16 vAA,#+BBBB 将数值符号扩展为32位后赋给寄存器 vAA

const vAA,#+BBBBBBBB 将数值付给寄存器vAA

const/high16 vAA,#+BBBB0000 将数值右边 0 扩展为32位后赋给寄存器vAA

const-wide/16 vAA,#+BBBB 将数值符号扩展64位后赋给寄存器对vAA

const-wide vAA,#+BBBBBBBBBBBBBBBB 将数值赋给寄存器对vAA

const-wide/high16 vAA,#+BBBB000000000000 将数值右边 0 扩展为64位后付给寄存器对 vAA

const-string vAA,string@BBBB 通过字符串索引构造一个字符串并赋给寄存器对 vAA

const-string/jumbo vAA,string@BBBBBBBB 通过字符串索引（较大） 构造一个字符串并付给寄存器对vAA

const-class vAA,type@BBBB 通过类型索引获取一个类引用并付给寄存器 vAA

const-class/jumbo vAAAA,type@BBBBBBBB 通过给定的类型那个索引获取一个类索引并付给寄存器vAAAA（这条指令占用两个字节，值为0x00ff，是Android4.0中新增的指令）

 

锁指令

锁指令多用在多线程程序中对同一对象的操作。Dalvik指令集中有两条锁指令。

monitor-enter vAA 为指定的对象获取锁

monitor-exit vAA 释放指定的对象的锁

 

实例操作指令

与实例相关的操作包括实例的类型转换、检查及新建等

check-cast vAA,type@BBBB 将vAA寄存器中的对象引用转换成指定的类型，如果失败会抛出ClassCastException 异常。如果类型B 指定的是基本类型，对于非基本类型的A来说，运行时始终会失败。

instance-of vA,vB,type@CCCC 判断vB寄存器中的对象引用是否可以转换成指定的类型，如果可以vA寄存赋值为1，否则vA寄存器为0

new-instance vAA,type@BBBB 构造一个指定类型对象的新实例,并将对象引用赋值给vAA寄存器,类型符号type指定的类型不能是数组类。

check-cast/jumbo vAAAA,type@BBBBBBBB    instance-of vAAAA, vBBBB, type@CCCCCCCC   new-instance/jumbo vAAAA, type@BBBBBBBB这三个指令功能分别与 上面三个指令分对应 相同，只是寄存器值与指令的索引取值范围坑大（Android4.0中新增的命令）

 

数组操作指令

数组操作包括读取数组长度、新建数组、数组赋值、数组元素取值与赋值等操作。

array-length vA,vB 获取给定vB寄存器中数组的长度并将值赋给vA寄存器，数组长度指的是数组的条目个数。

new-array vA,vB,type@CCCC 构造指定类型（type@CCCC）与大小（vB）的数组，并将值赋给vA寄存器。

new-array/jumbo vAAAA,vBBBB,type@CCCCCCCC 指令功能与上一条指令相同，只是寄存器与指令的索引取值范围更大（Android4.0中新增的指令）

filled-new-array {vC,vD,vE,vF,vG},type@BBBB 构造指定类型（type@BBBB）与大小（vA）的数组并填充数组内容。vA寄存器是隐含使用的，除了指定数组的大小外还制订了参数的个数，vC~vG是使用到的参数寄存器序列

filled-new-array/range {vCCCC, ... ,vNNNN},type@BBBB 指定功能与上一条指令相同，只是参数寄存器使用range字节码后缀指定了取值范围，vC是第一个参数寄存器， N=A+C-1。

filled-new-array/jumbo {vCCCC, ... ,vNNNN},type@BBBBBBBB 指令功能与上一条指令相同，只是寄存器与指令的索引取值范围更大（Android4.0中新增的指令）

fill-array-data vAA, +BBBBBBBB 用指定的数据来填充数组，vAA寄存器为数组引用，引用必须为基础类型的数组，在指令后面会紧跟一个数据表

arrayop vAA,vBB,vCC 对vBB寄存器指定的数组元素进入取值与赋值。vCC寄存器指定数组元素索引，vAA寄存器用来寄放读取的或需要设置的数组元素的值。读取元素使用aget类指令，元素赋值使用aput指令，元素赋值使用aput类指令，根据数组中存储的类型指令后面会紧跟不同的指令后缀，指令列表有aget、aget-wide、aget-object、aget-boolean、aget-byte、aget-char、aget-short、aput、aput-wide、aput-boolean、aput-byte、aput-char、aput-short。

 

异常指令

Dalvik指令集有一条指令用来抛出异常

throw vAA 抛出vAA寄存器中指定类型的异常。

 

跳转指令

跳转指令用于从当前地址跳转到孩子定的偏移处。Dalvik指令集中有三种跳转指令：无条件跳转（goto）、分支跳转（switch）与条件跳转（if）。

goto +AA 无条件跳转到指定偏移处，偏移量AA不能为0

goto/16 +AAAA 无条件跳转到指定偏移处，偏移量AAAA不能为0。

goto/32 +AAAAAAAA 无条件跳转到指定偏移处。

packed-switch vAA,+BBBBBBBB 分支跳转指令。vAA寄存器为switch分支中需要判断的值，BBBBBBBB指向一个packed-switch-payload格式的偏移表，表中的值是有规律递增的。

sparse-switch vAA,+BBBBBBBB 分支跳转指令。vAA寄存器为switch分支中需要判断的值，BBBBBBBB指向一个sparse-switch-payload格式的偏移表，表中的值是无规律的偏移表，表中的值是无规律的偏移量。

if-test vA,vB,+CCCC 条件跳转指令。比较vA寄存器与vB寄存器的值，如果比较结果满足就跳转到CCCC指定的偏移处。偏移量CCCC不能为0。if-test类型的指令有以下几条：

     ● if-eq 如果vA不等于vB则跳转。Java语法表示为 if(vA == vB)

     ● if-ne 如果vA不等于vB则跳转。Java语法表示为 if(vA != vB)

     ● if-lt 如果vA小于vB则跳转。Java语法表示为 if(vA < vB)

     ● if-le 如果vA小于等于vB则跳转。Java语法表示为 if(vA <= vB)

     ● if-gt 如果vA大于vB则跳转。Java语法表示为 if(vA > vB)

     ● if-ge 如果vA大于等于vB则跳转。Java语法表示为 if(vA >= vB)

 

if-testz vAA,+BBBB 条件跳转指令。拿vAA寄存器与 0 比较，如果比较结果满足或值为0时就跳转到BBBB指定的偏移处。偏移量BBBB不能为0。 if-testz类型的指令有一下几条：

     ● if-nez 如果vAA为 0 则跳转。Java语法表示为 if(vAA == 0)

     ● if-eqz 如果vAA不为 0 则跳转。Java语法表示为 if(vAA != 0)

     ● if-ltz 如果vAA小于 0 则跳转。Java语法表示为 if(vAA < 0)

     ● if-lez 如果vAA小于等于 0 则跳转。Java语法表示为 if(vAA <= 0)

     ● if-gtz 如果vAA大于 0 则跳转。Java语法表示为 if(vAA > 0)

     ● if-gez 如果vAA大于等于 0 则跳转。Java语法表示为 if(vAA >= 0)

 

比较指令

比较指令用于两个寄存器的值（浮点型或长整型）进行比较。它的格式为 cmpkind vAA,vBB,vCC，其中vBB寄存器与vCC寄存器是需要比较的两个寄存器或者两个寄存器对，比较的结果放到vAA寄存器。Dalvik指令集中共有 5 条比较指令。

cmpl-float 比较两个单精度浮点数。如果vBB寄存器小于vCC寄存器，则结果为1，相等则结果为0，大于的话结果为-1。

cmpg-float 比较两个单精度浮点数。如果vBB寄存器大于vCC寄存器，则结果为1，相等则结果为0，小于的话结果为-1。

cmpl-double  比较两个双精度浮点数。如果vBB寄存器小于vCC寄存器，则结果为1，相等则结果为0，大于的话结果为-1。

cmpg-double 比较两个双精度浮点数。如果vBB寄存器大于vCC寄存器，则结果为1，相等则结果为0，小于的话结果为-1。

cmp-long 比较两个长整型数。如果vBB寄存器大于vCC寄存器，则结果为1，相等则结果为0，小于的话结果为-1。

 

字段操作指令

字段操作指令用来对对象实例的字段进入读写操作。字段的类型那个可以是Java中有效的数据类型，对普通字段与静态字段操作有两中指令集，分别是iinstanceop vA,vB,field@CCCC 与 sstaticop vAA,field@BBBB

普通字段指令的指令前缀为i，如对普通字段读操作使用iget指令，写操作使用iput指令；静态字段的指令前缀为s，如对静态字段读操作使用sget指令，写操作使用sput指令。

根据访问的字段类型不同，字段操作指令后面会紧跟字段类型的后缀，如iget-byte指令表示读写实例字段的值类型为字节类型，iput-short指令表示设置实例字段的值类型为短整型。两类指令操作结果都是一样的，只是指令前缀与操作的字段类型不同。

普通字段操作指令有：iget、iget-wide、iget-object、iget-boolean、iget-byte、iget-char、iget-short、iput、iput-wide、iput-object、iput-boolean、iput-byte、iput-char、iput-short。

静态字段操作指令有：sget、sget-wide、sget-object、sget-boolean、sget-byte、sget-char、sget-short、sput、sput-wide、sput-object、sput-boolean、sput-byte、sput-char、sput-short。

在Android4.0系统中，Dalvik指令集中增加了 instanceop/jumbo vAAAA,vBBBB,field@CCCCCCCC 与sstaticop/jumbo vAAAA,field@BBBBBBBB 两类指令，它们与上面介绍的两类指令作用相同，只是在指令中增加了jumbo字节码后缀，且寄存器值与指令的索引取值范围更大。

 

方法调用指令

方法调用指令负责调用类实例的方法。它的基础指令为invoke，方法嗲用指令有 invoke-kind {vC,vD,vE,vF,vG},meth@BBBB 与 invoke-kind/range {vCCCC, ... ,vNNNN},meth@BBBB 两类，两类指令在作用上并无不同，只是后则在设置参数寄存器时使用了range来指定寄存器的范围。根据方法类型的不同，共有如下 5 条方法调用指令：

invoke-virtual 或 invoke-virtual/range 调用实例的虚方法

invoke-super 或 invoke-super/range 调用实例的父类方法

invoke-direct 或 invoke-direct/range 调用实例的直接方法

invoke-static 或 invoke-static/range 调用实例的静态方法

invoke-interface 或 invoke-interface/range 调用实例的接口方法

 

在Android4.0系统中，Dalvik指令集中增加了 invoke-kind/jumbo {vCCCC, ... ,vNNNN},meth@BBBBBBBB 这类指令，它与上面介绍的两类指令作用相同，只是在指令中增加了jumbo字节码后缀，且寄存器值与指令的索引取值范围更大。

方法调用的指令的返回值必须使用move-result-* 指令来获取。如下两条指令：

invoke-static {},Landroid/os/Parcel;->obtain()Landroid/osParcel;

move-result-object v0

 

数据转换指令

数据转换指令用于将一种类型的数值转换成另一种类型，它的格式为 unop vA,vB 。 vB寄存器或vB寄存器对存放需要转换的数据，转换后的结果保存在vA寄存器或vA寄存器对中。

neg-int 对整型数求补

not-int  对整型数求反

neg-long 对长整型求补

not-long 对长整型求反

neg-float 对单精度浮点型数求补

neg-double 对双精度浮点型数求补

int-to-long 将整型数转换为长整型

int-to-float 将整型数转换为单精度浮点型

int-to-double 将整型数转换为双精度浮点型

long-to-int 将长整型数转换为整型

long-to-float 将长整型数转换为单精度浮点型

long-to-double 将长整型数转换为双精度浮点型

float-to-int 将单精度浮点型数转换为整型

float-to-long 将单精度浮点型数转换为长整型

float-to-double 将单精度浮点型数转换为双精度浮点型

double-to-int 将双精度浮点型数转换为整型

double-to-long 将双精度浮点型数转换为长整型

double-to-float 将双精度浮点型数转换为单精度浮点型

int-to-byte 将整型转换为字节型

int-to-char 将整型转换为字符串

int-to-short 将整型转换为短整型

 

数据运算指令

数据运算指令包括算术运算指令与逻辑运算指令。算术运算指令主要进行数值间如加、减、乘、除、模、移位等运算，逻辑运算主要进行数值间与、或、非、异或等运算。数据运算指令有如下四类（数据运算时可能在寄存器或寄存器对间进行，下面的指令作用讲解时使用寄存器来描述）：

binop vAA,vBB,vCC 将vBB寄存器与vCC寄存器进行运算，结果保存到vAA寄存器

binop/2addr vA,vB 将vA寄存器与vB寄存器进行运算，结果保存到vA寄存器

binop/lit16 vA,vB,#+CCCC 将vB寄存器与常量CCCC进行运算，结果保存到vA寄存器

binop/lit8 vAA,vBB,#+CC 将vBB寄存器与常量CC进行运算，结果保存到vAA寄存器

后面3类指令比第1类指令分别多了addr、lit16、lit8等指令后缀。四类指令中基础字节码后面加上数据类型后缀，如-int或-long分别表示操作的数据类型那个为整型与长整型。第1类指令可归类如下：

add-type     vBB寄存器与vCC寄存器值进行加法运算（vBB  + vCC）

sub-type     vBB寄存器与vCC寄存器值进行减法运算（vBB  - vCC）

mul-type     vBB寄存器与vCC寄存器值进行乘法运算（vBB  * vCC）

div-type     vBB寄存器与vCC寄存器值进除法运算（vBB  / vCC）

rem-type     vBB寄存器与vCC寄存器值进行模运算（vBB  % vCC）

and-type     vBB寄存器与vCC寄存器值进行与运算（vBB  & vCC）

or-type     vBB寄存器与vCC寄存器值进行或运算（vBB  | vCC）

xor-type     vBB寄存器与vCC寄存器值进行异或运算（vBB  ^ vCC）

shl-type     vBB寄存器（有符号数）左移vCC位（vBB << vCC）

shr-type     vBB寄存器（有符号数）右移vCC位（vBB >> vCC）

ushr-type     vBB寄存器（无符号数）右移vCC位（vBB >> vCC）

其中基础字节码后面的-type可以是-int、-long、-float、-double。后面3类指令与之类似。

 

 

 

至此Dalvik虚拟机支持的所有指令都介绍完了。在Android4.0系统以前，每个指令的字节码只在用一个字节，取值范围是0x0~-0x0ff。在Android4.0系统中，有扩充了一部分指令，这些指令被成为扩展指令，如果指令主机次后添加了jumbo后缀，增加了寄存器与常量的取值范围。

简单的练习可以看看 写一个Dalvik版的Hello World

------------------------------------------------

Dalvik opcodes

Author: Gabor Paller

Vx values in the table denote a Dalvik register. Depending on the instruction, 16, 256 or 64k registers can be accessed. Operations on long and double values use two registers, e.g. a double value addressed in the V0 register occupies the V0 and V1 registers.

Boolean values are stored as 1 for true and 0 for false. Operations on booleans are translated into integer operations.

All the examples are in hig-endian format, e.g. 0F00 0A00 is coded as 0F, 00, 0A, 00 sequence.

Note there are no explanation/example at some instructions. This means that I have not seen that instruction "in the wild" and its presence/name is only known from Android opcode constant list.

Opcode (hex)	Opcode name	Explanation	Example
00	nop	No operation	0000 - nop
01	move vx,vy	Moves the content of vy into vx. Both registers must be in the first 256 register range.	0110 - move v0, v1 Moves v1 into v0.
02	move/from16 vx,vy	Moves the content of vy into vx. vy may be in the 64k register range while vx is one of the first 256 registers.	0200 1900 - move/from16 v0, v25 Moves v25 into v0.
03	move/16
04	move-wide
05	move-wide/from16 vx,vy	Moves a long/double value from vy to vx. vy may be in the 64k register range while wx is one of the first 256 registers.	0516 0000 - move-wide/from16 v22, v0 Moves v0 into v22.
06	move-wide/16
07	move-object vx,vy	Moves the object reference from vy to vx.	0781 - move-object v1, v8 Moves the object reference in v8 to v1.
08	move-object/from16 vx,vy	Moves the object reference from vy to vx, vy can address 64k registers and vx can address 256 registers.	0801 1500 - move-object/from16 v1, v21 Move the object reference in v21 to v1.
09	move-object/16
0A	move-result vx	Move the result value of the previous method invocation into vx.	0A00 - move-result v0 Move the return value of a previous method invocation into v0.
0B	move-result-wide vx	Move the long/double result value of the previous method invocation into vx,vx+1.	0B02 - move-result-wide v2 Move the long/double result value of the previous method invocation into v2,v3.
0C	move-result-object vx	Move the result object reference of the previous method invocation into vx.	0C00 - move-result-object v0
0D	move-exception vx	Move the exception object reference thrown during a method invocation into vx.	0D19 - move-exception v25
0E	return-void	Return without a return value	0E00 - return-void
0F	return vx	Return with vx return value	0F00 - return v0 Returns with return value in v0.
10	return-wide vx	Return with double/long result in vx,vx+1.	1000 - return-wide v0 Returns with a double/long value in v0,v1.
11	return-object vx	Return with vx object reference value.	1100 - return-object v0 Returns with object reference value in v0
12	const/4 vx,lit4	Puts the 4 bit constant into vx	1221 - const/4 v1, #int2 Moves literal 2 into v1. The destination register is in the lower 4 bit in the second byte, the literal 2 is in the higher 4 bit.
13	const/16 vx,lit16	Puts the 16 bit constant into vx	1300 0A00 - const/16 v0, #int 10 Puts the literal constant of 10 into v0.
14	const vx, lit32	Puts the integer constant into vx	1400 4E61 BC00 - const v0, #12345678 // #00BC614E Moves literal 12345678 into v0.
15	const/high16 v0, lit16	Puts the 16 bit constant into the topmost bits of the register. Used to initialize float values.	1500 2041 - const/high16 v0, #float 10.0 // #41200000 Moves the floating literal of 10.0 into v0. The 16 bit literal in the instruction carries the top 16 bits of the floating point number.
16	const-wide/16 vx, lit16	Puts the integer constant into vx and vx+1 registers, expanding the integer constant into a long constant..	1600 0A00 - const-wide/16 v0, #long 10 Moves literal 10 into v0 and v1 registers.
17	const-wide/32 vx, lit32	Puts the 32 bit constant into vx and vx+1 registers, expanding the integer constant into a long constant.	1702 4e61 bc00 - const-wide/32 v2, #long 12345678 // #00bc614e Puts #12345678 into v2 and v3 registers.
18	const-wide vx, lit64	Puts the 64 bit constant into vx and vx+1 registers.	1802 874b 6b5d 54dc 2b00- const-wide v2, #long 12345678901234567 // #002bdc545d6b4b87 Puts #12345678901234567 into v2 and v3 registers.
19	const-wide/high16 vx,lit16	Puts the 16 bit constant into the highest 16 bit of vx and vx+1 registers. Used to initialize double values.	1900 2440 - const-wide/high16 v0, #double 10.0 // #402400000 Puts the double constant of 10.0 into v0 register.
1A	const-string vx,string_id	Puts reference to a string constant identified by string_id into vx.	1A08 0000 - const-string v8, "" // string@0000 Puts reference to string@0000 (entry #0 in the string table) into v8.
1B	const-string-jumbo
1C	const-class vx,type_id	Moves the class object of a class identified by type_id (e.g. Object.class) into vx.	1C00 0100 - const-class v0, Test3 // type@0001 Moves reference to Test3.class (entry#1 in the type id table) into
1D	monitor-enter vx	Obtains the monitor of the object referenced by vx.	1D03 - monitor-enter v3 Obtains the monitor of the object referenced by v3.
1E	monitor-exit	Releases the monitor of the object referenced by vx.	1E03 - monitor-exit v3 Releases the monitor of the object referenced by v3.
1F	check-cast vx, type_id	Checks whether the object reference in vx can be cast to an instance of a class referenced by type_id. Throws ClassCastException if the cast is not possible, continues execution otherwise.	1F04 0100 - check-cast v4, Test3 // type@0001 Checks whether the object reference in v4 can be cast to type@0001 (entry #1 in the type id table)
20	instance-of vx,vy,type_id	Checks whether vy is instance of a class identified by type_id. Sets vx non-zero if it is, 0 otherwise.	2040 0100 - instance-of v0, v4, Test3 // type@0001 Checks whether the object reference in v4 is an instance of type@0001 (entry #1 in the type id table). Sets v0 to non-zero if v4 is instance of Test3, 0 otherwise.
21	array-length vx,vy	Calculates the number of elements of the array referenced by vy and puts the length value into vx.	2111 - array-length v1, v1 Calculates the number of elements of the array referenced by v1 and puts the result into v1.
22	new-instance vx,type	Instantiates an object type and puts the reference of the newly created instance into vx.	2200 1500 - new-instance v0, java.io.FileInputStream // type@0015 Instantiates type@0015 (entry #15H in the type table) and puts its reference into v0.
23	new-array vx,vy,type_id	Generates a new array of type_id type and vy element size and puts the reference to the array into vx.	2312 2500 - new-array v2, v1, char[] // type@0025 Generates a new array of type@0025 type and v1 size and puts the reference to the new array into v2.
24	filled-new-array {parameters},type_id	Generates a new array of type_id and fills it with the parameters5. Reference to the newly generated array can be obtained by a move-result-object instruction, immediately following the filled-new-array instruction.	2420 530D 0000 - filled-new-array {v0,v0},[I // type@0D53 Generates a new array of type@0D53. The array's size will be 2 and both elements will be filled with the contents of v0 register.
25	filled-new-array-range {vx..vy},type_id	Generates a new array of type_id and fills it with a range of parameters. Reference to the newly generated array can be obtained by a move-result-object instruction, immediately following the filled-new-array instruction.	2503 0600 1300 - filled-new-array/range {v19..v21}, [B // type@0006 Generates a new array of type@0D53. The array's size will be 3 and the elements will be filled using the v19,v20 and v21 registers4.
26	fill-array-data vx,array_data_offset	Fills the array referenced by vx with the static data. The location of the static data is the sum of  the position of the current instruction and the offset	2606 2500 0000 - fill-array-data v6, 00e6 // +0025 Fills the array referenced by v0 with the static data at current instruction+25H words location. The offset is expressed as a 32-bit number. The static data is stored in the following format: 0003 // Table type: static array data 0400 // Byte per array element (in this case, 4 byte integers) 0300 0000 // Number of elements in the table 0100 0000  // Element #0: integer 1 0200 0000 // Element #1: integer 2 0300 0000 // Element #2: integer3
27	throw vx	Throws an exception object. The reference of the exception object is in vx.	2700 - throw v0 Throws an exception. The exception object reference is in v0.
28	goto target	Unconditional jump by short offset2.	28F0 - goto 0005 // -0010 Jumps to current position-16 words (hex 10). 0005 is the label of the target instruction.
29	goto/16 target	Unconditional jump by 16 bit offset2.	2900 0FFE - goto/16 002f // -01f1 Jumps to the current position-1F1H words. 002F is the label of the target instruction.
2A	goto/32 target
2B	packed-switch vx,table	Implements a switch statement where the case constants are close to each other. The instruction uses an index table. vx indexes into this table to find the offset of the instruction for a particular case. If vx falls out of the index table, the execution continues on the next instruction (default case).	2B02 0C00 0000 - packed-switch v2, 000c // +000c Execute a packed switch according to the switch argument in v2. The position of the index table is at current instruction+0CH words. The table looks like the following: 0001 // Table type: packed switch table 0300 // number of elements 0000 0000 // element base 0500 0000  0: 00000005 // case 0: +00000005 0700 0000  1: 00000007 // case 1: +00000007 0900 0000  2: 00000009 // case 2: +00000009
2C	sparse-switch vx,table	Implements a switch statement with sparse case table. The instruction uses a lookup table with case constants and offsets for each case constant. If there is no match in the table, execution continues on the next instruction (default case).	2C02 0c00 0000 - sparse-switch v2, 000c // +000c Execute a sparse switch according to the switch argument in v2. The position of the lookup table is at current instruction+0CH words. The table looks like the following. 0002 // Table type: sparse switch table 0300 // number of elements 9cff ffff // first case: -100 fa00 0000 // second case constant: 250 e803 0000 // third case constant: 1000 0500 0000 // offset for the first case constant: +5 0700 0000 // offset for the second case constant: +7 0900 0000 // offset for the third case constant: +9
2D	cmpl-float	Compares the float values in vy and vz and sets the integer value in vx accordingly3	2D00 0607 - cmpl-float v0, v6, v7 Compares the float values in v6 and v7 then sets v0 accordingly. NaN bias is less-than, the instruction will return -1 if any of the parameters is NaN.
2E	cmpg-float vx, vy, vz	Compares the float values in vy and vz and sets the integer value in vx accordingly3.	2E00 0607 - cmpg-float v0, v6, v7 Compares the float values in v6 and v7 then sets v0 accordingly. NaN bias is greater-than, the instruction will return 1 if any of the parameters is NaN.
2F	cmpl-double vx,vy,vz	Compares the double values in vy and vz2 and sets the integer value in vx accordingly3.	2F19 0608 - cmpl-double v25, v6, v8 Compares the double values in v6,v7 and v8,v9 and sets v25 accordingly. NaN bias is less-than, the instruction will return -1 if any of the parameters is NaN.
30	cmpg-double vx, vy, vz	Compares the double values in vy and vz2 and sets the integer value in vx accordingly3.	3000 080A - cmpg-double v0, v8, v10 Compares the double values in v8,v9 and v10,v11 then sets v0 accordingly. NaN bias is greater-than, the instruction will return 1 if any of the parameters is NaN.
31	cmp-long vx, vy, vz	Compares the long values in vy and vz and sets the integer value in vx accordingly3.	3100 0204 - cmp-long v0, v2, v4 Compares the long values in v2 and v4 then sets v0 accordingly.
32	if-eq vx,vy,target	Jumps to target if vx==vy2. vx and vy are integer values.	32b3 6600 - if-eq v3, v11, 0080 // +0066 Jumps to the current position+66H words if v3==v11. 0080 is the label of the target instruction.
33	if-ne vx,vy,target	Jumps to target if vx!=vy2. vx and vy are integer values.	33A3 1000 - if-ne v3, v10, 002c // +0010 Jumps to the current position+10H words if v3!=v10. 002c is the label of the target instruction.
34	if-lt vx,vy,target	Jumps to target is vx<vy2. vx and vy are integer values.	3432 CBFF - if-lt v2, v3, 0023 // -0035 Jumps to the current position-35H words if v2<v3. 0023 is the label of the target instruction.
35	if-ge vx, vy,target	Jumps to target if vx>=vy2. vx and vy are integer values.	3510 1B00 - if-ge v0, v1, 002b // +001b Jumps to the current position+1BH words if v0>=v1. 002b is the label of the target instruction.
36	if-gt vx,vy,target	Jumps to target if vx>vy2. vx and vy are integer values.	3610 1B00 - if-ge v0, v1, 002b // +001b Jumps to the current position+1BH words if v0>v1. 002b is the label of the target instruction.
37	if-le vx,vy,target	Jumps to target if vx<=vy2. vx and vy are integer values.	3756 0B00 - if-le v6, v5, 0144 // +000b Jumps to the current position+0BH words if v6<=v5. 0144 is the label of the target instruction.
38	if-eqz vx,target	Jumps to target if vx==02. vx is an integer value.	3802 1900 - if-eqz v2, 0038 // +0019 Jumps to the current position+19H words if v2==0. 0038 is the label of the target instruction.
39	if-nez vx,target	Checks vx and jumps if vx is nonzero2.	3902 1200 - if-nez v2, 0014 // +0012 Jumps to current position+18 words (hex 12) if v2 is nonzero. 0014 is the label of the target instruction.
3A	if-ltz vx,target	Checks vx and jumps if vx<02.	3A00 1600 - if-ltz v0, 002d // +0016 Jumps to the current position+16H words if v0<0. 002d is the label of the target instruction.
3B	if-gez vx,target	Checks vx and jumps if vx>=02.	3B00 1600 - if-gez v0, 002d // +0016 Jumps to the current position+16H words if v0 >=0. 002d is the label of the target instruction.
3C	if-gtz vx,target	Checks vx and jumps if vx>02.	3C00 1D00 - if-gtz v0, 004a // +001d Jumps to the current position+1DH words if v0>0. 004A is the label of the target instruction.
3D	if-lez vx,target	Checks vx and jumps if vx<=02.	3D00 1D00 - if-lez v0, 004a // +001d Jumps to the current position+1DH words if v0<=0. 004A is the label of the target instruction.
3E	unused_3E
3F	unused_3F
40	unused_40
41	unused_41
42	unused_42
43	unused_43
44	aget vx,vy,vz	Gets an integer value of an object reference array into vx. The array is referenced by vy and is indexed by vz.	4407 0306 - aget v7, v3, v6 Gets an integer array element. The array is referenced by v3 and the element is indexed by v6. The element will be put into v7.
45	aget-wide vx,vy,vz	Gets a long/double value of long/double array into vx,vx+1. The array is referenced by vy and is indexed by vz.	4505 0104 - aget-wide v5, v1, v4 Gets a long/double array element. The array is referenced by v1 and the element is indexed by v4. The element will be put into v5,v6.
46	aget-object vx,vy,vz	Gets an object reference value of an object reference array into vx. The array is referenced by vy and is indexed by vz.	4602 0200 - aget-object v2, v2, v0 Gets an object reference array element. The array is referenced by v2 and the element is indexed by v0. The element will be put into v2.
47	aget-boolean vx,vy,vz	Gets a boolean value of a boolean array into vx. The array is referenced by vy and is indexed by vz.	4700 0001 - aget-boolean v0, v0, v1  Gets a boolean array element. The array is referenced by v0 and the element is indexed by v1. The element will be put into v0.
48	aget-byte vx,vy,vz	Gets a byte value of a byte array into vx. The array is referenced by vy and is indexed by vz.	4800 0001 - aget-byte v0, v0, v1 Gets a byte array element. The array is referenced by v0 and the element is indexed by v1. The element will be put into v0.
49	aget-char vx, vy,vz	Gets a char value  of a character array into vx. The element is indexed by vz, the array object is referenced by vy	4905 0003 - aget-char v5, v0, v3 Gets a character array element. The array is referenced by v0 and the element is indexed by v3. The element will be put into v5.
4A	aget-short vx,vy,vz	Gets a short value  of a short array into vx. The element is indexed by vz, the array object is referenced by vy.	4A00 0001 - aget-short v0, v0, v1 Gets a short array element. The array is referenced by v0 and the element is indexed by v1. The element will be put into v0.
4B	aput vx,vy,vz	Puts the integer value in vx into an element of an integer array. The element is indexed by vz, the array object is referenced by vy.	4B00 0305 - aput v0, v3, v5 Puts the integer value in v2 into an integer array referenced by v0. The target array element is indexed by v1.
4C	aput-wide vx,vy,vz	Puts the double/long value in vx,vx+1 into a double/long array. The array is referenced by vy, the element is indexed by vz.	4C05 0104 - aput-wide v5, v1, v4 Puts the double/long value in v5,v6 into a double/long array referenced by v1. The target array element is indexed by v4.
4D	aput-object vx,vy,vz	Puts the object reference value in vx into an element of an object reference array. The element is indexed by vz, the array object is referenced by vy.	4D02 0100 - aput-object v2, v1, v0 Puts the object reference value in v2 into an object reference array referenced by v0. The target array element is indexed by v1.
4E	aput-boolean vx,vy,vz	Puts the boolean value in vx into an element of a boolean array. The element is indexed by vz, the array object is referenced by vy.	4E01 0002 - aput-boolean v1, v0, v2 Puts the boolean value in v1 into an object reference array referenced by v0. The target array element is indexed by v2.
4F	aput-byte vx,vy,vz	Puts the byte value in vx into an element of a byte array. The element is indexed by vz, the array object is referenced by vy.	4F02 0001 - aput-byte v2, v0, v1 Puts the boolean value in v2 into a byte array referenced by v0. The target array element is indexed by v1.
50	aput-char vx,vy,vz	Puts the char value in vx into an element of a character array. The element is indexed by vz, the array object is referenced by vy.	5003 0001 - aput-char v3, v0, v1 Puts the character value in v3 into a character array referenced by v0. The target array element is indexed by v1.
51	aput-short vx,vy,vz	Puts the short value in vx into an element of a short array. The element is indexed by vz, the array object is referenced by vy.	5102 0001 - aput-short v2, v0, v1 Puts the short value in v2 into a character array referenced by v0. The target array element is indexed by v1.
52	iget vx, vy, field_id	Reads an instance field into vx. The instance is referenced by vy.	5210 0300 - iget v0, v1, Test2.i6:I // field@0003 Reads field@0003 into v0 (entry #3 in the field id table). The instance is referenced by v1.
53	iget-wide vx,vy,field_id	Reads an instance field into vx1. The instance is referenced by vy.	5320 0400 - iget-wide v0, v2, Test2.l0:J // field@0004 Reads field@0004 into v0 and v1 registers (entry #4 in the field id table). The instance is referenced by v2.
54	iget-object vx,vy,field_id	Reads an object reference instance field into vx. The instance is referenced by vy.	iget-object v1, v2, LineReader.fis:Ljava/io/FileInputStream; // field@0002 Reads field@0002 into v1  (entry #2 in the field id table). The instance is referenced by v2.
55	iget-boolean vx,vy,field_id	Reads a boolean instance field into vx. The instance is referenced by vy.	55FC 0000 - iget-boolean v12, v15, Test2.b0:Z // field@0000 Reads the boolean field@0000 into v12 register (entry #0 in the field id table). The instance is referenced by v15.
56	iget-byte vx,vy,field_id	Reads a byte instance field into vx. The instance is referenced by vy.	5632 0100 - iget-byte v2, v3, Test3.bi1:B // field@0001 Reads the char field@0001 into v2 register (entry #1 in the field id table). The instance is referenced by v3.
57	iget-char vx,vy,field_id	Reads a char instance field into vx. The instance is referenced by vy.	5720 0300 - iget-char v0, v2, Test3.ci1:C // field@0003 Reads the char field@0003 into v0 register (entry #3 in the field id table). The instance is referenced by v2.
58	iget-short vx,vy,field_id	Reads a short instance field into vx. The instance is referenced by vy.	5830 0800 - iget-short v0, v3, Test3.si1:S // field@0008 Reads the short field@0008 into v0 register (entry #8 in the field id table). The instance is referenced by v3.
59	iput vx,vy, field_id	Puts vx into an instance field. The instance is referenced by vy.	5920 0200 - iput v0,v2, Test2.i6:I // field@0002 Stores v0 into field@0002 (entry #2 in the field id table). The instance is referenced by v2.
5A	iput-wide vx,vy, field_id	Puts the wide value located in vx and vx+1 registers into an instance field. The instance is referenced by vy.	5A20 0000 - iput-wide v0,v2, Test2.d0:D // field@0000  Stores the wide value in v0, v1 registers into field@0000 (entry #0 in the field id table). The instance is referenced by v2.
5B	iput-object vx,vy,field_id	Puts the object reference in vx into an instance field. The instance is referenced by vy.	5B20 0000 - iput-object v0, v2, LineReader.bis:Ljava/io/BufferedInputStream; // field@0000 Stores the object reference in v0 into field@0000 (entry #0 in the field table). The instance is referenced by v2.
5C	iput-boolean vx,vy, field_id	Puts the boolean value located in vx into an instance field. The instance is referenced by vy.	5C30 0000 - iput-boolean v0, v3, Test2.b0:Z // field@0000 Puts the boolean value in v0 into field@0000 (entry #0 in the field id table). The instance is referenced by v3.
5D	iput-byte vx,vy,field_id	Puts the byte value located in vx into an instance field. The instance is referenced by vy.	5D20 0100 - iput-byte v0, v2, Test3.bi1:B // field@0001 Puts the boolean value in v0 into field@0001 (entry #1 in the field id table). The instance is referenced by v2.
5E	iput-char vx,vy,field_id	Puts the char value located in vx into an instance field. The instance is referenced by vy.	5E20 0300 - iput-char v0, v2, Test3.ci1:C // field@0003 Puts the char value in v0 into field@0003 (entry #3 in the field id table). The instance is referenced by v2.
5F	iput-short vx,vy,field_id	Puts the short value located in vx into an instance field. The instance is referenced by vy.	5F21 0800 - iput-short v1, v2, Test3.si1:S // field@0008 Puts the short value in v1 into field@0008 (entry #8 in the field id table). The instance is referenced by v2.
60	sget vx,field_id	Reads the integer field identified by the field_id into vx.	6000 0700 - sget v0, Test3.is1:I // field@0007 Reads field@0007 (entry #7 in the field id table) into v0.
61	sget-wide vx, field_id	Reads the static field identified by the field_id into vx and vx+1 registers.	6100 0500 - sget-wide v0, Test2.l1:J // field@0005 Reads field@0005 (entry #5 in the field id table) into v0 and v1 registers.
62	sget-object vx,field_id	Reads the object reference field identified by the field_id into vx.	6201 0C00 - sget-object v1, Test3.os1:Ljava/lang/Object; // field@000c Reads field@000c (entry #CH in the field id table) into v1.
63	sget-boolean vx,field_id	Reads the boolean static field identified by the field_id into vx.	6300 0C00 - sget-boolean v0, Test2.sb:Z // field@000c Reads boolean field@000c (entry #12 in the field id table) into v0.
64	sget-byte vx,field_id	Reads the byte static field identified by the field_id into vx.	6400 0200 - sget-byte v0, Test3.bs1:B // field@0002 Reads byte field@0002 (entry #2 in the field id table) into v0.
65	sget-char vx,field_id	Reads the char static field identified by the field_id into vx.	6500 0700 - sget-char v0, Test3.cs1:C // field@0007 Reads byte field@0007 (entry #7 in the field id table) into v0.
66	sget-short vx,field_id	Reads the short static field identified by the field_id into vx.	6600 0B00 - sget-short v0, Test3.ss1:S // field@000b Reads short field@000b (entry #BH in the field id table) into v0.
67	sput vx, field_id	Puts vx into a static field.	6700 0100 - sput v0, Test2.i5:I // field@0001 Stores v0 into field@0001 (entry #1 in the field id table).
68	sput-wide vx, field_id	Puts vx and vx+1 into a static field.	6800 0500 - sput-wide v0, Test2.l1:J // field@0005 Puts the long value in v0 and v1 into the field@0005 static field (entry #5 in the field id table).
69	sput-object vx,field_id	Puts object reference in vx into a static field.	6900 0c00 - sput-object v0, Test3.os1:Ljava/lang/Object; // field@000c Puts the object reference value in v0 into the field@000c static field (entry #CH in the field id table).
6A	sput-boolean vx,field_id	Puts boolean value in vx into a static field.	6A00 0300 - sput-boolean v0, Test3.bls1:Z // field@0003 Puts the byte value in v0 into the field@0003 static field (entry #3 in the field id table).
6B	sput-byte vx,field_id	Puts byte value in vx into a static field.	6B00 0200 - sput-byte v0, Test3.bs1:B // field@0002 Puts the byte value in v0 into the field@0002 static field (entry #2 in the field id table).
6C	sput-char vx,field_id	Puts char value in vx into a static field.	6C01 0700 - sput-char v1, Test3.cs1:C // field@0007 Puts the char value in v1 into the field@0007 static field (entry #7 in the field id table).
6D	sput-short vx,field_id	Puts short value in vx into a static field.	6D00 0B00 - sput-short v0, Test3.ss1:S // field@000b Puts the short value in v0 into the field@000b static field (entry #BH in the field id table).
6E	invoke-virtual { parameters }, methodtocall	Invokes a virtual method with parameters.	6E53 0600 0421 - invoke-virtual { v4, v0, v1, v2, v3}, Test2.method5:(IIII)V // method@0006 Invokes the 6th method in the method table with the following arguments: v4 is the "this" instance, v0, v1, v2, and v3 are the method parameters. The method has 5 arguments (4 MSB bits of the second byte)5.
6F	invoke-super {parameter},methodtocall	Invokes the virtual method of the immediate parent class.	6F10 A601 0100 invoke-super {v1},java.io.FilterOutputStream.close:()V // method@01a6 Invokes method@01a6 with one parameter, v1.
70	invoke-direct { parameters }, methodtocall	Invokes a method with parameters without the virtual method resolution.	7010 0800 0100 - invoke-direct {v1}, java.lang.Object.<init>:()V // method@0008 Invokes the 8th method in the method table with just one parameter, v1 is the "this" instance5.
71	invoke-static {parameters}, methodtocall	Invokes a static method with parameters.	7110 3400 0400 - invoke-static {v4}, java.lang.Integer.parseInt:( Ljava/lang/String;)I // method@0034 Invokes method@34 static method. The method is called with one parameter, v45.
72	invoke-interface {parameters},methodtocall	Invokes an interface method.	7240 2102 3154 invoke-interface {v1, v3, v4, v5}, mwfw.IReceivingProtocolAdapter.receivePackage:( ILjava/lang/String;Ljava/io/InputStream;)Z // method@0221 Invokes method@221 interface method using parameters in v1,v3,v4 and v55.
73	unused_73
74	invoke-virtual/range {vx..vy},methodtocall	Invokes virtual method with a range of registers. The instruction specifies the first register and the number of registers to be passed to the method.	7403 0600 1300 - invoke-virtual {v19..v21}, Test2.method5:(IIII)V // method@0006 Invokes the 6th method in the method table with the following arguments: v19 is the "this" instance, v20 and v21 are the method parameters.
75	invoke-super/range	Invokes  the virtual method of the immediate parent class. The instruction specifies the first register and the number of registers to be passed to the method.	7501 A601 0100 invoke-super {v1},java.io.FilterOutputStream.close:()V // method@01a6 Invokes method@01a6 with one parameter, v1.
76	invoke-direct/range {vx..vy},methodtocall	Invokes direct method with a range of registers. The instruction specifies the first register and the number of registers to be passed to the method.	7603 3A00 1300 - invoke-direct/range {v19..21},java.lang.Object.<init>:()V // method@003a Invokes method@3A with 1 parameters (second byte of the instruction=03). The parameter is stored in v19 (5th,6th bytes of the instruction).
77	invoke-static/range {vx..vy},methodtocall	Invokes static method with a range of registers. The instruction specifies the first register and the number of registers to be passed to the method.	7703 3A00 1300 - invoke-static/range {v19..21},java.lang.Integer.parseInt:( Ljava/lang/String;)I // method@0034 Invokes method@3A with 1 parameters (second byte of the instruction=03). The parameter is stored in v19 (5th,6th bytes of the instruction).
78	invoke-interface-range	Invokes an interface method with a range of registers. The instruction specifies the first register and the number of registers to be passed to the method.	7840 2102 0100 invoke-interface {v1..v4}, mwfw.IReceivingProtocolAdapter.receivePackage:( ILjava/lang/String;Ljava/io/InputStream;)Z // method@0221 Invokes method@221 interface method using parameters in v1..v4.
79	unused_79
7A	unused_7A
7B	neg-int vx,vy	Calculates vx=-vy.	7B01 - neg-int v1,v0 Calculates -v0 and stores the result in v1.
7C	not-int vx,vy
7D	neg-long vx,vy	Calculates vx,vx+1=-(vy,vy+1)	7D02 - neg-long v2,v0 Calculates -(v0,v1) and stores the result into (v2,v3)
7E	not-long vx,vy
7F	neg-float vx,vy	Calculates vx=-vy	7F01 - neg-float v1,v0 Calculates -v0 and stores the result into v1.
80	neg-double vx,vy	Calculates vx,vx+1=-(vy,vy+1)	8002 - neg-double v2,v0 Calculates -(v0,v1) and stores the result into (v2,v3)
81	int-to-long vx, vy	Converts the integer in vy into a long in vx,vx+1.	8106 - int-to-long v6, v0 Converts an integer in v0 into a long in v6,v7.
82	int-to-float vx, vy	Converts the integer in vx into a float in vx.	8206 - int-to-float v6, v0 Converts the integer in v0 into a float in v6.
83	int-to-double vx, vy	Converts the integer in vy into the double in vx,vx+1.	8306 - int-to-double v6, v0 Converts the integer in v0 into a double in v6,v7
84	long-to-int vx,vy	Converts the long value in vy,vy+1 into an integer in vx.	8424 - long-to-int v4, v2 Converts the long value in v2,v3 into an integer value in v4.
85	long-to-float vx, vy	Converts the long value in vy,vy+1 into a float in vx.	8510 - long-to-float v0, v1 Convcerts the long value in v1,v2 into a float value in v0.
86	long-to-double vx, vy	Converts the long value in vy,vy+1 into a double value in vx,vx+1.	8610 - long-to-double v0, v1 Converts the long value in v1,v2 into a double value in v0,v1.
87	float-to-int vx, vy	Converts the float value in vy into an integer value in vx.	8730 - float-to-int v0, v3 Converts the float value in v3 into an integer value in v0.
88	float-to-long vx,vy	Converts the float value in vy into a long value in vx.	8830 - float-to-long v0, v3 Converts the float value in v3 into a long value in v0,v1.
89	float-to-double vx, vy	Converts the float value in vy into a double value in vx,vx+1.	8930 - float-to-double v0, v3 Converts the float value in v3 into a double value in v0,v1.
8A	double-to-int vx, vy	Converts the double value in vy,vy+1 into an integer value in vx.	8A40  - double-to-int v0, v4 Converts the double value in v4,v5 into an integer value in v0.
8B	double-to-long vx, vy	Converts the double value in vy,vy+1 into a long value in vx,vx+1.	8B40 - double-to-long v0, v4 Converts the double value in v4,v5 into a long value in v0,v1.
8C	double-to-float vx, vy	Converts the double value in vy,vy+1 into a float value in vx.	8C40 - double-to-float v0, v4 Converts the double value in v4,v5 into a float value in v0,v1.
8D	int-to-byte vx,vy	Converts the int value in vy to a byte value and stores it in vx.	8D00 - int-to-byte v0, v0 Converts the integer in v0 into a byte and puts the byte value into v0.
8E	int-to-char vx,vy	Converts the int value in vy to a char value and stores it in vx.	8E33  - int-to-char v3, v3 Converts the integer in v3 into a char and puts the char value into v3.
8F	int-to-short vx,vy	Converts the int value in vy to a short value and stores it in vx.	8F00 - int-to-short v0, v0 Converts the integer in v0 into a short and puts the short value into v3.
90	add-int vx,vy,vz	Calculates vy+vz and puts the result into vx.	9000 0203 - add-int v0, v2, v3 Adds v3 to v2 and puts the result into v04.
91	sub-int vx,vy,vz	Calculates vy-vz and puts the result into vx.	9100 0203 - sub-int v0, v2, v3 Subtracts v3 from v2 and puts the result into v0.
92	mul-int vx, vy, vz	Multiplies vz with wy and puts the result int vx.	9200 0203 - mul-int v0,v2,v3 Multiplies v2 with w3 and puts the result into v0
93	div-int vx,vy,vz	Divides vy with vz and puts the result into vx.	9303 0001 - div-int v3, v0, v1 Divides v0 with v1 and puts the result into v3.
94	rem-int vx,vy,vz	Calculates vy % vz and puts the result into vx.	9400 0203 - rem-int v0, v2, v3 Calculates v3 % v2 and puts the result into v0.
95	and-int vx, vy, vz	Calculates vy AND vz and puts the result into vx.	9503 0001 - and-int v3, v0, v1 Calculates v0 AND v1 and puts the result into v3.
96	or-int vx, vy, vz	Calculates vy OR vz and puts the result into vx.	9603 0001 - or-int v3, v0, v1 Calculates v0 OR v1 and puts the result into v3.
97	xor-int vx, vy, vz	Calculates vy XOR vz and puts the result into vx.	9703 0001 - xor-int v3, v0, v1 Calculates v0 XOR v1 and puts the result into v3.
98	shl-int vx, vy, vz	Shift vy left by the positions specified by vz and store the result into vx.	9802 0001 - shl-int v2, v0, v1 Shift v0 left by the positions specified by v1 and store the result in v2.
99	shr-int vx, vy, vz	Shift vy right by the positions specified by vz and store the result into vx.	9902 0001 - shr-int v2, v0, v1 Shift v0 right by the positions specified by v1 and store the result in v2.
9A	ushr-int vx, vy, vz	Unsigned shift right (>>>) vy by the positions specified by vz and store the result into vx.	9A02 0001 - ushr-int v2, v0, v1 Unsigned shift v0 right by the positions specified by v1 and store the result in v2.
9B	add-long vx, vy, vz	Adds vy to vz and puts the result into vx1.	9B00 0305 - add-long v0, v3, v5 The long value in v3,v4 is added to the value in v5,v6 and the result is stored in v0,v1.
9C	sub-long vx,vy,vz	Calculates vy-vz and puts the result into vx1.	9C00 0305 - sub-long v0, v3, v5 Subtracts the long value in v5,v6 from the long value in v3,v4 and puts the result into v0,v1.
9D	mul-long vx,vy,vz	Calculates vy*vz and puts the result into vx1.	9D00 0305 - mul-long v0, v3, v5 Multiplies the long value in v5,v6 with the long value in v3,v4 and puts the result into v0,v1.
9E	div-long vx, vy, vz	Calculates vy/vz and puts the result into vx1.	9E06 0002 - div-long v6, v0, v2 Divides the long value in v0,v1 with the long value in v2,v3 and pust the result into v6,v7.
9F	rem-long vx,vy,vz	Calculates vy % vz and puts the result into vx1.	9F06 0002 - rem-long v6, v0, v2 Calculates v0,v1 %  v2,v3 and puts the result into v6,v7.
A0	and-long vx, vy, vz	Calculates the vy AND vz and puts the result into vx1.	A006 0002 - and-long v6, v0, v2 Calculates v0,v1 AND v2,v3 and puts the result into v6,v7.
A1	or-long vx, vy, vz	Calculates the vy OR vz and puts the result into vx1.	A106 0002 - or-long v6, v0, v2 Calculates v0,v1 OR v2,v3 and puts the result into v6,v7.
A2	xor-long vx, vy, vz	Calculates the vy XOR vz and puts the result into vx1.	A206 0002 - xor-long v6, v0, v2 Calculates v0,v1 XOR v2,v3 and puts the result into v6,v7.
A3	shl-long vx, vy, vz	Shifts left vy by vz positions and stores the result in vx1.	A302 0004 - shl-long v2, v0, v4 Shift v0,v1 by postions specified by v4 and puts the result into v2,v3.
A4	shr-long vx,vy,vz	Shifts right vy by vz positions and stores the result in vx1.	A402 0004 - shr-long v2, v0, v4 Shift v0,v1 by postions specified by v4 and puts the result into v2,v3.
A5	ushr-long vx, vy, vz	Unsigned shifts right vy by vz positions and stores the result in vx1.	A502 0004 - ushr-long v2, v0, v4 Unsigned shift v0,v1 by postions specified by v4 and puts the result into v2,v3.
A6	add-float vx,vy,vz	Adds vy to vz and puts the result into vx.	A600 0203 - add-float v0, v2, v3 Adds the floating point numbers in v2 and v3 and puts the result into v0.
A7	sub-float vx,vy,vz	Calculates vy-vz and puts the result into vx.	A700 0203 - sub-float v0, v2, v3 Calculates v2-v3 and puts the result into v0.
A8	mul-float vx, vy, vz	Multiplies vy with vz and puts the result into vx.	A803 0001 - mul-float v3, v0, v1 Multiplies v0 with v1 and puts the result into v3.
A9	div-float vx, vy, vz	Calculates vy/vz and puts the result into vx.	A903 0001 - div-float v3, v0, v1 Divides v0 with v1 and puts the result into v3.
AA	rem-float vx,vy,vz	Calculates vy % vz and puts the result into vx.	AA03 0001 - rem-float v3, v0, v1 Calculates v0 %  v1 and puts the result into v3.
AB	add-double vx,vy,vz	Adds vy to vz and puts the result into vx1.	AB00 0305 - add-double v0, v3, v5 Adds the double value in v5,v6 registers to the double value in v3,v4 registers and places the result  in v0,v1 registers.
AC	sub-double vx,vy,vz	Calculates vy-vz and puts the result into vx1.	AC00 0305 - sub-double v0, v3, v5 Subtracts the value in v5,v6 from the value in v3,v4 and puts the result into v0,v1.
AD	mul-double vx, vy, vz	Multiplies vy with vz and puts the result into vx1.	AD06 0002 - mul-double v6, v0, v2 Multiplies the double value in v0,v1 with the double value in v2,v3 and puts the result into v6,v7.
AE	div-double vx, vy, vz	Calculates vy/vz and puts the result into vx1.	AE06 0002 - div-double v6, v0, v2 Divides the double value in v0,v1 with the double value in v2,v3 and puts the result into v6,v7.
AF	rem-double vx,vy,vz	Calculates vy % vz and puts the result into vx1.	AF06 0002 - rem-double v6, v0, v2 Calculates v0,v1 % v2,v3 and puts the result into v6,v7.
B0	add-int/2addr vx,vy	Adds vy to vx.	B010 - add-int/2addr v0,v1 Adds v1 to v0.
B1	sub-int/2addr vx,vy	Calculates vx-vy and puts the result into vx.	B140 - sub-int/2addr v0, v4 Subtracts v4 from v0 and puts the result into v0.
B2	mul-int/2addr vx,vy	Multiplies vx with vy.	B210 - mul-int/2addr v0, v1 Multiples v0 with v1 and puts the result into v0.
B3	div-int/2addr vx,vy	Divides vx with vy and puts the result into vx.	B310 - div-int/2addr v0, v1 Divides v0 with v1 and puts the result into v0.
B4	rem-int/2addr vx,vy	Calculates vx % vy and puts the result into vx	B410 - rem-int/2addr v0, v1  Calculates v0 % v1 and puts the result into v0.
B5	and-int/2addr vx, vy	Calculates vx AND vy and puts the result into vx.	B510 - and-int/2addr v0, v1 Calculates v0 AND v1 and puts the result into v0.
B6	or-int/2addr vx, vy	Calculates vx OR vy and puts the result into vx.	B610 - or-int/2addr v0, v1 Calculates v0 OR v1 and puts the result into v0.
B7	xor-int/2addr vx, vy	Calculates vx XOR vy and puts the result into vx.	B710  - xor-int/2addr v0, v1 Calculates v0 XOR v1 and puts the result into v0.
B8	shl-int/2addr vx, vy	Shifts vx left by vy positions.	B810 - shl-int/2addr v0, v1 Shift v0 left by v1 positions.
B9	shr-int/2addr vx, vy	Shifts vx right by vy positions.	B910 - shr-int/2addr v0, v1 Shift v0 right by v1 positions.
BA	ushr-int/2addr vx, vy	Unsigned shift right (>>>) vx by the positions specified by vy.	BA10 - ushr-int/2addr v0, v1 Unsigned shift v0 by the positions specified by v1.
BB	add-long/2addr vx,vy	Adds vy to vx1.	BB20 - add-long/2addr v0, v2 Adds the long value in v2,v3 registers to the long value in v0,v1 registers.
BC	sub-long/2addr vx,vy	Calculates vx-vy and puts the result into vx1.	BC70 - sub-long/2addr v0, v7 Subtracts the long value in v7,v8 from the long value in v0,v1 and puts the result into v0,v1.
BD	mul-long/2addr vx,vy	Calculates vx*vy and puts the result into vx1.	BD70 - mul-long/2addr v0, v7 Multiplies the long value in v7,v8 with the long value in v0,v1 and puts the result into v0,v1.
BE	div-long/2addr vx, vy	Calculates vx/vy and puts the result into vx1.	BE20 - div-long/2addr v0, v2 Divides the long value in v0,v1 with the long value in v2,v3 and puts the result into v0,v1
BF	rem-long/2addr vx,vy	Calculates vx % vy and puts the result into vx1.	BF20 - rem-long/2addr v0, v2 Calculates v0,v1 % v2,v3 and puts the result into v0,v1
C0	and-long/2addr vx, vy	Calculates vx AND vy and puts the result into vx1.	C020 - and-long/2addr v0, v2 Calculates v0,v1 OR v2,v3 and puts the result into v0,v1.
C1	or-long/2addr vx, vy	Calculates vx OR vy and puts the result into vx1.	C120  - or-long/2addr v0, v2 Calculates v0,v1 OR v2,v3 and puts the result into v0,v1.
C2	xor-long/2addr vx, vy	Calculates vx XOR vy and puts the result into vx1.	C220 - xor-long/2addr v0, v2 Calculates v0,v1 XOR v2,v3 and puts the result into v0,v1.
C3	shl-long/2addr vx, vy	Shifts left the value in vx,vx+1 by the positions specified by vy and stores the result in vx,vx+1.	C320 - shl-long/2addr v0, v2 Shifts left v0,v1 by the positions specified by v2.
C4	shr-long/2addr vx, vy	Shifts right the value in vx,vx+1 by the positions specified by vy and stores the result in vx,vx+1.	C420 - shr-long/2addr v0, v2 Shifts right v0,v1 by the positions specified by v2.
C5	ushr-long/2addr vx, vy	Unsigned shifts right the value in vx,vx+1 by the positions specified by vy and stores the result in vx,vx+1.	C520 - ushr-long/2addr v0, v2 Unsigned shifts right v0,v1 by the positions specified by v2.
C6	add-float/2addr vx,vy	Adds vy to vx.	C640 - add-float/2addr v0,v4 Adds v4 to v0.
C7	sub-float/2addr vx,vy	Calculates vx-vy and stores the result in vx.	C740 - sub-float/2addr v0,v4 Adds v4 to v0.
C8	mul-float/2addr vx, vy	Multiplies vx with vy.	C810 - mul-float/2addr v0, v1 Multiplies v0 with v1.
C9	div-float/2addr vx, vy	Calculates vx/vy and puts the result into vx.	C910 - div-float/2addr v0, v1 Divides v0 with v1 and puts the result into v0.
CA	rem-float/2addr vx,vy	Calculates vx/vy and puts the result into vx.	CA10 - rem-float/2addr v0, v1  Calculates v0 % v1 and puts the result into v0.
CB	add-double/2addr vx, vy	Adds vy to vx1.	CB70 - add-double/2addr v0, v7 Adds v7 to v0.
CC	sub-double/2addr vx, vy	Calculates vx-vy and puts the result into vx1.	CC70 - sub-double/2addr v0, v7 Subtracts the value in v7,v8 from the value in v0,v1 and puts the result into v0,v1.
CD	mul-double/2addr vx, vy	Multiplies vx with vy1.	CD20 - mul-double/2addr v0, v2 Multiplies the double value in v0,v1 with the double value in v2,v3 and puts the result into v0,v1.
CE	div-double/2addr vx, vy	Calculates vx/vy and puts the result into vx1.	CE20 - div-double/2addr v0, v2 Divides the double value in v0,v1 with the double value in v2,v3 and puts the value into v0,v1.
CF	rem-double/2addr vx,vy	Calculates vx % vy and puts the result into vx1.	CF20 - rem-double/2addr v0, v2  Calculates  v0,v1 %  v2,v3 and puts the value into v0,v1.
D0	add-int/lit16 vx,vy,lit16	Adds vy to lit16 and stores the result into vx.	D001 D204 - add-int/lit16 v1, v0, #int 1234 // #04d2 Adds v0 to literal 1234 and stores the result into v1.
D1	sub-int/lit16 vx,vy,lit16	Calculates vy - lit16 and stores the result into vx.	D101 D204 - sub-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 - literal 1234 and stores the result into v1.
D2	mul-int/lit16 vx,vy,lit16	Calculates vy * lit16 and stores the result into vx.	D201 D204 - mul-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 * literal 1234 and stores the result into v1.
D3	div-int/lit16 vx,vy,lit16	Calculates vy / lit16 and stores the result into vx.	D301 D204 - div-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 / literal 1234 and stores the result into v1.
D4	rem-int/lit16 vx,vy,lit16	Calculates vy % lit16 and stores the result into vx.	D401 D204 - rem-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 % literal 1234 and stores the result into v1.
D5	and-int/lit16 vx,vy,lit16	Calculates vy AND lit16 and stores the result into vx.	D501 D204 - and-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 AND literal 1234 and stores the result into v1.
D6	or-int/lit16 vx,vy,lit16	Calculates vy OR lit16 and stores the result into vx.	D601 D204 - or-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 OR literal 1234 and stores the result into v1.
D7	xor-int/lit16 vx,vy,lit16	Calculates vy XOR lit16 and stores the result into vx.	D701 D204 - xor-int/lit16 v1, v0, #int 1234 // #04d2 Calculates v0 XOR literal 1234 and stores the result into v1.
D8	add-int/lit8 vx,vy,lit8	Adds vy to lit8 and stores the result into vx.	D800 0201 - add-int/lit8 v0,v2, #int1 Adds literal 1 to v2 and stores the result into v0.
D9	sub-int/lit8 vx,vy,lit8	Calculates vy-lit8 and stores the result into vx.	D900 0201 - sub-int/lit8 v0,v2, #int1 Calculates v2-1 and stores the result into v0.
DA	mul-int/lit-8 vx,vy,lit8	Multiplies vy with lit8 8-bit literal constant and puts the result into vx.	DA00 0002 - mul-int/lit8 v0,v0, #int2 Multiplies v0 with literal 2 and puts the result into v0.
DB	div-int/lit8 vx,vy,lit8	Calculates vy/lit8 and stores the result into vx.	DB00 0203 - mul-int/lit8 v0,v2, #int3 Calculates v2/3 and stores the result into v0.
DC	rem-int/lit8 vx,vy,lit8	Calculates vy % lit8 and stores the result into vx.	DC00 0203 - rem-int/lit8 v0,v2, #int3 Calculates v2 % 3 and stores the result into v0.
DD	and-int/lit8 vx,vy,lit8	Calculates vy AND lit8 and stores the result into vx.	DD00 0203 - and-int/lit8 v0,v2, #int3 Calculates v2 AND 3 and stores the result into v0.
DE	or-int/lit8 vx, vy, lit8	Calculates vy OR lit8 and puts the result into vx.	DE00 0203 - or-int/lit8 v0, v2, #int 3 Calculates v2 OR literal 3 and puts the result into v0.
DF	xor-int/lit8 vx, vy, lit8	Calculates vy XOR lit8 and puts the result into vx.	DF00 0203     |  0008: xor-int/lit8 v0, v2, #int 3 Calculates v2 XOR literal 3 and puts the result into v0.
E0	shl-int/lit8 vx, vy, lit8	Shift v0 left by the bit positions specified by the literal constant and put the result into vx.	E001 0001 - shl-int/lit8 v1, v0, #int 1 Shift v0 left by 1 position and put the result into v1.
E1	shr-int/lit8 vx, vy, lit8	Shift v0 right by the bit positions specified by the literal constant and put the result into vx.	E101 0001 - shr-int/lit8 v1, v0, #int 1 Shift v0 right by 1 position and put the result into v1.
E2	ushr-int/lit8 vx, vy, lit8	Unsigned right shift of v0 (>>>) by the bit positions specified by the literal constant and put the result into vx.	E201 0001 - ushr-int/lit8 v1, v0, #int 1 Unsigned shift v0 right by 1 position and put the result into v1.
E3	unused_E3
E4	unused_E4
E5	unused_E5
E6	unused_E6
E7	unused_E7
E8	unused_E8
E9	unused_E9
EA	unused_EA
EB	unused_EB
EC	unused_EC
ED	unused_ED
EE	execute-inline {parameters},inline ID	Executes the inline method identified by inline ID6.	EE20 0300 0100 - execute-inline {v1, v0}, inline #0003 Executes inline method #3 using v1 as "this" and passing one parameter in v0.
EF	unused_EF
F0	invoke-direct-empty	Stands as a placeholder for pruned empty methods like Object.<init>. This acts as nop during normal execution6.	F010 F608 0000 - invoke-direct-empty {v0}, Ljava/lang/Object;.<init>:()V // method@08f6 Replacement for the empty method java/lang/Object;<init>.
F1	unused_F1
F2	iget-quick vx,vy,offset	Gets the value stored at offset in vy instance's data area to vx6.	F221 1000 - iget-quick v1, v2, [obj+0010] Gets the value at offset 0CH of the instance pointed by v2 and stores the object reference in v1.
F3	iget-wide-quick vx,vy,offset	Gets the object reference value stored at offset in vy instance's data area to vx,vx+16.	F364 3001 - iget-wide-quick v4, v6, [obj+0130] Gets the value at offset 130H of the instance pointed by v6 and stores the object reference in v4,v5.
F4	iget-object-quick vx,vy,offset	Gets the object reference value stored at offset in vy instance's data area to vx6.	F431 0C00 - iget-object-quick v1, v3, [obj+000c] Gets the object reference value at offset 0CH of the instance pointed by v3 and stores the object reference in v1.
F5	iput-quick vx,vy,offset	Puts the value stored in vx to offset in vy instance's data area6.	F521 1000  - iput-quick v1, v2, [obj+0010] Puts the object reference value in v1 to offset 10H of the instance pointed by v2.
F6	iput-wide-quick vx,vy,offset	Puts the value stored in vx,vx+1 to offset in vy instance's data area6.	F652 7001 - iput-wide-quick v2, v5, [obj+0170] Puts the value in v2,v3 to offset 170H of the instance pointed by v5.
F7	iput-object-quick vx,vy,offset	Puts the object reference value stored in vx to offset in vy instance's data area to vx6.	F701 4C00 - iput-object-quick v1, v0, [obj+004c] Puts the object reference value in v1 to offset 0CH of the instance pointed by v3.
F8	invoke-virtual-quick {parameters},vtable offset	Invokes a virtual method using the vtable of the target object6.	F820 B800 CF00 - invoke-virtual-quick {v15, v12}, vtable #00b8 Invokes a virtual method. The target object instance is pointed by v15 and vtable entry #B8 points to the method to be called. v12 is a parameter to the method call.
F9	invoke-virtual-quick/range {parameter range},vtable offset	Invokes a virtual method using the vtable of the target object6	F906 1800 0000 - invoke-virtual-quick/range {v0..v5},vtable #0018 Invokes a method using the vtable of the instance pointed by v0. v1..v5 registers are parameters to the method call.
FA	invoke-super-quick {parameters},vtable offset	Invokes a virtual method in the target object's immediate parent class using the vtable of that parent class6.	FA40 8100 3254  - invoke-super-quick {v2, v3, v4, v5}, vtable #0081 Invokes a method using the vtable of the immediate parent class of instance pointed by v2. v3, v4 and v5 registers are parameters to the method call.
FB	invoke-super-quick/range {register range},vtable offset	Invokes a virtual method in the target object's immediate parent class using the vtable of that parent class6.	F906 1B00 0000 - invoke-super-quick/range {v0..v5}, vtable #001b Invokes a method using the vtable of the immediate parent class of instance pointed by v0. v1..v5 registers are parameters to the method call.
FC	unused_FC
FD	unused_FD
FE	unused_FE
FF	unused_FF

1. Note that double and long values occupy two registers (e.g. the value addressed by vy is located in vy and vy+1 registers)
2. The offset can be positive or negative and it is calculated from the offset of the starting byte of the instruction. The offset is always interpreted in words (2 bytes per 1 offset value increment/decrement). Negative offset is stored in two's complement format. The current position is the offset of the starting byte of the instruction.
3. Compare operations returrn positive value if the first operand is greater than the second operand, 0 if they are equal and negative value if the first operand is smaller than the second operand.
4. Not seen in the wild, interpolated from Dalvik bytecode list.
5. The invocation parameter list encoding is somewhat weird. Starting if parameter number > 4 and parameter number % 4 == 1, the 5th (9th, etc.) parameter is encoded on the 4 lowest bit of the byte immediately following the instruction. Curiously, this encoding is not used in case of 1 parameter, in this case an entire 16 bit word is added after the method index of which only 4 bit is used to encode the single parameter while the lowest 4 bit of the byte following the instruction byte is left unused.
6. This is an unsafe instruction and occurs only in ODEX files.