@futpib/parser 1.0.2 → 1.0.4

package/build/dalvikBytecodeParser.d.ts

@@ -1,8 +1,8 @@
-import { DalvikExecutableField, DalvikExecutableMethod } from "./dalvikExecutable.js";
-import { IndexIntoFieldIds, IndexIntoMethodIds, IndexIntoStringIds, IndexIntoTypeIds } from "./dalvikExecutableParser/typedNumbers.js";
-import { Parser } from "./parser.js";
+import { type DalvikExecutableField, type DalvikExecutableMethod } from './dalvikExecutable.js';
+import { type IndexIntoFieldIds, type IndexIntoMethodIds, type IndexIntoPrototypeIds, type IndexIntoStringIds, type IndexIntoTypeIds } from './dalvikExecutableParser/typedNumbers.js';
+import { type Parser } from './parser.js';
 type DalvikBytecodeOperationNoOperation = {
-    operation: 'no-operation';
+    operation: 'nop';
 };
 declare const dalvikBytecodeOperationInvokeVirtualParser: Parser<{
     operation: "invoke-virtual";
@@ -35,21 +35,1007 @@ declare const dalvikBytecodeOperationInvokeInterfaceParser: Parser<{
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationInvokeInterface = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeInterfaceParser>>;
 type DalvikBytecodeOperationInvoke = DalvikBytecodeOperationInvokeVirtual | DalvikBytecodeOperationInvokeSuper | DalvikBytecodeOperationInvokeDirect | DalvikBytecodeOperationInvokeStatic | DalvikBytecodeOperationInvokeInterface;
+declare const dalvikBytecodeOperationInvokeVirtualRangeParser: Parser<{
+    operation: "invoke-virtual/range";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeVirtualRange = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeVirtualRangeParser>>;
+declare const dalvikBytecodeOperationInvokeSuperRangeParser: Parser<{
+    operation: "invoke-super/range";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeSuperRange = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeSuperRangeParser>>;
+declare const dalvikBytecodeOperationInvokeDirectRangeParser: Parser<{
+    operation: "invoke-direct/range";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeDirectRange = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeDirectRangeParser>>;
+declare const dalvikBytecodeOperationInvokeStaticRangeParser: Parser<{
+    operation: "invoke-static/range";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeStaticRange = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeStaticRangeParser>>;
+declare const dalvikBytecodeOperationInvokeInterfaceRangeParser: Parser<{
+    operation: "invoke-interface/range";
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInvokeInterfaceRange = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeInterfaceRangeParser>>;
+type DalvikBytecodeOperationInvokeRange = DalvikBytecodeOperationInvokeVirtualRange | DalvikBytecodeOperationInvokeSuperRange | DalvikBytecodeOperationInvokeDirectRange | DalvikBytecodeOperationInvokeStaticRange | DalvikBytecodeOperationInvokeInterfaceRange;
+type DalvikBytecodeOperationInvokePolymorphic = {
+    operation: 'invoke-polymorphic';
+    methodIndex: IndexIntoMethodIds;
+    protoIndex: IndexIntoPrototypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationInvokePolymorphicRange = {
+    operation: 'invoke-polymorphic/range';
+    methodIndex: IndexIntoMethodIds;
+    protoIndex: IndexIntoPrototypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationGoto = {
+    operation: 'goto';
+    branchOffset: number;
+};
+type DalvikBytecodeOperationGoto16 = {
+    operation: 'goto/16';
+    branchOffset: number;
+};
+type DalvikBytecodeOperationGoto32 = {
+    operation: 'goto/32';
+    branchOffset: number;
+};
+type DalvikBytecodeOperationPackedSwitch = {
+    operation: 'packed-switch';
+    branchOffset: number;
+    registers: number[];
+};
+type DalvikBytecodeOperationPackedSwitchPayload = {
+    operation: 'packed-switch-payload';
+    value: number;
+    branchOffsets: number[];
+};
+type DalvikBytecodeOperationSparseSwitch = {
+    operation: 'sparse-switch';
+    branchOffset: number;
+    registers: number[];
+};
+type DalvikBytecodeOperationSparseSwitchPayload = {
+    operation: 'sparse-switch-payload';
+    keys: number[];
+    branchOffsets: number[];
+};
+type DalvikBytecodeOperationFillArrayDataPayload = {
+    operation: 'fill-array-data-payload';
+    elementWidth: number;
+    data: number[];
+};
 type DalvikBytecodeOperationInstanceOf = {
     operation: 'instance-of';
     registers: number[];
     typeIndex: IndexIntoTypeIds;
 };
+declare const dalvikBytecodeOperationArrayElementGetParser: Parser<{
+    operation: "aget";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGet = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetParser>>;
+declare const dalvikBytecodeOperationArrayElementGetWideParser: Parser<{
+    operation: "aget-wide";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGetWide = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetWideParser>>;
+declare const dalvikBytecodeOperationArrayElementGetObjectParser: Parser<{
+    operation: "aget-object";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGetObject = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetObjectParser>>;
+declare const dalvikBytecodeOperationArrayElementGetBooleanParser: Parser<{
+    operation: "aget-boolean";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGetBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetBooleanParser>>;
+declare const dalvikBytecodeOperationArrayElementGetByteParser: Parser<{
+    operation: "aget-byte";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGetByte = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetByteParser>>;
+declare const dalvikBytecodeOperationArrayElementGetCharParser: Parser<{
+    operation: "aget-char";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGetChar = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetCharParser>>;
+declare const dalvikBytecodeOperationArrayElementGetShortParser: Parser<{
+    operation: "aget-short";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementGetShort = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetShortParser>>;
+declare const dalvikBytecodeOperationArrayElementPutParser: Parser<{
+    operation: "aput";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPut = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutParser>>;
+declare const dalvikBytecodeOperationArrayElementPutWideParser: Parser<{
+    operation: "aput-wide";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPutWide = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutWideParser>>;
+declare const dalvikBytecodeOperationArrayElementPutObjectParser: Parser<{
+    operation: "aput-object";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPutObject = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutObjectParser>>;
+declare const dalvikBytecodeOperationArrayElementPutBooleanParser: Parser<{
+    operation: "aput-boolean";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPutBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutBooleanParser>>;
+declare const dalvikBytecodeOperationArrayElementPutByteParser: Parser<{
+    operation: "aput-byte";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPutByte = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutByteParser>>;
+declare const dalvikBytecodeOperationArrayElementPutCharParser: Parser<{
+    operation: "aput-char";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPutChar = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutCharParser>>;
+declare const dalvikBytecodeOperationArrayElementPutShortParser: Parser<{
+    operation: "aput-short";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationArrayElementPutShort = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutShortParser>>;
+type DalvikBytecodeOperationArrayElement = DalvikBytecodeOperationArrayElementGet | DalvikBytecodeOperationArrayElementGetWide | DalvikBytecodeOperationArrayElementGetObject | DalvikBytecodeOperationArrayElementGetBoolean | DalvikBytecodeOperationArrayElementGetByte | DalvikBytecodeOperationArrayElementGetChar | DalvikBytecodeOperationArrayElementGetShort | DalvikBytecodeOperationArrayElementPut | DalvikBytecodeOperationArrayElementPutWide | DalvikBytecodeOperationArrayElementPutObject | DalvikBytecodeOperationArrayElementPutBoolean | DalvikBytecodeOperationArrayElementPutByte | DalvikBytecodeOperationArrayElementPutChar | DalvikBytecodeOperationArrayElementPutShort;
+declare const dalvikBytecodeOperationInstanceFieldGetParser: Parser<{
+    operation: "iget";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGet = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetParser>>;
+declare const dalvikBytecodeOperationInstanceFieldGetWideParser: Parser<{
+    operation: "iget-wide";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGetWide = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetWideParser>>;
+declare const dalvikBytecodeOperationInstanceFieldGetObjectParser: Parser<{
+    operation: "iget-object";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGetObject = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetObjectParser>>;
+declare const dalvikBytecodeOperationInstanceFieldGetBooleanParser: Parser<{
+    operation: "iget-boolean";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGetBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetBooleanParser>>;
+declare const dalvikBytecodeOperationInstanceFieldGetByteParser: Parser<{
+    operation: "iget-byte";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGetByte = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetByteParser>>;
+declare const dalvikBytecodeOperationInstanceFieldGetCharParser: Parser<{
+    operation: "iget-char";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGetChar = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetCharParser>>;
+declare const dalvikBytecodeOperationInstanceFieldGetShortParser: Parser<{
+    operation: "iget-short";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldGetShort = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldGetShortParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutParser: Parser<{
+    operation: "iput";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPut = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutWideParser: Parser<{
+    operation: "iput-wide";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPutWide = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutWideParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutObjectParser: Parser<{
+    operation: "iput-object";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPutObject = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutObjectParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutBooleanParser: Parser<{
+    operation: "iput-boolean";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPutBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutBooleanParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutByteParser: Parser<{
+    operation: "iput-byte";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPutByte = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutByteParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutCharParser: Parser<{
+    operation: "iput-char";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPutChar = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutCharParser>>;
+declare const dalvikBytecodeOperationInstanceFieldPutShortParser: Parser<{
+    operation: "iput-short";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationInstanceFieldPutShort = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutShortParser>>;
+type DalvikBytecodeOperationInstanceField = DalvikBytecodeOperationInstanceFieldGet | DalvikBytecodeOperationInstanceFieldGetWide | DalvikBytecodeOperationInstanceFieldGetObject | DalvikBytecodeOperationInstanceFieldGetBoolean | DalvikBytecodeOperationInstanceFieldGetByte | DalvikBytecodeOperationInstanceFieldGetChar | DalvikBytecodeOperationInstanceFieldGetShort | DalvikBytecodeOperationInstanceFieldPut | DalvikBytecodeOperationInstanceFieldPutWide | DalvikBytecodeOperationInstanceFieldPutObject | DalvikBytecodeOperationInstanceFieldPutBoolean | DalvikBytecodeOperationInstanceFieldPutByte | DalvikBytecodeOperationInstanceFieldPutChar | DalvikBytecodeOperationInstanceFieldPutShort;
+declare const dalvikBytecodeOperationStaticFieldGetParser: Parser<{
+    operation: "sget";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGet = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetParser>>;
+declare const dalvikBytecodeOperationStaticFieldGetWideParser: Parser<{
+    operation: "sget-wide";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGetWide = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetWideParser>>;
+declare const dalvikBytecodeOperationStaticFieldGetObjectParser: Parser<{
+    operation: "sget-object";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGetObject = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetObjectParser>>;
+declare const dalvikBytecodeOperationStaticFieldGetBooleanParser: Parser<{
+    operation: "sget-boolean";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGetBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetBooleanParser>>;
+declare const dalvikBytecodeOperationStaticFieldGetByteParser: Parser<{
+    operation: "sget-byte";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGetByte = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetByteParser>>;
+declare const dalvikBytecodeOperationStaticFieldGetCharParser: Parser<{
+    operation: "sget-char";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGetChar = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetCharParser>>;
+declare const dalvikBytecodeOperationStaticFieldGetShortParser: Parser<{
+    operation: "sget-short";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldGetShort = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldGetShortParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutParser: Parser<{
+    operation: "sput";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPut = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutWideParser: Parser<{
+    operation: "sput-wide";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPutWide = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutWideParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutObjectParser: Parser<{
+    operation: "sput-object";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPutObject = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutObjectParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutBooleanParser: Parser<{
+    operation: "sput-boolean";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPutBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutBooleanParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutByteParser: Parser<{
+    operation: "sput-byte";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPutByte = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutByteParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutCharParser: Parser<{
+    operation: "sput-char";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPutChar = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutCharParser>>;
+declare const dalvikBytecodeOperationStaticFieldPutShortParser: Parser<{
+    operation: "sput-short";
+    registers: number[];
+    fieldIndex: IndexIntoFieldIds;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationStaticFieldPutShort = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutShortParser>>;
+type DalvikBytecodeOperationStaticField = DalvikBytecodeOperationStaticFieldGet | DalvikBytecodeOperationStaticFieldGetWide | DalvikBytecodeOperationStaticFieldGetObject | DalvikBytecodeOperationStaticFieldGetBoolean | DalvikBytecodeOperationStaticFieldGetByte | DalvikBytecodeOperationStaticFieldGetChar | DalvikBytecodeOperationStaticFieldGetShort | DalvikBytecodeOperationStaticFieldPut | DalvikBytecodeOperationStaticFieldPutWide | DalvikBytecodeOperationStaticFieldPutObject | DalvikBytecodeOperationStaticFieldPutBoolean | DalvikBytecodeOperationStaticFieldPutByte | DalvikBytecodeOperationStaticFieldPutChar | DalvikBytecodeOperationStaticFieldPutShort;
+declare const dalvikBytecodeOperationAddIntLiteral8Parser: Parser<{
+    operation: "add-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationReverseSubtractIntLiteral8Parser: Parser<{
+    operation: "rsub-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationReverseSubtractIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationMultiplyIntLiteral8Parser: Parser<{
+    operation: "mul-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationDivideIntLiteral8Parser: Parser<{
+    operation: "div-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationRemainderIntLiteral8Parser: Parser<{
+    operation: "rem-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationAndIntLiteral8Parser: Parser<{
+    operation: "and-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAndIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationOrIntLiteral8Parser: Parser<{
+    operation: "or-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationOrIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationXorIntLiteral8Parser: Parser<{
+    operation: "xor-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationXorIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationShiftLeftIntLiteral8Parser: Parser<{
+    operation: "shl-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftLeftIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationShiftRightIntLiteral8Parser: Parser<{
+    operation: "shr-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftRightIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightIntLiteral8Parser>>;
+declare const dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser: Parser<{
+    operation: "ushr-int/lit8";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationUnsignedShiftRightIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser>>;
+type DalvikBytecodeOperationBinaryOperationLiteral8 = DalvikBytecodeOperationAddIntLiteral8 | DalvikBytecodeOperationReverseSubtractIntLiteral8 | DalvikBytecodeOperationMultiplyIntLiteral8 | DalvikBytecodeOperationDivideIntLiteral8 | DalvikBytecodeOperationRemainderIntLiteral8 | DalvikBytecodeOperationAndIntLiteral8 | DalvikBytecodeOperationOrIntLiteral8 | DalvikBytecodeOperationXorIntLiteral8 | DalvikBytecodeOperationShiftLeftIntLiteral8 | DalvikBytecodeOperationShiftRightIntLiteral8 | DalvikBytecodeOperationUnsignedShiftRightIntLiteral8;
+declare const dalvikBytecodeOperationAddIntLiteral16Parser: Parser<{
+    operation: "add-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationReverseSubtractIntLiteral16Parser: Parser<{
+    operation: "rsub-int";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationReverseSubtractIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationMultiplyIntLiteral16Parser: Parser<{
+    operation: "mul-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationDivideIntLiteral16Parser: Parser<{
+    operation: "div-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationRemainderIntLiteral16Parser: Parser<{
+    operation: "rem-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationAndIntLiteral16Parser: Parser<{
+    operation: "and-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAndIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationOrIntLiteral16Parser: Parser<{
+    operation: "or-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationOrIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntLiteral16Parser>>;
+declare const dalvikBytecodeOperationXorIntLiteral16Parser: Parser<{
+    operation: "xor-int/lit16";
+    registers: number[];
+    value: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationXorIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntLiteral16Parser>>;
+type DalvikBytecodeOperationBinaryOperationLiteral16 = DalvikBytecodeOperationAddIntLiteral16 | DalvikBytecodeOperationReverseSubtractIntLiteral16 | DalvikBytecodeOperationMultiplyIntLiteral16 | DalvikBytecodeOperationDivideIntLiteral16 | DalvikBytecodeOperationRemainderIntLiteral16 | DalvikBytecodeOperationAndIntLiteral16 | DalvikBytecodeOperationOrIntLiteral16 | DalvikBytecodeOperationXorIntLiteral16;
+declare const dalvikBytecodeOperationAddIntInPlaceParser: Parser<{
+    operation: "add-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntInPlaceParser>>;
+declare const dalvikBytecodeOperationReverseSubtractIntInPlaceParser: Parser<{
+    operation: "sub-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationReverseSubtractIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractIntInPlaceParser>>;
+declare const dalvikBytecodeOperationMultiplyIntInPlaceParser: Parser<{
+    operation: "mul-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntInPlaceParser>>;
+declare const dalvikBytecodeOperationDivideIntInPlaceParser: Parser<{
+    operation: "div-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntInPlaceParser>>;
+declare const dalvikBytecodeOperationRemainderIntInPlaceParser: Parser<{
+    operation: "rem-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntInPlaceParser>>;
+declare const dalvikBytecodeOperationAndIntInPlaceParser: Parser<{
+    operation: "and-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAndIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntInPlaceParser>>;
+declare const dalvikBytecodeOperationOrIntInPlaceParser: Parser<{
+    operation: "or-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationOrIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntInPlaceParser>>;
+declare const dalvikBytecodeOperationXorIntInPlaceParser: Parser<{
+    operation: "xor-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationXorIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntInPlaceParser>>;
+declare const dalvikBytecodeOperationShiftLeftIntInPlaceParser: Parser<{
+    operation: "shl-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftLeftIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftIntInPlaceParser>>;
+declare const dalvikBytecodeOperationShiftRightIntInPlaceParser: Parser<{
+    operation: "shr-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftRightIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightIntInPlaceParser>>;
+declare const dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser: Parser<{
+    operation: "ushr-int/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationUnsignedShiftRightIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser>>;
+declare const dalvikBytecodeOperationAddLongInPlaceParser: Parser<{
+    operation: "add-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddLongInPlaceParser>>;
+declare const dalvikBytecodeOperationSubtractLongInPlaceParser: Parser<{
+    operation: "sub-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractLongInPlaceParser>>;
+declare const dalvikBytecodeOperationMultiplyLongInPlaceParser: Parser<{
+    operation: "mul-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyLongInPlaceParser>>;
+declare const dalvikBytecodeOperationDivideLongInPlaceParser: Parser<{
+    operation: "div-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideLongInPlaceParser>>;
+declare const dalvikBytecodeOperationRemainderLongInPlaceParser: Parser<{
+    operation: "rem-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderLongInPlaceParser>>;
+declare const dalvikBytecodeOperationAndLongInPlaceParser: Parser<{
+    operation: "and-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAndLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAndLongInPlaceParser>>;
+declare const dalvikBytecodeOperationOrLongInPlaceParser: Parser<{
+    operation: "or-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationOrLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationOrLongInPlaceParser>>;
+declare const dalvikBytecodeOperationXorLongInPlaceParser: Parser<{
+    operation: "xor-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationXorLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationXorLongInPlaceParser>>;
+declare const dalvikBytecodeOperationShiftLeftLongInPlaceParser: Parser<{
+    operation: "shl-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftLeftLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftLongInPlaceParser>>;
+declare const dalvikBytecodeOperationShiftRightLongInPlaceParser: Parser<{
+    operation: "shr-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftRightLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightLongInPlaceParser>>;
+declare const dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser: Parser<{
+    operation: "ushr-long/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationUnsignedShiftRightLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser>>;
+declare const dalvikBytecodeOperationAddFloatInPlaceParser: Parser<{
+    operation: "add-float/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddFloatInPlaceParser>>;
+declare const dalvikBytecodeOperationSubtractFloatInPlaceParser: Parser<{
+    operation: "sub-float/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractFloatInPlaceParser>>;
+declare const dalvikBytecodeOperationMultiplyFloatInPlaceParser: Parser<{
+    operation: "mul-float/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyFloatInPlaceParser>>;
+declare const dalvikBytecodeOperationDivideFloatInPlaceParser: Parser<{
+    operation: "div-float/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideFloatInPlaceParser>>;
+declare const dalvikBytecodeOperationRemainderFloatInPlaceParser: Parser<{
+    operation: "rem-float/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderFloatInPlaceParser>>;
+declare const dalvikBytecodeOperationAddDoubleInPlaceParser: Parser<{
+    operation: "add-double/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddDoubleInPlaceParser>>;
+declare const dalvikBytecodeOperationSubtractDoubleInPlaceParser: Parser<{
+    operation: "sub-double/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractDoubleInPlaceParser>>;
+declare const dalvikBytecodeOperationMultiplyDoubleInPlaceParser: Parser<{
+    operation: "mul-double/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyDoubleInPlaceParser>>;
+declare const dalvikBytecodeOperationDivideDoubleInPlaceParser: Parser<{
+    operation: "div-double/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideDoubleInPlaceParser>>;
+declare const dalvikBytecodeOperationRemainderDoubleInPlaceParser: Parser<{
+    operation: "rem-double/2addr";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderDoubleInPlaceParser>>;
+type DalvikBytecodeOperationBinaryOperationInPlace = DalvikBytecodeOperationAddIntInPlace | DalvikBytecodeOperationReverseSubtractIntInPlace | DalvikBytecodeOperationMultiplyIntInPlace | DalvikBytecodeOperationDivideIntInPlace | DalvikBytecodeOperationRemainderIntInPlace | DalvikBytecodeOperationAndIntInPlace | DalvikBytecodeOperationOrIntInPlace | DalvikBytecodeOperationXorIntInPlace | DalvikBytecodeOperationShiftLeftIntInPlace | DalvikBytecodeOperationShiftRightIntInPlace | DalvikBytecodeOperationUnsignedShiftRightIntInPlace | DalvikBytecodeOperationAddLongInPlace | DalvikBytecodeOperationSubtractLongInPlace | DalvikBytecodeOperationMultiplyLongInPlace | DalvikBytecodeOperationDivideLongInPlace | DalvikBytecodeOperationRemainderLongInPlace | DalvikBytecodeOperationAndLongInPlace | DalvikBytecodeOperationOrLongInPlace | DalvikBytecodeOperationXorLongInPlace | DalvikBytecodeOperationShiftLeftLongInPlace | DalvikBytecodeOperationShiftRightLongInPlace | DalvikBytecodeOperationUnsignedShiftRightLongInPlace | DalvikBytecodeOperationAddFloatInPlace | DalvikBytecodeOperationSubtractFloatInPlace | DalvikBytecodeOperationMultiplyFloatInPlace | DalvikBytecodeOperationDivideFloatInPlace | DalvikBytecodeOperationRemainderFloatInPlace | DalvikBytecodeOperationAddDoubleInPlace | DalvikBytecodeOperationSubtractDoubleInPlace | DalvikBytecodeOperationMultiplyDoubleInPlace | DalvikBytecodeOperationDivideDoubleInPlace | DalvikBytecodeOperationRemainderDoubleInPlace;
+declare const dalvikBytecodeOperationAddIntParser: Parser<{
+    operation: "add-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddInt = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntParser>>;
+declare const dalvikBytecodeOperationSubtractIntParser: Parser<{
+    operation: "sub-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractInt = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractIntParser>>;
+declare const dalvikBytecodeOperationMultiplyIntParser: Parser<{
+    operation: "mul-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyInt = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntParser>>;
+declare const dalvikBytecodeOperationDivideIntParser: Parser<{
+    operation: "div-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideInt = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntParser>>;
+declare const dalvikBytecodeOperationRemainderIntParser: Parser<{
+    operation: "rem-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderInt = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntParser>>;
+declare const dalvikBytecodeOperationAndIntParser: Parser<{
+    operation: "and-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAndInt = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntParser>>;
+declare const dalvikBytecodeOperationOrIntParser: Parser<{
+    operation: "or-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationOrInt = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntParser>>;
+declare const dalvikBytecodeOperationXorIntParser: Parser<{
+    operation: "xor-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationXorInt = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntParser>>;
+declare const dalvikBytecodeOperationShiftLeftIntParser: Parser<{
+    operation: "shl-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftLeftInt = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftIntParser>>;
+declare const dalvikBytecodeOperationShiftRightIntParser: Parser<{
+    operation: "shr-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftRightInt = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightIntParser>>;
+declare const dalvikBytecodeOperationUnsignedShiftRightIntParser: Parser<{
+    operation: "ushr-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationUnsignedShiftRightInt = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightIntParser>>;
+declare const dalvikBytecodeOperationAddLongParser: Parser<{
+    operation: "add-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddLong = Awaited<ReturnType<typeof dalvikBytecodeOperationAddLongParser>>;
+declare const dalvikBytecodeOperationSubtractLongParser: Parser<{
+    operation: "sub-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractLong = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractLongParser>>;
+declare const dalvikBytecodeOperationMultiplyLongParser: Parser<{
+    operation: "mul-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyLong = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyLongParser>>;
+declare const dalvikBytecodeOperationDivideLongParser: Parser<{
+    operation: "div-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideLong = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideLongParser>>;
+declare const dalvikBytecodeOperationRemainderLongParser: Parser<{
+    operation: "rem-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderLong = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderLongParser>>;
+declare const dalvikBytecodeOperationAndLongParser: Parser<{
+    operation: "and-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAndLong = Awaited<ReturnType<typeof dalvikBytecodeOperationAndLongParser>>;
+declare const dalvikBytecodeOperationOrLongParser: Parser<{
+    operation: "or-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationOrLong = Awaited<ReturnType<typeof dalvikBytecodeOperationOrLongParser>>;
+declare const dalvikBytecodeOperationXorLongParser: Parser<{
+    operation: "xor-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationXorLong = Awaited<ReturnType<typeof dalvikBytecodeOperationXorLongParser>>;
+declare const dalvikBytecodeOperationShiftLeftLongParser: Parser<{
+    operation: "shl-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftLeftLong = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftLongParser>>;
+declare const dalvikBytecodeOperationShiftRightLongParser: Parser<{
+    operation: "shr-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationShiftRightLong = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightLongParser>>;
+declare const dalvikBytecodeOperationUnsignedShiftRightLongParser: Parser<{
+    operation: "ushr-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationUnsignedShiftRightLong = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightLongParser>>;
+declare const dalvikBytecodeOperationAddFloatParser: Parser<{
+    operation: "add-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationAddFloatParser>>;
+declare const dalvikBytecodeOperationSubtractFloatParser: Parser<{
+    operation: "sub-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractFloatParser>>;
+declare const dalvikBytecodeOperationMultiplyFloatParser: Parser<{
+    operation: "mul-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyFloatParser>>;
+declare const dalvikBytecodeOperationDivideFloatParser: Parser<{
+    operation: "div-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideFloatParser>>;
+declare const dalvikBytecodeOperationAddDoubleParser: Parser<{
+    operation: "add-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationAddDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationAddDoubleParser>>;
+declare const dalvikBytecodeOperationSubtractDoubleParser: Parser<{
+    operation: "sub-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationSubtractDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractDoubleParser>>;
+declare const dalvikBytecodeOperationMultiplyDoubleParser: Parser<{
+    operation: "mul-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationMultiplyDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyDoubleParser>>;
+declare const dalvikBytecodeOperationDivideDoubleParser: Parser<{
+    operation: "div-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDivideDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideDoubleParser>>;
+declare const dalvikBytecodeOperationRemainderDoubleParser: Parser<{
+    operation: "rem-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationRemainderDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderDoubleParser>>;
+type DalvikBytecodeOperationBinaryOperation = DalvikBytecodeOperationAddInt | DalvikBytecodeOperationSubtractInt | DalvikBytecodeOperationMultiplyInt | DalvikBytecodeOperationDivideInt | DalvikBytecodeOperationRemainderInt | DalvikBytecodeOperationAndInt | DalvikBytecodeOperationOrInt | DalvikBytecodeOperationXorInt | DalvikBytecodeOperationShiftLeftInt | DalvikBytecodeOperationShiftRightInt | DalvikBytecodeOperationUnsignedShiftRightInt | DalvikBytecodeOperationAddLong | DalvikBytecodeOperationSubtractLong | DalvikBytecodeOperationMultiplyLong | DalvikBytecodeOperationDivideLong | DalvikBytecodeOperationRemainderLong | DalvikBytecodeOperationAndLong | DalvikBytecodeOperationOrLong | DalvikBytecodeOperationXorLong | DalvikBytecodeOperationShiftLeftLong | DalvikBytecodeOperationShiftRightLong | DalvikBytecodeOperationUnsignedShiftRightLong | DalvikBytecodeOperationAddFloat | DalvikBytecodeOperationSubtractFloat | DalvikBytecodeOperationMultiplyFloat | DalvikBytecodeOperationDivideFloat | DalvikBytecodeOperationAddDouble | DalvikBytecodeOperationSubtractDouble | DalvikBytecodeOperationMultiplyDouble | DalvikBytecodeOperationDivideDouble | DalvikBytecodeOperationRemainderDouble;
+declare const dalvikBytecodeOperationNegateIntParser: Parser<{
+    operation: "neg-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationNegateInt = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateIntParser>>;
+declare const dalvikBytecodeOperationNotIntParser: Parser<{
+    operation: "not-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationNotInt = Awaited<ReturnType<typeof dalvikBytecodeOperationNotIntParser>>;
+declare const dalvikBytecodeOperationNegateLongParser: Parser<{
+    operation: "neg-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationNegateLong = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateLongParser>>;
+declare const dalvikBytecodeOperationNotLongParser: Parser<{
+    operation: "not-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationNotLong = Awaited<ReturnType<typeof dalvikBytecodeOperationNotLongParser>>;
+declare const dalvikBytecodeOperationNegateFloatParser: Parser<{
+    operation: "neg-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationNegateFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateFloatParser>>;
+declare const dalvikBytecodeOperationNegateDoubleParser: Parser<{
+    operation: "neg-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationNegateDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateDoubleParser>>;
+declare const dalvikBytecodeOperationIntToLongParser: Parser<{
+    operation: "int-to-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIntToLong = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToLongParser>>;
+declare const dalvikBytecodeOperationIntToFloatParser: Parser<{
+    operation: "int-to-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIntToFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToFloatParser>>;
+declare const dalvikBytecodeOperationIntToDoubleParser: Parser<{
+    operation: "int-to-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIntToDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToDoubleParser>>;
+declare const dalvikBytecodeOperationLongToIntParser: Parser<{
+    operation: "long-to-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationLongToInt = Awaited<ReturnType<typeof dalvikBytecodeOperationLongToIntParser>>;
+declare const dalvikBytecodeOperationLongToFloatParser: Parser<{
+    operation: "long-to-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationLongToFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationLongToFloatParser>>;
+declare const dalvikBytecodeOperationLongToDoubleParser: Parser<{
+    operation: "long-to-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationLongToDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationLongToDoubleParser>>;
+declare const dalvikBytecodeOperationFloatToIntParser: Parser<{
+    operation: "float-to-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationFloatToInt = Awaited<ReturnType<typeof dalvikBytecodeOperationFloatToIntParser>>;
+declare const dalvikBytecodeOperationFloatToLongParser: Parser<{
+    operation: "float-to-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationFloatToLong = Awaited<ReturnType<typeof dalvikBytecodeOperationFloatToLongParser>>;
+declare const dalvikBytecodeOperationFloatToDoubleParser: Parser<{
+    operation: "float-to-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationFloatToDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationFloatToDoubleParser>>;
+declare const dalvikBytecodeOperationDoubleToIntParser: Parser<{
+    operation: "double-to-int";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDoubleToInt = Awaited<ReturnType<typeof dalvikBytecodeOperationDoubleToIntParser>>;
+declare const dalvikBytecodeOperationDoubleToLongParser: Parser<{
+    operation: "double-to-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDoubleToLong = Awaited<ReturnType<typeof dalvikBytecodeOperationDoubleToLongParser>>;
+declare const dalvikBytecodeOperationDoubleToFloatParser: Parser<{
+    operation: "double-to-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationDoubleToFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationDoubleToFloatParser>>;
+declare const dalvikBytecodeOperationIntToByteParser: Parser<{
+    operation: "int-to-byte";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIntToByte = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToByteParser>>;
+declare const dalvikBytecodeOperationIntToCharParser: Parser<{
+    operation: "int-to-char";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIntToChar = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToCharParser>>;
+declare const dalvikBytecodeOperationIntToShortParser: Parser<{
+    operation: "int-to-short";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIntToShort = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToShortParser>>;
+type DalvikBytecodeOperationUnaryOperation = DalvikBytecodeOperationNegateInt | DalvikBytecodeOperationNotInt | DalvikBytecodeOperationNegateLong | DalvikBytecodeOperationNotLong | DalvikBytecodeOperationNegateFloat | DalvikBytecodeOperationNegateDouble | DalvikBytecodeOperationIntToLong | DalvikBytecodeOperationIntToFloat | DalvikBytecodeOperationIntToDouble | DalvikBytecodeOperationLongToInt | DalvikBytecodeOperationLongToFloat | DalvikBytecodeOperationLongToDouble | DalvikBytecodeOperationFloatToInt | DalvikBytecodeOperationFloatToLong | DalvikBytecodeOperationFloatToDouble | DalvikBytecodeOperationDoubleToInt | DalvikBytecodeOperationDoubleToLong | DalvikBytecodeOperationDoubleToFloat | DalvikBytecodeOperationIntToByte | DalvikBytecodeOperationIntToChar | DalvikBytecodeOperationIntToShort;
+declare const dalvikBytecodeIfEqualParser: Parser<{
+    operation: "if-eq";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfEqual = Awaited<ReturnType<typeof dalvikBytecodeIfEqualParser>>;
+declare const dalvikBytecodeIfNotEqualParser: Parser<{
+    operation: "if-ne";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfNotEqual = Awaited<ReturnType<typeof dalvikBytecodeIfNotEqualParser>>;
+declare const dalvikBytecodeIfLessThanParser: Parser<{
+    operation: "if-lt";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfLessThan = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanParser>>;
+declare const dalvikBytecodeIfGreaterThanOrEqualToParser: Parser<{
+    operation: "if-ge";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfGreaterThanOrEqualTo = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanOrEqualToParser>>;
+declare const dalvikBytecodeIfGreaterThanParser: Parser<{
+    operation: "if-gt";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfGreaterThan = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanParser>>;
+declare const dalvikBytecodeIfLessThanOrEqualToParser: Parser<{
+    operation: "if-le";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfLessThanOrEqualTo = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanOrEqualToParser>>;
+type DalvikBytecodeOperationIfTest = DalvikBytecodeOperationIfEqual | DalvikBytecodeOperationIfNotEqual | DalvikBytecodeOperationIfLessThan | DalvikBytecodeOperationIfGreaterThanOrEqualTo | DalvikBytecodeOperationIfGreaterThan | DalvikBytecodeOperationIfLessThanOrEqualTo;
+declare const dalvikBytecodeIfEqualZeroParser: Parser<{
+    operation: "if-eqz";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfEqualZero = Awaited<ReturnType<typeof dalvikBytecodeIfEqualZeroParser>>;
+declare const dalvikBytecodeIfNotEqualZeroParser: Parser<{
+    operation: "if-nez";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfNotEqualZero = Awaited<ReturnType<typeof dalvikBytecodeIfNotEqualZeroParser>>;
+declare const dalvikBytecodeIfLessThanZeroParser: Parser<{
+    operation: "if-ltz";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfLessThanZero = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanZeroParser>>;
+declare const dalvikBytecodeIfGreaterThanOrEqualToZeroParser: Parser<{
+    operation: "if-gez";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfGreaterThanOrEqualToZero = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanOrEqualToZeroParser>>;
+declare const dalvikBytecodeIfGreaterThanZeroParser: Parser<{
+    operation: "if-gtz";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfGreaterThanZero = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanZeroParser>>;
+declare const dalvikBytecodeIfLessThanOrEqualToZeroParser: Parser<{
+    operation: "if-lez";
+    registers: number[];
+    branchOffset: number;
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationIfLessThanOrEqualToZero = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanOrEqualToZeroParser>>;
+type DalvikBytecodeOperationIfTestZero = DalvikBytecodeOperationIfEqualZero | DalvikBytecodeOperationIfNotEqualZero | DalvikBytecodeOperationIfLessThanZero | DalvikBytecodeOperationIfGreaterThanOrEqualToZero | DalvikBytecodeOperationIfGreaterThanZero | DalvikBytecodeOperationIfLessThanOrEqualToZero;
+type DalvikBytecodeOperationConstString = {
+    operation: 'const-string';
+    stringIndex: IndexIntoStringIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationConstStringJumbo = {
+    operation: 'const-string/jumbo';
+    stringIndex: IndexIntoStringIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationConstMethodHandle = {
+    operation: 'const-method-handle';
+    methodIndex: IndexIntoMethodIds;
+    registers: number[];
+};
 type DalvikBytecodeOperationNewInstance = {
     operation: 'new-instance';
     typeIndex: IndexIntoTypeIds;
     registers: number[];
 };
+type DalvikBytecodeOperationNewArray = {
+    operation: 'new-array';
+    typeIndex: IndexIntoTypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationFilledNewArray = {
+    operation: 'filled-new-array';
+    typeIndex: IndexIntoTypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationFilledNewArrayRange = {
+    operation: 'filled-new-array/range';
+    typeIndex: IndexIntoTypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationFillArrayData = {
+    operation: 'fill-array-data';
+    branchOffset: number;
+    registers: number[];
+};
 type DalvikBytecodeOperationCheckCast = {
     operation: 'check-cast';
     typeIndex: IndexIntoTypeIds;
     registers: number[];
 };
+type DalvikBytecodeOperationArrayLength = {
+    operation: 'array-length';
+    registers: number[];
+};
+type DalvikBytecodeOperationConstClass = {
+    operation: 'const-class';
+    typeIndex: IndexIntoTypeIds;
+    registers: number[];
+};
+type DalvikBytecodeOperationMonitorEnter = {
+    operation: 'monitor-enter';
+    registers: number[];
+};
+type DalvikBytecodeOperationMonitorExit = {
+    operation: 'monitor-exit';
+    registers: number[];
+};
 type DalvikBytecodeOperationReturnVoid = {
     operation: 'return-void';
 };
@@ -74,7 +1060,121 @@ declare const dalvikBytecodeMoveExceptionParser: Parser<{
 }, Uint8Array<ArrayBufferLike>>;
 type DalvikBytecodeOperationMoveException = Awaited<ReturnType<typeof dalvikBytecodeMoveExceptionParser>>;
 type DalvikBytecodeOperationMoveResult1 = DalvikBytecodeOperationMoveResult | DalvikBytecodeOperationMoveResultWide | DalvikBytecodeOperationMoveResultObject | DalvikBytecodeOperationMoveException;
-export type DalvikBytecodeOperation = DalvikBytecodeOperationNoOperation | DalvikBytecodeOperationInvoke | DalvikBytecodeOperationNewInstance | DalvikBytecodeOperationCheckCast | DalvikBytecodeOperationInstanceOf | DalvikBytecodeOperationReturnVoid | DalvikBytecodeOperationMoveResult1;
+type DalvikBytecodeOperationMove = {
+    operation: 'move';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveWide = {
+    operation: 'move-wide';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveObject = {
+    operation: 'move-object';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveFrom16 = {
+    operation: 'move/from16';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveWideFrom16 = {
+    operation: 'move-wide/from16';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveObjectFrom16 = {
+    operation: 'move-object/from16';
+    registers: number[];
+};
+type DalvikBytecodeOperationMoveWide16 = {
+    operation: 'move-wide/16';
+    registers: number[];
+};
+declare const dalvikBytecodeOperationReturnParser: Parser<{
+    operation: "return";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationReturn = Awaited<ReturnType<typeof dalvikBytecodeOperationReturnParser>>;
+declare const dalvikBytecodeOperationReturnWideParser: Parser<{
+    operation: "return-wide";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationReturnWide = Awaited<ReturnType<typeof dalvikBytecodeOperationReturnWideParser>>;
+declare const dalvikBytecodeOperationReturnObjectParser: Parser<{
+    operation: "return-object";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationReturnObject = Awaited<ReturnType<typeof dalvikBytecodeOperationReturnObjectParser>>;
+type DalvikBytecodeOperationReturn1 = DalvikBytecodeOperationReturn | DalvikBytecodeOperationReturnWide | DalvikBytecodeOperationReturnObject;
+type DalvikBytecodeOperationConst4 = {
+    operation: 'const/4';
+    registers: number[];
+    value: number;
+};
+type DalvikBytecodeOperationConst16 = {
+    operation: 'const/16';
+    registers: number[];
+    value: number;
+};
+type DalvikBytecodeOperationConstHigh16 = {
+    operation: 'const/high16';
+    registers: number[];
+    value: number;
+};
+type DalvikBytecodeOperationConstWide16 = {
+    operation: 'const-wide/16';
+    registers: number[];
+    value: bigint;
+};
+type DalvikBytecodeOperationConstWide32 = {
+    operation: 'const-wide/32';
+    registers: number[];
+    value: bigint;
+};
+type DalvikBytecodeOperationConstWide = {
+    operation: 'const-wide';
+    registers: number[];
+    value: bigint;
+};
+type DalvikBytecodeOperationConstWideHigh16 = {
+    operation: 'const-wide/high16';
+    registers: number[];
+    value: bigint;
+};
+type DalvikBytecodeOperationConst = {
+    operation: 'const';
+    registers: number[];
+    value: number;
+};
+type DalvikBytecodeOperationThrow = {
+    operation: 'throw';
+    registers: number[];
+};
+declare const dalvikBytecodeOperationCompareFloatWithLessThanBiasParser: Parser<{
+    operation: "cmpl-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationCompareFloatWithLessThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareFloatWithLessThanBiasParser>>;
+declare const dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser: Parser<{
+    operation: "cmpg-float";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationCompareFloatWithGreaterThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser>>;
+declare const dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser: Parser<{
+    operation: "cmpl-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationCompareDoubleWithLessThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser>>;
+declare const dalvikBytecodeOperationCompareDoubleWithGreaterThanBiasParser: Parser<{
+    operation: "cmpg-double";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationCompareDoubleWithGreaterThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareDoubleWithGreaterThanBiasParser>>;
+declare const dalvikBytecodeOperationCompareLongParser: Parser<{
+    operation: "cmp-long";
+    registers: number[];
+}, Uint8Array<ArrayBufferLike>>;
+type DalvikBytecodeOperationCompareLong = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareLongParser>>;
+type DalvikBytecodeOperationCompare = DalvikBytecodeOperationCompareFloatWithLessThanBias | DalvikBytecodeOperationCompareFloatWithGreaterThanBias | DalvikBytecodeOperationCompareDoubleWithLessThanBias | DalvikBytecodeOperationCompareDoubleWithGreaterThanBias | DalvikBytecodeOperationCompareLong;
+export type DalvikBytecodeOperation = DalvikBytecodeOperationNoOperation | DalvikBytecodeOperationIfTest | DalvikBytecodeOperationIfTestZero | DalvikBytecodeOperationBinaryOperation | DalvikBytecodeOperationBinaryOperationLiteral8 | DalvikBytecodeOperationBinaryOperationLiteral16 | DalvikBytecodeOperationBinaryOperationInPlace | DalvikBytecodeOperationUnaryOperation | DalvikBytecodeOperationGoto | DalvikBytecodeOperationGoto16 | DalvikBytecodeOperationGoto32 | DalvikBytecodeOperationPackedSwitch | DalvikBytecodeOperationPackedSwitchPayload | DalvikBytecodeOperationSparseSwitch | DalvikBytecodeOperationSparseSwitchPayload | DalvikBytecodeOperationNewArray | DalvikBytecodeOperationFilledNewArray | DalvikBytecodeOperationFilledNewArrayRange | DalvikBytecodeOperationFillArrayDataPayload | DalvikBytecodeOperationMoveResult1 | DalvikBytecodeOperationMove | DalvikBytecodeOperationMoveWide | DalvikBytecodeOperationMoveObject | DalvikBytecodeOperationMoveFrom16 | DalvikBytecodeOperationMoveWideFrom16 | DalvikBytecodeOperationMoveObjectFrom16 | DalvikBytecodeOperationMoveWide16 | DalvikBytecodeOperationInvoke | DalvikBytecodeOperationInvokeRange | DalvikBytecodeOperationInvokePolymorphic | DalvikBytecodeOperationInvokePolymorphicRange | DalvikBytecodeOperationNewInstance | DalvikBytecodeOperationFillArrayData | DalvikBytecodeOperationCheckCast | DalvikBytecodeOperationInstanceOf | DalvikBytecodeOperationArrayLength | DalvikBytecodeOperationArrayElement | DalvikBytecodeOperationInstanceField | DalvikBytecodeOperationStaticField | DalvikBytecodeOperationConst4 | DalvikBytecodeOperationConst16 | DalvikBytecodeOperationConstHigh16 | DalvikBytecodeOperationConstWide16 | DalvikBytecodeOperationConstWide32 | DalvikBytecodeOperationConstWide | DalvikBytecodeOperationConstWideHigh16 | DalvikBytecodeOperationConst | DalvikBytecodeOperationConstString | DalvikBytecodeOperationConstStringJumbo | DalvikBytecodeOperationConstMethodHandle | DalvikBytecodeOperationConstClass | DalvikBytecodeOperationMonitorEnter | DalvikBytecodeOperationMonitorExit | DalvikBytecodeOperationThrow | DalvikBytecodeOperationCompare | DalvikBytecodeOperationReturnVoid | DalvikBytecodeOperationReturn1;
 export declare const dalvikBytecodeOperationCompanion: {
     getRegisters(operation: DalvikBytecodeOperation): number[];
 };