@futpib/parser 1.0.1 → 1.0.2

package/build/dalvikBytecodeParser.js

@@ -0,0 +1,836 @@
+import { createArrayParser } from "./arrayParser.js";
+import { createDalvikBytecodeFormat21cParser, createDalvikBytecodeFormat21sParser, createDalvikBytecodeFormat21tParser, createDalvikBytecodeFormat22bParser, createDalvikBytecodeFormat22cParser, createDalvikBytecodeFormat22sParser, createDalvikBytecodeFormat22tParser, dalvikBytecodeFormat23xParser, dalvikBytecodeFormat31iParser, createDalvikBytecodeFormat35cParser, createDalvikBytecodeFormat3rcParser, dalvikBytecodeFormat10tParser, dalvikBytecodeFormat10xParser, dalvikBytecodeFormat11xParser, dalvikBytecodeFormat12xParser, dalvikBytecodeFormat20tParser, dalvikBytecodeFormat22xParser, nibblesParser, dalvikBytecodeFormat32xParser } from "./dalvikBytecodeParser/formatParsers.js";
+import { isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoStringIds, isoIndexIntoTypeIds } from "./dalvikExecutableParser/typedNumbers.js";
+import { createExactElementParser } from "./exactElementParser.js";
+import { setParserName } from "./parser.js";
+import { promiseCompose } from "./promiseCompose.js";
+import { createSliceBoundedParser } from "./sliceBoundedParser.js";
+import { createTupleParser } from "./tupleParser.js";
+import { createUnionParser } from "./unionParser.js";
+// https://source.android.com/docs/core/runtime/dalvik-bytecode
+const dalvikBytecodeOperationUnusedParser = async (parserContext) => {
+    const opcode = await parserContext.read(0);
+    parserContext.invariant(((opcode >= 0x3e && opcode <= 0x43)
+        || (opcode === 0x73)
+        || (opcode >= 0x79 && opcode <= 0x7a)
+        || (opcode >= 0xe3 && opcode <= 0xf9)), 'Expected unused opcode');
+    parserContext.skip(1);
+};
+setParserName(dalvikBytecodeOperationUnusedParser, 'dalvikBytecodeOperationUnusedParser');
+const dalvikBytecodeOperationNoOperationParser = promiseCompose(createExactElementParser(0x00), () => ({
+    operation: 'no-operation',
+}));
+setParserName(dalvikBytecodeOperationNoOperationParser, 'dalvikBytecodeOperationNoOperationParser');
+const createDalvikBytecodeOperationInvoke = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat35cParser({
+        isoIndex: isoIndexIntoMethodIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation,
+    methodIndex: index,
+    registers,
+}));
+const dalvikBytecodeOperationInvokeVirtualParser = createDalvikBytecodeOperationInvoke('invoke-virtual', 0x6e);
+const dalvikBytecodeOperationInvokeSuperParser = createDalvikBytecodeOperationInvoke('invoke-super', 0x6f);
+const dalvikBytecodeOperationInvokeDirectParser = createDalvikBytecodeOperationInvoke('invoke-direct', 0x70);
+const dalvikBytecodeOperationInvokeStaticParser = createDalvikBytecodeOperationInvoke('invoke-static', 0x71);
+const dalvikBytecodeOperationInvokeInterfaceParser = createDalvikBytecodeOperationInvoke('invoke-interface', 0x72);
+const dalvikBytecodeOperationInvokeParser = createUnionParser([
+    dalvikBytecodeOperationInvokeVirtualParser,
+    dalvikBytecodeOperationInvokeSuperParser,
+    dalvikBytecodeOperationInvokeDirectParser,
+    dalvikBytecodeOperationInvokeStaticParser,
+    dalvikBytecodeOperationInvokeInterfaceParser,
+]);
+setParserName(dalvikBytecodeOperationInvokeParser, 'dalvikBytecodeOperationInvokeParser');
+const createDalvikBytecodeOperationInvokeRange = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat3rcParser({
+        isoIndex: isoIndexIntoMethodIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation,
+    methodIndex: index,
+    registers,
+}));
+const dalvikBytecodeOperationInvokeVirtualRangeParser = createDalvikBytecodeOperationInvokeRange('invoke-virtual/range', 0x74);
+const dalvikBytecodeOperationInvokeSuperRangeParser = createDalvikBytecodeOperationInvokeRange('invoke-super/range', 0x75);
+const dalvikBytecodeOperationInvokeDirectRangeParser = createDalvikBytecodeOperationInvokeRange('invoke-direct/range', 0x76);
+const dalvikBytecodeOperationInvokeStaticRangeParser = createDalvikBytecodeOperationInvokeRange('invoke-static/range', 0x77);
+const dalvikBytecodeOperationInvokeInterfaceRangeParser = createDalvikBytecodeOperationInvokeRange('invoke-interface/range', 0x78);
+const dalvikBytecodeOperationInvokeRangeParser = createUnionParser([
+    dalvikBytecodeOperationInvokeVirtualRangeParser,
+    dalvikBytecodeOperationInvokeSuperRangeParser,
+    dalvikBytecodeOperationInvokeDirectRangeParser,
+    dalvikBytecodeOperationInvokeStaticRangeParser,
+    dalvikBytecodeOperationInvokeInterfaceRangeParser,
+]);
+setParserName(dalvikBytecodeOperationInvokeRangeParser, 'dalvikBytecodeOperationInvokeRangeParser');
+const dalvikBytecodeOperationGotoParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x28),
+    dalvikBytecodeFormat10tParser,
+]), ([_opcode, { branchOffset }]) => ({
+    operation: 'goto',
+    branchOffset,
+}));
+const dalvikBytecodeOperationGoto16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x29),
+    dalvikBytecodeFormat20tParser,
+]), ([_opcode, { branchOffset }]) => ({
+    operation: 'goto/16',
+    branchOffset,
+}));
+const dalvikBytecodeOperationInstanceOfParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x20),
+    createDalvikBytecodeFormat22cParser({
+        isoIndex: isoIndexIntoTypeIds,
+    }),
+]), ([_opcode, { registers, index }]) => ({
+    operation: 'instance-of',
+    registers,
+    typeIndex: index,
+}));
+setParserName(dalvikBytecodeOperationInstanceOfParser, 'dalvikBytecodeOperationInstanceOfParser');
+const createDalvikBytecodeOperationArrayElement = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    dalvikBytecodeFormat23xParser,
+]), ([_opcode, { registers }]) => ({
+    operation,
+    registers,
+}));
+const dalvikBytecodeOperationArrayElementGetParser = createDalvikBytecodeOperationArrayElement('aget', 0x44);
+const dalvikBytecodeOperationArrayElementGetWideParser = createDalvikBytecodeOperationArrayElement('aget-wide', 0x45);
+const dalvikBytecodeOperationArrayElementGetObjectParser = createDalvikBytecodeOperationArrayElement('aget-object', 0x46);
+const dalvikBytecodeOperationArrayElementGetBooleanParser = createDalvikBytecodeOperationArrayElement('aget-boolean', 0x47);
+const dalvikBytecodeOperationArrayElementGetByteParser = createDalvikBytecodeOperationArrayElement('aget-byte', 0x48);
+const dalvikBytecodeOperationArrayElementGetCharParser = createDalvikBytecodeOperationArrayElement('aget-char', 0x49);
+const dalvikBytecodeOperationArrayElementGetShortParser = createDalvikBytecodeOperationArrayElement('aget-short', 0x4a);
+const dalvikBytecodeOperationArrayElementPutParser = createDalvikBytecodeOperationArrayElement('aput', 0x4b);
+const dalvikBytecodeOperationArrayElementPutWideParser = createDalvikBytecodeOperationArrayElement('aput-wide', 0x4c);
+const dalvikBytecodeOperationArrayElementPutObjectParser = createDalvikBytecodeOperationArrayElement('aput-object', 0x4d);
+const dalvikBytecodeOperationArrayElementPutBooleanParser = createDalvikBytecodeOperationArrayElement('aput-boolean', 0x4e);
+const dalvikBytecodeOperationArrayElementPutByteParser = createDalvikBytecodeOperationArrayElement('aput-byte', 0x4f);
+const dalvikBytecodeOperationArrayElementPutCharParser = createDalvikBytecodeOperationArrayElement('aput-char', 0x50);
+const dalvikBytecodeOperationArrayElementPutShortParser = createDalvikBytecodeOperationArrayElement('aput-short', 0x51);
+const dalvikBytecodeOperationArrayElementParser = createUnionParser([
+    dalvikBytecodeOperationArrayElementGetParser,
+    dalvikBytecodeOperationArrayElementGetWideParser,
+    dalvikBytecodeOperationArrayElementGetObjectParser,
+    dalvikBytecodeOperationArrayElementGetBooleanParser,
+    dalvikBytecodeOperationArrayElementGetByteParser,
+    dalvikBytecodeOperationArrayElementGetCharParser,
+    dalvikBytecodeOperationArrayElementGetShortParser,
+    dalvikBytecodeOperationArrayElementPutParser,
+    dalvikBytecodeOperationArrayElementPutWideParser,
+    dalvikBytecodeOperationArrayElementPutObjectParser,
+    dalvikBytecodeOperationArrayElementPutBooleanParser,
+    dalvikBytecodeOperationArrayElementPutByteParser,
+    dalvikBytecodeOperationArrayElementPutCharParser,
+    dalvikBytecodeOperationArrayElementPutShortParser,
+]);
+setParserName(dalvikBytecodeOperationArrayElementParser, 'dalvikBytecodeOperationArrayElementParser');
+const createDalvikBytecodeOperationInstanceField = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat22cParser({
+        isoIndex: isoIndexIntoFieldIds,
+    }),
+]), ([_opcode, { registers, index }]) => ({
+    operation,
+    registers,
+    fieldIndex: index,
+}));
+const dalvikBytecodeOperationInstanceFieldGetParser = createDalvikBytecodeOperationInstanceField('iget', 0x52);
+const dalvikBytecodeOperationInstanceFieldGetWideParser = createDalvikBytecodeOperationInstanceField('iget-wide', 0x53);
+const dalvikBytecodeOperationInstanceFieldGetObjectParser = createDalvikBytecodeOperationInstanceField('iget-object', 0x54);
+const dalvikBytecodeOperationInstanceFieldGetBooleanParser = createDalvikBytecodeOperationInstanceField('iget-boolean', 0x55);
+const dalvikBytecodeOperationInstanceFieldGetByteParser = createDalvikBytecodeOperationInstanceField('iget-byte', 0x56);
+const dalvikBytecodeOperationInstanceFieldGetCharParser = createDalvikBytecodeOperationInstanceField('iget-char', 0x57);
+const dalvikBytecodeOperationInstanceFieldGetShortParser = createDalvikBytecodeOperationInstanceField('iget-short', 0x58);
+const dalvikBytecodeOperationInstanceFieldPutParser = createDalvikBytecodeOperationInstanceField('iput', 0x59);
+const dalvikBytecodeOperationInstanceFieldPutWideParser = createDalvikBytecodeOperationInstanceField('iput-wide', 0x5a);
+const dalvikBytecodeOperationInstanceFieldPutObjectParser = createDalvikBytecodeOperationInstanceField('iput-object', 0x5b);
+const dalvikBytecodeOperationInstanceFieldPutBooleanParser = createDalvikBytecodeOperationInstanceField('iput-boolean', 0x5c);
+const dalvikBytecodeOperationInstanceFieldPutByteParser = createDalvikBytecodeOperationInstanceField('iput-byte', 0x5d);
+const dalvikBytecodeOperationInstanceFieldPutCharParser = createDalvikBytecodeOperationInstanceField('iput-char', 0x5e);
+const dalvikBytecodeOperationInstanceFieldPutShortParser = createDalvikBytecodeOperationInstanceField('iput-short', 0x5f);
+const dalvikBytecodeOperationInstanceFieldParser = createUnionParser([
+    dalvikBytecodeOperationInstanceFieldGetParser,
+    dalvikBytecodeOperationInstanceFieldGetWideParser,
+    dalvikBytecodeOperationInstanceFieldGetObjectParser,
+    dalvikBytecodeOperationInstanceFieldGetBooleanParser,
+    dalvikBytecodeOperationInstanceFieldGetByteParser,
+    dalvikBytecodeOperationInstanceFieldGetCharParser,
+    dalvikBytecodeOperationInstanceFieldGetShortParser,
+    dalvikBytecodeOperationInstanceFieldPutParser,
+    dalvikBytecodeOperationInstanceFieldPutWideParser,
+    dalvikBytecodeOperationInstanceFieldPutObjectParser,
+    dalvikBytecodeOperationInstanceFieldPutBooleanParser,
+    dalvikBytecodeOperationInstanceFieldPutByteParser,
+    dalvikBytecodeOperationInstanceFieldPutCharParser,
+    dalvikBytecodeOperationInstanceFieldPutShortParser,
+]);
+setParserName(dalvikBytecodeOperationInstanceFieldParser, 'dalvikBytecodeOperationInstanceFieldParser');
+const createDalvikBytecodeOperationStaticField = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoFieldIds,
+    }),
+]), ([_opcode, { registers, index }]) => ({
+    operation,
+    registers,
+    fieldIndex: index,
+}));
+const dalvikBytecodeOperationStaticFieldGetParser = createDalvikBytecodeOperationStaticField('sget', 0x60);
+const dalvikBytecodeOperationStaticFieldGetWideParser = createDalvikBytecodeOperationStaticField('sget-wide', 0x61);
+const dalvikBytecodeOperationStaticFieldGetObjectParser = createDalvikBytecodeOperationStaticField('sget-object', 0x62);
+const dalvikBytecodeOperationStaticFieldGetBooleanParser = createDalvikBytecodeOperationStaticField('sget-boolean', 0x63);
+const dalvikBytecodeOperationStaticFieldGetByteParser = createDalvikBytecodeOperationStaticField('sget-byte', 0x64);
+const dalvikBytecodeOperationStaticFieldGetCharParser = createDalvikBytecodeOperationStaticField('sget-char', 0x65);
+const dalvikBytecodeOperationStaticFieldGetShortParser = createDalvikBytecodeOperationStaticField('sget-short', 0x66);
+const dalvikBytecodeOperationStaticFieldPutParser = createDalvikBytecodeOperationStaticField('sput', 0x67);
+const dalvikBytecodeOperationStaticFieldPutWideParser = createDalvikBytecodeOperationStaticField('sput-wide', 0x68);
+const dalvikBytecodeOperationStaticFieldPutObjectParser = createDalvikBytecodeOperationStaticField('sput-object', 0x69);
+const dalvikBytecodeOperationStaticFieldPutBooleanParser = createDalvikBytecodeOperationStaticField('sput-boolean', 0x6a);
+const dalvikBytecodeOperationStaticFieldPutByteParser = createDalvikBytecodeOperationStaticField('sput-byte', 0x6b);
+const dalvikBytecodeOperationStaticFieldPutCharParser = createDalvikBytecodeOperationStaticField('sput-char', 0x6c);
+const dalvikBytecodeOperationStaticFieldPutShortParser = createDalvikBytecodeOperationStaticField('sput-short', 0x6d);
+const dalvikBytecodeOperationStaticFieldParser = createUnionParser([
+    dalvikBytecodeOperationStaticFieldGetParser,
+    dalvikBytecodeOperationStaticFieldGetWideParser,
+    dalvikBytecodeOperationStaticFieldGetObjectParser,
+    dalvikBytecodeOperationStaticFieldGetBooleanParser,
+    dalvikBytecodeOperationStaticFieldGetByteParser,
+    dalvikBytecodeOperationStaticFieldGetCharParser,
+    dalvikBytecodeOperationStaticFieldGetShortParser,
+    dalvikBytecodeOperationStaticFieldPutParser,
+    dalvikBytecodeOperationStaticFieldPutWideParser,
+    dalvikBytecodeOperationStaticFieldPutObjectParser,
+    dalvikBytecodeOperationStaticFieldPutBooleanParser,
+    dalvikBytecodeOperationStaticFieldPutByteParser,
+    dalvikBytecodeOperationStaticFieldPutCharParser,
+    dalvikBytecodeOperationStaticFieldPutShortParser,
+]);
+setParserName(dalvikBytecodeOperationStaticFieldParser, 'dalvikBytecodeOperationStaticFieldParser');
+const createDalvikBytecodeOperationBinaryOperationLiteral8 = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat22bParser(),
+]), ([_opcode, { registers, value }]) => ({
+    operation,
+    registers,
+    value,
+}));
+const dalvikBytecodeOperationAddIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('add-int/lit8', 0xd8);
+const dalvikBytecodeOperationReverseSubtractIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('rsub-int/lit8', 0xd9);
+const dalvikBytecodeOperationMultiplyIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('mul-int/lit8', 0xda);
+const dalvikBytecodeOperationDivideIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('div-int/lit8', 0xdb);
+const dalvikBytecodeOperationRemainderIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('rem-int/lit8', 0xdc);
+const dalvikBytecodeOperationAndIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('and-int/lit8', 0xdd);
+const dalvikBytecodeOperationOrIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('or-int/lit8', 0xde);
+const dalvikBytecodeOperationXorIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('xor-int/lit8', 0xdf);
+const dalvikBytecodeOperationShiftLeftIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('shl-int/lit8', 0xe0);
+const dalvikBytecodeOperationShiftRightIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('shr-int/lit8', 0xe1);
+const dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('ushr-int/lit8', 0xe2);
+const dalvikBytecodeOperationBinaryOperationLiteral8Parser = createUnionParser([
+    dalvikBytecodeOperationAddIntLiteral8Parser,
+    dalvikBytecodeOperationReverseSubtractIntLiteral8Parser,
+    dalvikBytecodeOperationMultiplyIntLiteral8Parser,
+    dalvikBytecodeOperationDivideIntLiteral8Parser,
+    dalvikBytecodeOperationRemainderIntLiteral8Parser,
+    dalvikBytecodeOperationAndIntLiteral8Parser,
+    dalvikBytecodeOperationOrIntLiteral8Parser,
+    dalvikBytecodeOperationXorIntLiteral8Parser,
+    dalvikBytecodeOperationShiftLeftIntLiteral8Parser,
+    dalvikBytecodeOperationShiftRightIntLiteral8Parser,
+    dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser,
+]);
+setParserName(dalvikBytecodeOperationBinaryOperationLiteral8Parser, 'dalvikBytecodeOperationBinaryOperationLiteral8Parser');
+const createDalvikBytecodeOperationBinaryOperationLiteral16 = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat22sParser(),
+]), ([_opcode, { registers, value }]) => ({
+    operation,
+    registers,
+    value,
+}));
+const dalvikBytecodeOperationAddIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('add-int/lit16', 0xd0);
+const dalvikBytecodeOperationReverseSubtractIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('rsub-int/lit16', 0xd1);
+const dalvikBytecodeOperationMultiplyIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('mul-int/lit16', 0xd2);
+const dalvikBytecodeOperationDivideIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('div-int/lit16', 0xd3);
+const dalvikBytecodeOperationRemainderIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('rem-int/lit16', 0xd4);
+const dalvikBytecodeOperationAndIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('and-int/lit16', 0xd5);
+const dalvikBytecodeOperationOrIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('or-int/lit16', 0xd6);
+const dalvikBytecodeOperationXorIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('xor-int/lit16', 0xd7);
+const dalvikBytecodeOperationBinaryOperationLiteral16Parser = createUnionParser([
+    dalvikBytecodeOperationAddIntLiteral16Parser,
+    dalvikBytecodeOperationReverseSubtractIntLiteral16Parser,
+    dalvikBytecodeOperationMultiplyIntLiteral16Parser,
+    dalvikBytecodeOperationDivideIntLiteral16Parser,
+    dalvikBytecodeOperationRemainderIntLiteral16Parser,
+    dalvikBytecodeOperationAndIntLiteral16Parser,
+    dalvikBytecodeOperationOrIntLiteral16Parser,
+    dalvikBytecodeOperationXorIntLiteral16Parser,
+]);
+setParserName(dalvikBytecodeOperationBinaryOperationLiteral16Parser, 'dalvikBytecodeOperationBinaryOperationLiteral16Parser');
+const createDalvikBytecodeOperationBinaryOperationInPlace = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    dalvikBytecodeFormat12xParser,
+]), ([_opcode, { registers }]) => ({
+    operation,
+    registers,
+}));
+const dalvikBytecodeOperationAddIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-int/2addr', 0xb0);
+const dalvikBytecodeOperationReverseSubtractIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rsub-int', 0xb1);
+const dalvikBytecodeOperationMultiplyIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-int/2addr', 0xb2);
+const dalvikBytecodeOperationDivideIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-int/2addr', 0xb3);
+const dalvikBytecodeOperationRemainderIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-int/2addr', 0xb4);
+const dalvikBytecodeOperationAndIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('and-int/2addr', 0xb5);
+const dalvikBytecodeOperationOrIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('or-int/2addr', 0xb6);
+const dalvikBytecodeOperationXorIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('xor-int/2addr', 0xb7);
+const dalvikBytecodeOperationShiftLeftIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shl-int/2addr', 0xb8);
+const dalvikBytecodeOperationShiftRightIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shr-int/2addr', 0xb9);
+const dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('ushr-int/2addr', 0xba);
+const dalvikBytecodeOperationAddLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-long/2addr', 0xbb);
+const dalvikBytecodeOperationReverseSubtractLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rsub-long', 0xbc);
+const dalvikBytecodeOperationMultiplyLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-long/2addr', 0xbd);
+const dalvikBytecodeOperationDivideLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-long/2addr', 0xbe);
+const dalvikBytecodeOperationRemainderLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-long/2addr', 0xbf);
+const dalvikBytecodeOperationAndLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('and-long/2addr', 0xc0);
+const dalvikBytecodeOperationOrLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('or-long/2addr', 0xc1);
+const dalvikBytecodeOperationXorLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('xor-long/2addr', 0xc2);
+const dalvikBytecodeOperationShiftLeftLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shl-long/2addr', 0xc3);
+const dalvikBytecodeOperationShiftRightLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shr-long/2addr', 0xc4);
+const dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('ushr-long/2addr', 0xc5);
+const dalvikBytecodeOperationAddFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-float/2addr', 0xc6);
+const dalvikBytecodeOperationSubtractFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-float/2addr', 0xc7);
+const dalvikBytecodeOperationMultiplyFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-float/2addr', 0xc8);
+const dalvikBytecodeOperationDivideFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-float/2addr', 0xc9);
+const dalvikBytecodeOperationAddDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-double/2addr', 0xca);
+const dalvikBytecodeOperationSubtractDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-double/2addr', 0xcb);
+const dalvikBytecodeOperationMultiplyDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-double/2addr', 0xcc);
+const dalvikBytecodeOperationDivideDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-double/2addr', 0xcd);
+const dalvikBytecodeOperationRemainderDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-double/2addr', 0xce);
+const dalvikBytecodeOperationBinaryOperationInPlaceParser = createUnionParser([
+    dalvikBytecodeOperationAddIntInPlaceParser,
+    dalvikBytecodeOperationReverseSubtractIntInPlaceParser,
+    dalvikBytecodeOperationMultiplyIntInPlaceParser,
+    dalvikBytecodeOperationDivideIntInPlaceParser,
+    dalvikBytecodeOperationRemainderIntInPlaceParser,
+    dalvikBytecodeOperationAndIntInPlaceParser,
+    dalvikBytecodeOperationOrIntInPlaceParser,
+    dalvikBytecodeOperationXorIntInPlaceParser,
+    dalvikBytecodeOperationShiftLeftIntInPlaceParser,
+    dalvikBytecodeOperationShiftRightIntInPlaceParser,
+    dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser,
+    dalvikBytecodeOperationAddLongInPlaceParser,
+    dalvikBytecodeOperationReverseSubtractLongInPlaceParser,
+    dalvikBytecodeOperationMultiplyLongInPlaceParser,
+    dalvikBytecodeOperationDivideLongInPlaceParser,
+    dalvikBytecodeOperationRemainderLongInPlaceParser,
+    dalvikBytecodeOperationAndLongInPlaceParser,
+    dalvikBytecodeOperationOrLongInPlaceParser,
+    dalvikBytecodeOperationXorLongInPlaceParser,
+    dalvikBytecodeOperationShiftLeftLongInPlaceParser,
+    dalvikBytecodeOperationShiftRightLongInPlaceParser,
+    dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser,
+    dalvikBytecodeOperationAddFloatInPlaceParser,
+    dalvikBytecodeOperationSubtractFloatInPlaceParser,
+    dalvikBytecodeOperationMultiplyFloatInPlaceParser,
+    dalvikBytecodeOperationDivideFloatInPlaceParser,
+    dalvikBytecodeOperationAddDoubleInPlaceParser,
+    dalvikBytecodeOperationSubtractDoubleInPlaceParser,
+    dalvikBytecodeOperationMultiplyDoubleInPlaceParser,
+    dalvikBytecodeOperationDivideDoubleInPlaceParser,
+    dalvikBytecodeOperationRemainderDoubleInPlaceParser,
+]);
+setParserName(dalvikBytecodeOperationBinaryOperationInPlaceParser, 'dalvikBytecodeOperationBinaryOperationInPlaceParser');
+const createDalvikBytecodeOperationBinaryOperation = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    dalvikBytecodeFormat23xParser,
+]), ([_opcode, { registers }]) => ({
+    operation,
+    registers,
+}));
+const dalvikBytecodeOperationAddIntParser = createDalvikBytecodeOperationBinaryOperation('add-int', 0x90);
+const dalvikBytecodeOperationSubtractIntParser = createDalvikBytecodeOperationBinaryOperation('sub-int', 0x91);
+const dalvikBytecodeOperationMultiplyIntParser = createDalvikBytecodeOperationBinaryOperation('mul-int', 0x92);
+const dalvikBytecodeOperationDivideIntParser = createDalvikBytecodeOperationBinaryOperation('div-int', 0x93);
+const dalvikBytecodeOperationRemainderIntParser = createDalvikBytecodeOperationBinaryOperation('rem-int', 0x94);
+const dalvikBytecodeOperationAndIntParser = createDalvikBytecodeOperationBinaryOperation('and-int', 0x95);
+const dalvikBytecodeOperationOrIntParser = createDalvikBytecodeOperationBinaryOperation('or-int', 0x96);
+const dalvikBytecodeOperationXorIntParser = createDalvikBytecodeOperationBinaryOperation('xor-int', 0x97);
+const dalvikBytecodeOperationShiftLeftIntParser = createDalvikBytecodeOperationBinaryOperation('shl-int', 0x98);
+const dalvikBytecodeOperationShiftRightIntParser = createDalvikBytecodeOperationBinaryOperation('shr-int', 0x99);
+const dalvikBytecodeOperationUnsignedShiftRightIntParser = createDalvikBytecodeOperationBinaryOperation('ushr-int', 0x9a);
+const dalvikBytecodeOperationAddLongParser = createDalvikBytecodeOperationBinaryOperation('add-long', 0x9b);
+const dalvikBytecodeOperationSubtractLongParser = createDalvikBytecodeOperationBinaryOperation('sub-long', 0x9c);
+const dalvikBytecodeOperationMultiplyLongParser = createDalvikBytecodeOperationBinaryOperation('mul-long', 0x9d);
+const dalvikBytecodeOperationDivideLongParser = createDalvikBytecodeOperationBinaryOperation('div-long', 0x9e);
+const dalvikBytecodeOperationRemainderLongParser = createDalvikBytecodeOperationBinaryOperation('rem-long', 0x9f);
+const dalvikBytecodeOperationAndLongParser = createDalvikBytecodeOperationBinaryOperation('and-long', 0xa0);
+const dalvikBytecodeOperationOrLongParser = createDalvikBytecodeOperationBinaryOperation('or-long', 0xa1);
+const dalvikBytecodeOperationXorLongParser = createDalvikBytecodeOperationBinaryOperation('xor-long', 0xa2);
+const dalvikBytecodeOperationShiftLeftLongParser = createDalvikBytecodeOperationBinaryOperation('shl-long', 0xa3);
+const dalvikBytecodeOperationShiftRightLongParser = createDalvikBytecodeOperationBinaryOperation('shr-long', 0xa4);
+const dalvikBytecodeOperationUnsignedShiftRightLongParser = createDalvikBytecodeOperationBinaryOperation('ushr-long', 0xa5);
+const dalvikBytecodeOperationAddFloatParser = createDalvikBytecodeOperationBinaryOperation('add-float', 0xa6);
+const dalvikBytecodeOperationSubtractFloatParser = createDalvikBytecodeOperationBinaryOperation('sub-float', 0xa7);
+const dalvikBytecodeOperationMultiplyFloatParser = createDalvikBytecodeOperationBinaryOperation('mul-float', 0xa8);
+const dalvikBytecodeOperationDivideFloatParser = createDalvikBytecodeOperationBinaryOperation('div-float', 0xa9);
+const dalvikBytecodeOperationAddDoubleParser = createDalvikBytecodeOperationBinaryOperation('add-double', 0xaa);
+const dalvikBytecodeOperationSubtractDoubleParser = createDalvikBytecodeOperationBinaryOperation('sub-double', 0xab);
+const dalvikBytecodeOperationMultiplyDoubleParser = createDalvikBytecodeOperationBinaryOperation('mul-double', 0xac);
+const dalvikBytecodeOperationDivideDoubleParser = createDalvikBytecodeOperationBinaryOperation('div-double', 0xad);
+const dalvikBytecodeOperationRemainderDoubleParser = createDalvikBytecodeOperationBinaryOperation('rem-double', 0xae);
+const dalvikBytecodeOperationBinaryOperationParser = createUnionParser([
+    dalvikBytecodeOperationAddIntParser,
+    dalvikBytecodeOperationSubtractIntParser,
+    dalvikBytecodeOperationMultiplyIntParser,
+    dalvikBytecodeOperationDivideIntParser,
+    dalvikBytecodeOperationRemainderIntParser,
+    dalvikBytecodeOperationAndIntParser,
+    dalvikBytecodeOperationOrIntParser,
+    dalvikBytecodeOperationXorIntParser,
+    dalvikBytecodeOperationShiftLeftIntParser,
+    dalvikBytecodeOperationShiftRightIntParser,
+    dalvikBytecodeOperationUnsignedShiftRightIntParser,
+    dalvikBytecodeOperationAddLongParser,
+    dalvikBytecodeOperationSubtractLongParser,
+    dalvikBytecodeOperationMultiplyLongParser,
+    dalvikBytecodeOperationDivideLongParser,
+    dalvikBytecodeOperationRemainderLongParser,
+    dalvikBytecodeOperationAndLongParser,
+    dalvikBytecodeOperationOrLongParser,
+    dalvikBytecodeOperationXorLongParser,
+    dalvikBytecodeOperationShiftLeftLongParser,
+    dalvikBytecodeOperationShiftRightLongParser,
+    dalvikBytecodeOperationUnsignedShiftRightLongParser,
+    dalvikBytecodeOperationAddFloatParser,
+    dalvikBytecodeOperationSubtractFloatParser,
+    dalvikBytecodeOperationMultiplyFloatParser,
+    dalvikBytecodeOperationDivideFloatParser,
+    dalvikBytecodeOperationAddDoubleParser,
+    dalvikBytecodeOperationSubtractDoubleParser,
+    dalvikBytecodeOperationMultiplyDoubleParser,
+    dalvikBytecodeOperationDivideDoubleParser,
+    dalvikBytecodeOperationRemainderDoubleParser,
+]);
+setParserName(dalvikBytecodeOperationBinaryOperationParser, 'dalvikBytecodeOperationBinaryOperationParser');
+const createDalvikBytecodeOperationUnaryOperation = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    dalvikBytecodeFormat12xParser,
+]), ([_opcode, { registers }]) => ({
+    operation,
+    registers,
+}));
+const dalvikBytecodeOperationNegateIntParser = createDalvikBytecodeOperationUnaryOperation('neg-int', 0x7b);
+const dalvikBytecodeOperationNotIntParser = createDalvikBytecodeOperationUnaryOperation('not-int', 0x7c);
+const dalvikBytecodeOperationNegateLongParser = createDalvikBytecodeOperationUnaryOperation('neg-long', 0x7d);
+const dalvikBytecodeOperationNotLongParser = createDalvikBytecodeOperationUnaryOperation('not-long', 0x7e);
+const dalvikBytecodeOperationNegateFloatParser = createDalvikBytecodeOperationUnaryOperation('neg-float', 0x7f);
+const dalvikBytecodeOperationNegateDoubleParser = createDalvikBytecodeOperationUnaryOperation('neg-double', 0x80);
+const dalvikBytecodeOperationIntToLongParser = createDalvikBytecodeOperationUnaryOperation('int-to-long', 0x81);
+const dalvikBytecodeOperationIntToFloatParser = createDalvikBytecodeOperationUnaryOperation('int-to-float', 0x82);
+const dalvikBytecodeOperationIntToDoubleParser = createDalvikBytecodeOperationUnaryOperation('int-to-double', 0x83);
+const dalvikBytecodeOperationLongToIntParser = createDalvikBytecodeOperationUnaryOperation('long-to-int', 0x84);
+const dalvikBytecodeOperationLongToFloatParser = createDalvikBytecodeOperationUnaryOperation('long-to-float', 0x85);
+const dalvikBytecodeOperationLongToDoubleParser = createDalvikBytecodeOperationUnaryOperation('long-to-double', 0x86);
+const dalvikBytecodeOperationFloatToIntParser = createDalvikBytecodeOperationUnaryOperation('float-to-int', 0x87);
+const dalvikBytecodeOperationFloatToLongParser = createDalvikBytecodeOperationUnaryOperation('float-to-long', 0x88);
+const dalvikBytecodeOperationFloatToDoubleParser = createDalvikBytecodeOperationUnaryOperation('float-to-double', 0x89);
+const dalvikBytecodeOperationDoubleToIntParser = createDalvikBytecodeOperationUnaryOperation('double-to-int', 0x8a);
+const dalvikBytecodeOperationDoubleToLongParser = createDalvikBytecodeOperationUnaryOperation('double-to-long', 0x8b);
+const dalvikBytecodeOperationDoubleToFloatParser = createDalvikBytecodeOperationUnaryOperation('double-to-float', 0x8c);
+const dalvikBytecodeOperationIntToByteParser = createDalvikBytecodeOperationUnaryOperation('int-to-byte', 0x8d);
+const dalvikBytecodeOperationIntToCharParser = createDalvikBytecodeOperationUnaryOperation('int-to-char', 0x8e);
+const dalvikBytecodeOperationIntToShortParser = createDalvikBytecodeOperationUnaryOperation('int-to-short', 0x8f);
+const dalvikBytecodeOperationUnaryOperationParser = createUnionParser([
+    dalvikBytecodeOperationNegateIntParser,
+    dalvikBytecodeOperationNotIntParser,
+    dalvikBytecodeOperationNegateLongParser,
+    dalvikBytecodeOperationNotLongParser,
+    dalvikBytecodeOperationNegateFloatParser,
+    dalvikBytecodeOperationNegateDoubleParser,
+    dalvikBytecodeOperationIntToLongParser,
+    dalvikBytecodeOperationIntToFloatParser,
+    dalvikBytecodeOperationIntToDoubleParser,
+    dalvikBytecodeOperationLongToIntParser,
+    dalvikBytecodeOperationLongToFloatParser,
+    dalvikBytecodeOperationLongToDoubleParser,
+    dalvikBytecodeOperationFloatToIntParser,
+    dalvikBytecodeOperationFloatToLongParser,
+    dalvikBytecodeOperationFloatToDoubleParser,
+    dalvikBytecodeOperationDoubleToIntParser,
+    dalvikBytecodeOperationDoubleToLongParser,
+    dalvikBytecodeOperationDoubleToFloatParser,
+    dalvikBytecodeOperationIntToByteParser,
+    dalvikBytecodeOperationIntToCharParser,
+    dalvikBytecodeOperationIntToShortParser,
+]);
+setParserName(dalvikBytecodeOperationUnaryOperationParser, 'dalvikBytecodeOperationUnaryOperationParser');
+const createDalvikBytecodeOperationIfTest = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat22tParser(),
+]), ([_opcode, { registers, branchOffset }]) => ({
+    operation,
+    registers,
+    branchOffset,
+}));
+const dalvikBytecodeIfEqualParser = createDalvikBytecodeOperationIfTest('if-eq', 0x32);
+const dalvikBytecodeIfNotEqualParser = createDalvikBytecodeOperationIfTest('if-neq', 0x33);
+const dalvikBytecodeIfLessThanParser = createDalvikBytecodeOperationIfTest('if-lt', 0x34);
+const dalvikBytecodeIfGreaterThanOrEqualToParser = createDalvikBytecodeOperationIfTest('if-ge', 0x35);
+const dalvikBytecodeIfGreaterThanParser = createDalvikBytecodeOperationIfTest('if-gt', 0x36);
+const dalvikBytecodeIfLessThanOrEqualToParser = createDalvikBytecodeOperationIfTest('if-le', 0x37);
+const dalvikBytecodeOperationIfTestParser = createUnionParser([
+    dalvikBytecodeIfEqualParser,
+    dalvikBytecodeIfNotEqualParser,
+    dalvikBytecodeIfLessThanParser,
+    dalvikBytecodeIfGreaterThanOrEqualToParser,
+    dalvikBytecodeIfGreaterThanParser,
+    dalvikBytecodeIfLessThanOrEqualToParser,
+]);
+setParserName(dalvikBytecodeOperationIfTestParser, 'dalvikBytecodeOperationIfTestParser');
+const createDalvikBytecodeOperationIfTestZero = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    createDalvikBytecodeFormat21tParser(),
+]), ([_opcode, { registers, branchOffset }]) => ({
+    operation,
+    registers,
+    branchOffset,
+}));
+const dalvikBytecodeIfEqualZeroParser = createDalvikBytecodeOperationIfTestZero('if-eqz', 0x38);
+const dalvikBytecodeIfNotEqualZeroParser = createDalvikBytecodeOperationIfTestZero('if-nez', 0x39);
+const dalvikBytecodeIfLessThanZeroParser = createDalvikBytecodeOperationIfTestZero('if-ltz', 0x3a);
+const dalvikBytecodeIfGreaterThanOrEqualToZeroParser = createDalvikBytecodeOperationIfTestZero('if-gez', 0x3b);
+const dalvikBytecodeIfGreaterThanZeroParser = createDalvikBytecodeOperationIfTestZero('if-gtz', 0x3c);
+const dalvikBytecodeIfLessThanOrEqualToZeroParser = createDalvikBytecodeOperationIfTestZero('if-lez', 0x3d);
+const dalvikBytecodeOperationIfTestZeroParser = createUnionParser([
+    dalvikBytecodeIfEqualZeroParser,
+    dalvikBytecodeIfNotEqualZeroParser,
+    dalvikBytecodeIfLessThanZeroParser,
+    dalvikBytecodeIfGreaterThanOrEqualToZeroParser,
+    dalvikBytecodeIfGreaterThanZeroParser,
+    dalvikBytecodeIfLessThanOrEqualToZeroParser,
+]);
+setParserName(dalvikBytecodeOperationIfTestZeroParser, 'dalvikBytecodeOperationIfTestZeroParser');
+const dalvikBytecodeOperationConstStringParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x1a),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoStringIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'const-string',
+    stringIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationConstStringParser, 'dalvikBytecodeOperationConstStringParser');
+const dalvikBytecodeOperationConstMethodHandleParser = promiseCompose(createTupleParser([
+    createExactElementParser(0xfe),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoMethodIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'const-method-handle',
+    methodIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationConstMethodHandleParser, 'dalvikBytecodeOperationConstMethodHandleParser');
+const dalvikBytecodeOperationNewInstanceParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x22),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoTypeIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'new-instance',
+    typeIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationNewInstanceParser, 'dalvikBytecodeOperationNewInstanceParser');
+const dalvikBytecodeOperationNewArrayParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x23),
+    createDalvikBytecodeFormat22cParser({
+        isoIndex: isoIndexIntoTypeIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'new-array',
+    typeIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationNewArrayParser, 'dalvikBytecodeOperationNewArrayParser');
+const dalvikBytecodeOperationCheckCastParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x1f),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoTypeIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'check-cast',
+    typeIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationCheckCastParser, 'dalvikBytecodeOperationCheckCastParser');
+const dalvikBytecodeOperationConstClassParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x1c),
+    createDalvikBytecodeFormat21cParser({
+        isoIndex: isoIndexIntoTypeIds,
+    }),
+]), ([_opcode, { index, registers }]) => ({
+    operation: 'const-class',
+    typeIndex: index,
+    registers,
+}));
+setParserName(dalvikBytecodeOperationConstClassParser, 'dalvikBytecodeOperationConstClassParser');
+const dalvikBytecodeOperationReturnVoidParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x0e),
+    dalvikBytecodeFormat10xParser,
+]), () => ({
+    operation: 'return-void',
+}));
+setParserName(dalvikBytecodeOperationReturnVoidParser, 'dalvikBytecodeOperationReturnVoidParser');
+const createDalvikBytecodeMoveResult1Parser = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    dalvikBytecodeFormat11xParser,
+]), ([_opcode, { registers }]) => ({
+    operation,
+    registers,
+}));
+const dalvikBytecodeMoveResultParser = createDalvikBytecodeMoveResult1Parser('move-result', 0x0a);
+const dalvikBytecodeMoveResultWideParser = createDalvikBytecodeMoveResult1Parser('move-result-wide', 0x0b);
+const dalvikBytecodeMoveResultObjectParser = createDalvikBytecodeMoveResult1Parser('move-result-object', 0x0c);
+const dalvikBytecodeMoveExceptionParser = createDalvikBytecodeMoveResult1Parser('move-exception', 0x0d);
+const dalvikBytecodeOperationMoveResult1Parser = createUnionParser([
+    dalvikBytecodeMoveResultParser,
+    dalvikBytecodeMoveResultWideParser,
+    dalvikBytecodeMoveResultObjectParser,
+    dalvikBytecodeMoveExceptionParser,
+]);
+setParserName(dalvikBytecodeOperationMoveResult1Parser, 'dalvikBytecodeOperationMoveResult1Parser');
+const dalvikBytecodeOperationMoveParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x01),
+    dalvikBytecodeFormat12xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move',
+    registers,
+}));
+const dalvikBytecodeOperationMoveWideParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x04),
+    dalvikBytecodeFormat12xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move-wide',
+    registers,
+}));
+const dalvikBytecodeOperationMoveObjectParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x07),
+    dalvikBytecodeFormat12xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move-object',
+    registers,
+}));
+const dalvikBytecodeOperationMoveFrom16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x02),
+    dalvikBytecodeFormat22xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move/from16',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationMoveFrom16Parser, 'dalvikBytecodeOperationMoveFrom16Parser');
+const dalvikBytecodeOperationMoveWideFrom16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x05),
+    dalvikBytecodeFormat22xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move-wide/from16',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationMoveWideFrom16Parser, 'dalvikBytecodeOperationMoveWideFrom16Parser');
+const dalvikBytecodeOperationMoveObjectFrom16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x08),
+    dalvikBytecodeFormat22xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move-object/from16',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationMoveObjectFrom16Parser, 'dalvikBytecodeOperationMoveObjectFrom16Parser');
+const dalvikBytecodeOperationMoveWide16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x06),
+    dalvikBytecodeFormat32xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'move-wide/16',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationMoveWide16Parser, 'dalvikBytecodeOperationMoveWide16Parser');
+const createDalvikBytecodeOperationReturn1Parser = createDalvikBytecodeMoveResult1Parser;
+const dalvikBytecodeOperationReturnParser = createDalvikBytecodeOperationReturn1Parser('return', 0x0f);
+const dalvikBytecodeOperationReturnWideParser = createDalvikBytecodeOperationReturn1Parser('return-wide', 0x10);
+const dalvikBytecodeOperationReturnObjectParser = createDalvikBytecodeOperationReturn1Parser('return-object', 0x11);
+const dalvikBytecodeOperationReturn1Parser = createUnionParser([
+    dalvikBytecodeOperationReturnParser,
+    dalvikBytecodeOperationReturnWideParser,
+    dalvikBytecodeOperationReturnObjectParser,
+]);
+setParserName(dalvikBytecodeOperationReturn1Parser, 'dalvikBytecodeOperationReturn1Parser');
+const dalvikBytecodeOperationConst4Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x12),
+    nibblesParser,
+]), ([_opcode, [register0, value,],]) => ({
+    operation: 'const/4',
+    registers: [
+        register0,
+    ],
+    value: value << 28 >> 28,
+}));
+setParserName(dalvikBytecodeOperationConst4Parser, 'dalvikBytecodeOperationConst4Parser');
+const dalvikBytecodeOperationConst16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x13),
+    createDalvikBytecodeFormat21sParser(),
+]), ([_opcode, { registers, value }]) => ({
+    operation: 'const/16',
+    registers,
+    value: value << 16 >> 16,
+}));
+setParserName(dalvikBytecodeOperationConst16Parser, 'dalvikBytecodeOperationConst16Parser');
+const dalvikBytecodeOperationConstHigh16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x15),
+    createDalvikBytecodeFormat21sParser(),
+]), ([_opcode, { registers, value }]) => ({
+    operation: 'const/high16',
+    registers,
+    value: value << 16,
+}));
+setParserName(dalvikBytecodeOperationConstHigh16Parser, 'dalvikBytecodeOperationConstHigh16Parser');
+const dalvikBytecodeOperationConstWide16Parser = promiseCompose(createTupleParser([
+    createExactElementParser(0x16),
+    createDalvikBytecodeFormat21sParser(),
+]), ([_opcode, { registers, value }]) => ({
+    operation: 'const-wide/16',
+    registers,
+    value: BigInt(value) << 48n >> 48n,
+}));
+setParserName(dalvikBytecodeOperationConstWide16Parser, 'dalvikBytecodeOperationConstWide16Parser');
+const dalvikBytecodeOperationConstParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x14),
+    dalvikBytecodeFormat31iParser,
+]), ([_opcode, { registers, value }]) => ({
+    operation: 'const',
+    registers,
+    value,
+}));
+setParserName(dalvikBytecodeOperationConstParser, 'dalvikBytecodeOperationConstParser');
+const dalvikBytecodeOperationThrowParser = promiseCompose(createTupleParser([
+    createExactElementParser(0x27),
+    dalvikBytecodeFormat11xParser,
+]), ([_opcode, { registers }]) => ({
+    operation: 'throw',
+    registers,
+}));
+setParserName(dalvikBytecodeOperationThrowParser, 'dalvikBytecodeOperationThrowParser');
+const createDalvikBytecodeOperationCompare = (operation, opcode) => promiseCompose(createTupleParser([
+    createExactElementParser(opcode),
+    dalvikBytecodeFormat23xParser,
+]), ([_opcode, { registers }]) => ({
+    operation,
+    registers,
+}));
+const dalvikBytecodeOperationCompareFloatWithLessThanBiasParser = createDalvikBytecodeOperationCompare('cmpl-float', 0x2d);
+const dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser = createDalvikBytecodeOperationCompare('cmpg-float', 0x2e);
+const dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser = createDalvikBytecodeOperationCompare('cmpl-double', 0x2f);
+const dalvikBytecodeOperationCompareDoubleWithGreaterThanBiasParser = createDalvikBytecodeOperationCompare('cmpg-double', 0x30);
+const dalvikBytecodeOperationCompareLongParser = createDalvikBytecodeOperationCompare('cmp-long', 0x31);
+const dalvikBytecodeOperationCompareParser = createUnionParser([
+    dalvikBytecodeOperationCompareFloatWithLessThanBiasParser,
+    dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser,
+    dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser,
+    dalvikBytecodeOperationCompareDoubleWithGreaterThanBiasParser,
+    dalvikBytecodeOperationCompareLongParser,
+]);
+setParserName(dalvikBytecodeOperationCompareParser, 'dalvikBytecodeOperationCompareParser');
+export const dalvikBytecodeOperationCompanion = {
+    getRegisters(operation) {
+        if (operation && typeof operation === 'object' && 'registers' in operation) {
+            return operation.registers;
+        }
+        return [];
+    },
+};
+const dalvikBytecodeOperationParser = promiseCompose(createTupleParser([
+    () => { },
+    //createDebugLogInputParser(),
+    createUnionParser([
+        dalvikBytecodeOperationUnusedParser,
+        dalvikBytecodeOperationNoOperationParser,
+        dalvikBytecodeOperationInvokeParser,
+        dalvikBytecodeOperationInvokeRangeParser,
+        dalvikBytecodeOperationNewInstanceParser,
+        dalvikBytecodeOperationNewArrayParser,
+        dalvikBytecodeOperationCheckCastParser,
+        dalvikBytecodeOperationInstanceOfParser,
+        dalvikBytecodeOperationArrayElementParser,
+        dalvikBytecodeOperationInstanceFieldParser,
+        dalvikBytecodeOperationStaticFieldParser,
+        dalvikBytecodeOperationConstStringParser,
+        dalvikBytecodeOperationConstMethodHandleParser,
+        dalvikBytecodeOperationConstClassParser,
+        dalvikBytecodeOperationReturnVoidParser,
+        dalvikBytecodeOperationReturn1Parser,
+        dalvikBytecodeOperationThrowParser,
+        dalvikBytecodeOperationGotoParser,
+        dalvikBytecodeOperationGoto16Parser,
+        dalvikBytecodeOperationMoveResult1Parser,
+        dalvikBytecodeOperationMoveParser,
+        dalvikBytecodeOperationMoveWideParser,
+        dalvikBytecodeOperationMoveObjectParser,
+        dalvikBytecodeOperationMoveFrom16Parser,
+        dalvikBytecodeOperationMoveWideFrom16Parser,
+        dalvikBytecodeOperationMoveObjectFrom16Parser,
+        dalvikBytecodeOperationMoveWide16Parser,
+        dalvikBytecodeOperationConst4Parser,
+        dalvikBytecodeOperationConst16Parser,
+        dalvikBytecodeOperationConstHigh16Parser,
+        dalvikBytecodeOperationConstWide16Parser,
+        dalvikBytecodeOperationConstParser,
+        dalvikBytecodeOperationCompareParser,
+        dalvikBytecodeOperationIfTestParser,
+        dalvikBytecodeOperationIfTestZeroParser,
+        dalvikBytecodeOperationBinaryOperationParser,
+        dalvikBytecodeOperationBinaryOperationLiteral8Parser,
+        dalvikBytecodeOperationBinaryOperationLiteral16Parser,
+        dalvikBytecodeOperationBinaryOperationInPlaceParser,
+        dalvikBytecodeOperationUnaryOperationParser,
+    ]),
+]), ([_debug, operation,]) => {
+    // console.log(operation);
+    return operation;
+});
+setParserName(dalvikBytecodeOperationParser, 'dalvikBytecodeOperationParser');
+const dalvikBytecodeParser = promiseCompose(createArrayParser(dalvikBytecodeOperationParser), operations => operations.filter((operation) => operation !== undefined));
+export const createDalvikBytecodeParser = (size) => createSliceBoundedParser(dalvikBytecodeParser, size, true);
+export function resolveDalvikBytecodeOperation(operation, { resolveIndexIntoStringIds, resolveIndexIntoTypeIds, resolveIndexIntoMethodIds, resolveIndexIntoFieldIds, }) {
+    if (operation && typeof operation === 'object' && 'stringIndex' in operation) {
+        const { stringIndex, ...rest } = operation;
+        return {
+            ...rest,
+            string: resolveIndexIntoStringIds(stringIndex),
+        };
+    }
+    if (operation && typeof operation === 'object' && 'typeIndex' in operation) {
+        const { typeIndex, ...rest } = operation;
+        return {
+            ...rest,
+            type: resolveIndexIntoTypeIds(typeIndex),
+        };
+    }
+    if (operation && typeof operation === 'object' && 'methodIndex' in operation) {
+        const { methodIndex, ...rest } = operation;
+        return {
+            ...rest,
+            method: resolveIndexIntoMethodIds(methodIndex),
+        };
+    }
+    if (operation && typeof operation === 'object' && 'fieldIndex' in operation) {
+        const { fieldIndex, ...rest } = operation;
+        return {
+            ...rest,
+            field: resolveIndexIntoFieldIds(fieldIndex),
+        };
+    }
+    return operation;
+}