@futpib/parser 1.0.2 → 1.0.3

package/src/dalvikBytecodeParser.ts

@@ -1,25 +1,61 @@
-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 { DalvikExecutableField, DalvikExecutableMethod } from "./dalvikExecutable.js";
-import { IndexIntoFieldIds, IndexIntoMethodIds, IndexIntoStringIds, IndexIntoTypeIds, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoStringIds, isoIndexIntoTypeIds } from "./dalvikExecutableParser/typedNumbers.js";
-import { createExactElementParser } from "./exactElementParser.js";
-import { Parser, setParserName } from "./parser.js";
-import { promiseCompose } from "./promiseCompose.js";
-import { createSliceBoundedParser } from "./sliceBoundedParser.js";
-import { createTupleParser } from "./tupleParser.js";
-import { createUnionParser } from "./unionParser.js";
+import { createArrayParser } from './arrayParser.js';
+import {
+	createDalvikBytecodeFormat21cParser,
+	createDalvikBytecodeFormat21sParser,
+	createDalvikBytecodeFormat21tParser,
+	createDalvikBytecodeFormat22bParser,
+	createDalvikBytecodeFormat22cParser,
+	createDalvikBytecodeFormat22sParser,
+	createDalvikBytecodeFormat22tParser,
+	dalvikBytecodeFormat23xParser,
+	createDalvikBytecodeFormat31cParser,
+	dalvikBytecodeFormat31iParser,
+	dalvikBytecodeFormat31tParser,
+	createDalvikBytecodeFormat35cParser,
+	createDalvikBytecodeFormat3rcParser,
+	dalvikBytecodeFormat10tParser,
+	dalvikBytecodeFormat10xParser,
+	dalvikBytecodeFormat11xParser,
+	dalvikBytecodeFormat11nParser,
+	dalvikBytecodeFormat12xParser,
+	dalvikBytecodeFormat20tParser,
+	dalvikBytecodeFormat22xParser,
+	dalvikBytecodeFormat32xParser,
+	dalvikBytecodeFormat30tParser,
+	dalvikBytecodeFormat51lParser,
+	createDalvikBytecodeFormat45ccParser,
+	createDalvikBytecodeFormat4rccParser,
+} from './dalvikBytecodeParser/formatParsers.js';
+import {
+	ubyteParser, ushortParser, intParser, uintParser, createExactUshortParser,
+} from './dalvikExecutableParser/typeParsers.js';
+import { type DalvikExecutableField, type DalvikExecutableMethod } from './dalvikExecutable.js';
+import {
+	type IndexIntoFieldIds, type IndexIntoMethodIds, type IndexIntoPrototypeIds, type IndexIntoStringIds, type IndexIntoTypeIds, isoIndexIntoFieldIds, isoIndexIntoMethodIds, isoIndexIntoPrototypeIds, isoIndexIntoStringIds, isoIndexIntoTypeIds,
+} from './dalvikExecutableParser/typedNumbers.js';
+import { createExactElementParser } from './exactElementParser.js';
+import { createElementSwitchParser } from './exactElementSwitchParser.js';
+import { type Parser, setParserName } from './parser.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createSliceBoundedParser } from './sliceBoundedParser.js';
+import { createDisjunctionParser } from './disjunctionParser.js';
+import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createQuantifierParser } from './quantifierParser.js';
+import { createDebugLogInputParser } from './debugLogInputParser.js';
+import { createNegativeLookaheadParser } from './negativeLookaheadParser.js';
+import { createTupleParser } from './tupleParser.js';
 
 // https://source.android.com/docs/core/runtime/dalvik-bytecode
 
-const dalvikBytecodeOperationUnusedParser: Parser<void, Uint8Array> = async (parserContext) => {
+const dalvikBytecodeOperationUnusedParser: Parser<void, Uint8Array> = async parserContext => {
 	const opcode = await parserContext.read(0);
 
 	parserContext.invariant(
 		(
-			(opcode >= 0x3e && opcode <= 0x43)
-				|| (opcode === 0x73)
-				|| (opcode >= 0x79 && opcode <= 0x7a)
-				|| (opcode >= 0xe3 && opcode <= 0xf9)
+			(opcode >= 0x3E && opcode <= 0x43)
+			|| (opcode === 0x73)
+			|| (opcode >= 0x79 && opcode <= 0x7A)
+			|| (opcode >= 0xE3 && opcode <= 0xF9)
 		),
 		'Expected unused opcode',
 	);
@@ -30,13 +66,13 @@ const dalvikBytecodeOperationUnusedParser: Parser<void, Uint8Array> = async (par
 setParserName(dalvikBytecodeOperationUnusedParser, 'dalvikBytecodeOperationUnusedParser');
 
 type DalvikBytecodeOperationNoOperation = {
-	operation: 'no-operation';
+	operation: 'nop';
 };
 
 const dalvikBytecodeOperationNoOperationParser: Parser<DalvikBytecodeOperationNoOperation, Uint8Array> = promiseCompose(
-	createExactElementParser(0x00),
+	createExactUshortParser(0x00_00), // nop is 2 bytes: 0x00 0x00
 	() => ({
-		operation: 'no-operation',
+		operation: 'nop',
 	}),
 );
 
@@ -55,7 +91,7 @@ const createDalvikBytecodeOperationInvoke = <T extends string>(operation: T, opc
 	]),
 	([
 		_opcode,
-		{ index, registers }
+		{ index, registers },
 	]) => ({
 		operation,
 		methodIndex: index,
@@ -63,11 +99,11 @@ const createDalvikBytecodeOperationInvoke = <T extends string>(operation: T, opc
 	}),
 );
 
-const dalvikBytecodeOperationInvokeVirtualParser = createDalvikBytecodeOperationInvoke('invoke-virtual', 0x6e);
+const dalvikBytecodeOperationInvokeVirtualParser = createDalvikBytecodeOperationInvoke('invoke-virtual', 0x6E);
 
 type DalvikBytecodeOperationInvokeVirtual = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeVirtualParser>>;
 
-const dalvikBytecodeOperationInvokeSuperParser = createDalvikBytecodeOperationInvoke('invoke-super', 0x6f);
+const dalvikBytecodeOperationInvokeSuperParser = createDalvikBytecodeOperationInvoke('invoke-super', 0x6F);
 
 type DalvikBytecodeOperationInvokeSuper = Awaited<ReturnType<typeof dalvikBytecodeOperationInvokeSuperParser>>;
 
@@ -91,7 +127,7 @@ type DalvikBytecodeOperationInvoke =
 	| DalvikBytecodeOperationInvokeInterface
 ;
 
-const dalvikBytecodeOperationInvokeParser: Parser<DalvikBytecodeOperationInvoke, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationInvokeParser: Parser<DalvikBytecodeOperationInvoke, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationInvokeVirtualParser,
 	dalvikBytecodeOperationInvokeSuperParser,
 	dalvikBytecodeOperationInvokeDirectParser,
@@ -114,7 +150,7 @@ const createDalvikBytecodeOperationInvokeRange = <T extends string>(operation: T
 	]),
 	([
 		_opcode,
-		{ index, registers }
+		{ index, registers },
 	]) => ({
 		operation,
 		methodIndex: index,
@@ -150,7 +186,7 @@ type DalvikBytecodeOperationInvokeRange =
 	| DalvikBytecodeOperationInvokeInterfaceRange
 ;
 
-const dalvikBytecodeOperationInvokeRangeParser: Parser<DalvikBytecodeOperationInvokeRange, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationInvokeRangeParser: Parser<DalvikBytecodeOperationInvokeRange, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationInvokeVirtualRangeParser,
 	dalvikBytecodeOperationInvokeSuperRangeParser,
 	dalvikBytecodeOperationInvokeDirectRangeParser,
@@ -160,6 +196,63 @@ const dalvikBytecodeOperationInvokeRangeParser: Parser<DalvikBytecodeOperationIn
 
 setParserName(dalvikBytecodeOperationInvokeRangeParser, 'dalvikBytecodeOperationInvokeRangeParser');
 
+// Invoke-polymorphic and invoke-polymorphic/range (Android 8.0+)
+type DalvikBytecodeOperationInvokePolymorphic = {
+	operation: 'invoke-polymorphic';
+	methodIndex: IndexIntoMethodIds;
+	protoIndex: IndexIntoPrototypeIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationInvokePolymorphicParser: Parser<DalvikBytecodeOperationInvokePolymorphic, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0xFA),
+		createDalvikBytecodeFormat45ccParser({
+			isoMethodIndex: isoIndexIntoMethodIds,
+			isoProtoIndex: isoIndexIntoPrototypeIds,
+		}),
+	]),
+	([
+		_opcode,
+		{ methodIndex, protoIndex, registers },
+	]) => ({
+		operation: 'invoke-polymorphic',
+		methodIndex,
+		protoIndex,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationInvokePolymorphicParser, 'dalvikBytecodeOperationInvokePolymorphicParser');
+
+type DalvikBytecodeOperationInvokePolymorphicRange = {
+	operation: 'invoke-polymorphic/range';
+	methodIndex: IndexIntoMethodIds;
+	protoIndex: IndexIntoPrototypeIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationInvokePolymorphicRangeParser: Parser<DalvikBytecodeOperationInvokePolymorphicRange, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0xFB),
+		createDalvikBytecodeFormat4rccParser({
+			isoMethodIndex: isoIndexIntoMethodIds,
+			isoProtoIndex: isoIndexIntoPrototypeIds,
+		}),
+	]),
+	([
+		_opcode,
+		{ methodIndex, protoIndex, registers },
+	]) => ({
+		operation: 'invoke-polymorphic/range',
+		methodIndex,
+		protoIndex,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationInvokePolymorphicRangeParser, 'dalvikBytecodeOperationInvokePolymorphicRangeParser');
+
 type DalvikBytecodeOperationGoto = {
 	operation: 'goto';
 	branchOffset: number;
@@ -192,6 +285,172 @@ const dalvikBytecodeOperationGoto16Parser: Parser<DalvikBytecodeOperationGoto16,
 	}),
 );
 
+type DalvikBytecodeOperationGoto32 = {
+	operation: 'goto/32';
+	branchOffset: number;
+};
+
+const dalvikBytecodeOperationGoto32Parser: Parser<DalvikBytecodeOperationGoto32, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x2A),
+		dalvikBytecodeFormat30tParser,
+	]),
+	([ _opcode, { branchOffset } ]) => ({
+		operation: 'goto/32',
+		branchOffset,
+	}),
+);
+
+type DalvikBytecodeOperationPackedSwitch = {
+	operation: 'packed-switch';
+	branchOffset: number;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationPackedSwitchParser: Parser<DalvikBytecodeOperationPackedSwitch, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x2B),
+		dalvikBytecodeFormat31tParser,
+	]),
+	([ _opcode, { branchOffset, registers } ]) => ({
+		operation: 'packed-switch',
+		branchOffset,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationPackedSwitchParser, 'dalvikBytecodeOperationPackedSwitchParser');
+
+type DalvikBytecodeOperationPackedSwitchPayload = {
+	operation: 'packed-switch-payload';
+	value: number;
+	branchOffsets: number[];
+};
+
+const dalvikBytecodeOperationPackedSwitchPayloadParser: Parser<DalvikBytecodeOperationPackedSwitchPayload, Uint8Array> = parserCreatorCompose(
+	() => promiseCompose(
+		createTupleParser([
+			createExactUshortParser(0x01_00),
+			ushortParser,
+			intParser,
+		]),
+		([ _ident, size, value ]) => ({
+			size,
+			value,
+		}),
+	),
+	({ size, value }) => promiseCompose(
+		createQuantifierParser(
+			intParser,
+			size,
+		),
+		branchOffsets => ({
+			operation: 'packed-switch-payload' as const,
+			value,
+			branchOffsets,
+		}),
+	),
+)();
+
+setParserName(dalvikBytecodeOperationPackedSwitchPayloadParser, 'dalvikBytecodeOperationPackedSwitchPayloadParser');
+
+type DalvikBytecodeOperationSparseSwitch = {
+	operation: 'sparse-switch';
+	branchOffset: number;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationSparseSwitchParser: Parser<DalvikBytecodeOperationSparseSwitch, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x2C),
+		dalvikBytecodeFormat31tParser,
+	]),
+	([ _opcode, { branchOffset, registers } ]) => ({
+		operation: 'sparse-switch',
+		branchOffset,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationSparseSwitchParser, 'dalvikBytecodeOperationSparseSwitchParser');
+
+type DalvikBytecodeOperationSparseSwitchPayload = {
+	operation: 'sparse-switch-payload';
+	keys: number[];
+	branchOffsets: number[];
+};
+
+const dalvikBytecodeOperationSparseSwitchPayloadParser: Parser<DalvikBytecodeOperationSparseSwitchPayload, Uint8Array> = parserCreatorCompose(
+	() => promiseCompose(
+		createTupleParser([
+			createExactUshortParser(0x02_00),
+			ushortParser,
+		]),
+		([ _ident, size ]) => ({
+			size,
+		}),
+	),
+	({ size }) => promiseCompose(
+		createTupleParser([
+			createQuantifierParser(
+				intParser,
+				size,
+			),
+			createQuantifierParser(
+				intParser,
+				size,
+			),
+		]),
+		([ keys, branchOffsets ]) => ({
+			operation: 'sparse-switch-payload' as const,
+			keys,
+			branchOffsets,
+		}),
+	),
+)();
+
+setParserName(dalvikBytecodeOperationSparseSwitchPayloadParser, 'dalvikBytecodeOperationSparseSwitchPayloadParser');
+
+type DalvikBytecodeOperationFillArrayDataPayload = {
+	operation: 'fill-array-data-payload';
+	elementWidth: number;
+	data: number[];
+};
+
+const dalvikBytecodeOperationFillArrayDataPayloadParser: Parser<DalvikBytecodeOperationFillArrayDataPayload, Uint8Array> = parserCreatorCompose(
+	() => promiseCompose(
+		createTupleParser([
+			createExactUshortParser(0x03_00),
+			ushortParser,
+			uintParser,
+		]),
+		([ _ident, elementWidth, size ]): { elementWidth: number; size: number } => ({
+			elementWidth,
+			size,
+		}),
+	),
+	({ elementWidth, size }: { elementWidth: number; size: number }) => {
+		const dataSize = size * elementWidth;
+		const paddingSize = dataSize % 2; // 1 if odd, 0 if even
+		return promiseCompose(
+			createTupleParser([
+				createQuantifierParser(
+					ubyteParser,
+					dataSize,
+				),
+				paddingSize > 0 ? createQuantifierParser(ubyteParser, paddingSize) : () => [],
+			]),
+			([ data, _padding ]) => ({
+				operation: 'fill-array-data-payload' as const,
+				elementWidth,
+				data,
+			}),
+		);
+	},
+)();
+
+setParserName(dalvikBytecodeOperationFillArrayDataPayloadParser, 'dalvikBytecodeOperationFillArrayDataPayloadParser');
+
 type DalvikBytecodeOperationInstanceOf = {
 	operation: 'instance-of';
 	registers: number[];
@@ -252,27 +511,27 @@ const dalvikBytecodeOperationArrayElementGetCharParser = createDalvikBytecodeOpe
 
 type DalvikBytecodeOperationArrayElementGetChar = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetCharParser>>;
 
-const dalvikBytecodeOperationArrayElementGetShortParser = createDalvikBytecodeOperationArrayElement('aget-short', 0x4a);
+const dalvikBytecodeOperationArrayElementGetShortParser = createDalvikBytecodeOperationArrayElement('aget-short', 0x4A);
 
 type DalvikBytecodeOperationArrayElementGetShort = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementGetShortParser>>;
 
-const dalvikBytecodeOperationArrayElementPutParser = createDalvikBytecodeOperationArrayElement('aput', 0x4b);
+const dalvikBytecodeOperationArrayElementPutParser = createDalvikBytecodeOperationArrayElement('aput', 0x4B);
 
 type DalvikBytecodeOperationArrayElementPut = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutParser>>;
 
-const dalvikBytecodeOperationArrayElementPutWideParser = createDalvikBytecodeOperationArrayElement('aput-wide', 0x4c);
+const dalvikBytecodeOperationArrayElementPutWideParser = createDalvikBytecodeOperationArrayElement('aput-wide', 0x4C);
 
 type DalvikBytecodeOperationArrayElementPutWide = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutWideParser>>;
 
-const dalvikBytecodeOperationArrayElementPutObjectParser = createDalvikBytecodeOperationArrayElement('aput-object', 0x4d);
+const dalvikBytecodeOperationArrayElementPutObjectParser = createDalvikBytecodeOperationArrayElement('aput-object', 0x4D);
 
 type DalvikBytecodeOperationArrayElementPutObject = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutObjectParser>>;
 
-const dalvikBytecodeOperationArrayElementPutBooleanParser = createDalvikBytecodeOperationArrayElement('aput-boolean', 0x4e);
+const dalvikBytecodeOperationArrayElementPutBooleanParser = createDalvikBytecodeOperationArrayElement('aput-boolean', 0x4E);
 
 type DalvikBytecodeOperationArrayElementPutBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutBooleanParser>>;
 
-const dalvikBytecodeOperationArrayElementPutByteParser = createDalvikBytecodeOperationArrayElement('aput-byte', 0x4f);
+const dalvikBytecodeOperationArrayElementPutByteParser = createDalvikBytecodeOperationArrayElement('aput-byte', 0x4F);
 
 type DalvikBytecodeOperationArrayElementPutByte = Awaited<ReturnType<typeof dalvikBytecodeOperationArrayElementPutByteParser>>;
 
@@ -301,7 +560,7 @@ type DalvikBytecodeOperationArrayElement =
 	| DalvikBytecodeOperationArrayElementPutShort
 ;
 
-const dalvikBytecodeOperationArrayElementParser: Parser<DalvikBytecodeOperationArrayElement, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationArrayElementParser: Parser<DalvikBytecodeOperationArrayElement, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationArrayElementGetParser,
 	dalvikBytecodeOperationArrayElementGetWideParser,
 	dalvikBytecodeOperationArrayElementGetObjectParser,
@@ -370,27 +629,27 @@ const dalvikBytecodeOperationInstanceFieldPutParser = createDalvikBytecodeOperat
 
 type DalvikBytecodeOperationInstanceFieldPut = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutParser>>;
 
-const dalvikBytecodeOperationInstanceFieldPutWideParser = createDalvikBytecodeOperationInstanceField('iput-wide', 0x5a);
+const dalvikBytecodeOperationInstanceFieldPutWideParser = createDalvikBytecodeOperationInstanceField('iput-wide', 0x5A);
 
 type DalvikBytecodeOperationInstanceFieldPutWide = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutWideParser>>;
 
-const dalvikBytecodeOperationInstanceFieldPutObjectParser = createDalvikBytecodeOperationInstanceField('iput-object', 0x5b);
+const dalvikBytecodeOperationInstanceFieldPutObjectParser = createDalvikBytecodeOperationInstanceField('iput-object', 0x5B);
 
 type DalvikBytecodeOperationInstanceFieldPutObject = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutObjectParser>>;
 
-const dalvikBytecodeOperationInstanceFieldPutBooleanParser = createDalvikBytecodeOperationInstanceField('iput-boolean', 0x5c);
+const dalvikBytecodeOperationInstanceFieldPutBooleanParser = createDalvikBytecodeOperationInstanceField('iput-boolean', 0x5C);
 
 type DalvikBytecodeOperationInstanceFieldPutBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutBooleanParser>>;
 
-const dalvikBytecodeOperationInstanceFieldPutByteParser = createDalvikBytecodeOperationInstanceField('iput-byte', 0x5d);
+const dalvikBytecodeOperationInstanceFieldPutByteParser = createDalvikBytecodeOperationInstanceField('iput-byte', 0x5D);
 
 type DalvikBytecodeOperationInstanceFieldPutByte = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutByteParser>>;
 
-const dalvikBytecodeOperationInstanceFieldPutCharParser = createDalvikBytecodeOperationInstanceField('iput-char', 0x5e);
+const dalvikBytecodeOperationInstanceFieldPutCharParser = createDalvikBytecodeOperationInstanceField('iput-char', 0x5E);
 
 type DalvikBytecodeOperationInstanceFieldPutChar = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutCharParser>>;
 
-const dalvikBytecodeOperationInstanceFieldPutShortParser = createDalvikBytecodeOperationInstanceField('iput-short', 0x5f);
+const dalvikBytecodeOperationInstanceFieldPutShortParser = createDalvikBytecodeOperationInstanceField('iput-short', 0x5F);
 
 type DalvikBytecodeOperationInstanceFieldPutShort = Awaited<ReturnType<typeof dalvikBytecodeOperationInstanceFieldPutShortParser>>;
 
@@ -411,7 +670,7 @@ type DalvikBytecodeOperationInstanceField =
 	| DalvikBytecodeOperationInstanceFieldPutShort
 ;
 
-const dalvikBytecodeOperationInstanceFieldParser: Parser<DalvikBytecodeOperationInstanceField, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationInstanceFieldParser: Parser<DalvikBytecodeOperationInstanceField, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationInstanceFieldGetParser,
 	dalvikBytecodeOperationInstanceFieldGetWideParser,
 	dalvikBytecodeOperationInstanceFieldGetObjectParser,
@@ -488,19 +747,19 @@ const dalvikBytecodeOperationStaticFieldPutObjectParser = createDalvikBytecodeOp
 
 type DalvikBytecodeOperationStaticFieldPutObject = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutObjectParser>>;
 
-const dalvikBytecodeOperationStaticFieldPutBooleanParser = createDalvikBytecodeOperationStaticField('sput-boolean', 0x6a);
+const dalvikBytecodeOperationStaticFieldPutBooleanParser = createDalvikBytecodeOperationStaticField('sput-boolean', 0x6A);
 
 type DalvikBytecodeOperationStaticFieldPutBoolean = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutBooleanParser>>;
 
-const dalvikBytecodeOperationStaticFieldPutByteParser = createDalvikBytecodeOperationStaticField('sput-byte', 0x6b);
+const dalvikBytecodeOperationStaticFieldPutByteParser = createDalvikBytecodeOperationStaticField('sput-byte', 0x6B);
 
 type DalvikBytecodeOperationStaticFieldPutByte = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutByteParser>>;
 
-const dalvikBytecodeOperationStaticFieldPutCharParser = createDalvikBytecodeOperationStaticField('sput-char', 0x6c);
+const dalvikBytecodeOperationStaticFieldPutCharParser = createDalvikBytecodeOperationStaticField('sput-char', 0x6C);
 
 type DalvikBytecodeOperationStaticFieldPutChar = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutCharParser>>;
 
-const dalvikBytecodeOperationStaticFieldPutShortParser = createDalvikBytecodeOperationStaticField('sput-short', 0x6d);
+const dalvikBytecodeOperationStaticFieldPutShortParser = createDalvikBytecodeOperationStaticField('sput-short', 0x6D);
 
 type DalvikBytecodeOperationStaticFieldPutShort = Awaited<ReturnType<typeof dalvikBytecodeOperationStaticFieldPutShortParser>>;
 
@@ -521,7 +780,7 @@ type DalvikBytecodeOperationStaticField =
 	| DalvikBytecodeOperationStaticFieldPutShort
 ;
 
-const dalvikBytecodeOperationStaticFieldParser: Parser<DalvikBytecodeOperationStaticField, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationStaticFieldParser: Parser<DalvikBytecodeOperationStaticField, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationStaticFieldGetParser,
 	dalvikBytecodeOperationStaticFieldGetWideParser,
 	dalvikBytecodeOperationStaticFieldGetObjectParser,
@@ -556,47 +815,47 @@ const createDalvikBytecodeOperationBinaryOperationLiteral8 = <T extends string>(
 	}),
 );
 
-const dalvikBytecodeOperationAddIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('add-int/lit8', 0xd8);
+const dalvikBytecodeOperationAddIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('add-int/lit8', 0xD8);
 
 type DalvikBytecodeOperationAddIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationReverseSubtractIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('rsub-int/lit8', 0xd9);
+const dalvikBytecodeOperationReverseSubtractIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('rsub-int/lit8', 0xD9);
 
 type DalvikBytecodeOperationReverseSubtractIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationMultiplyIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('mul-int/lit8', 0xda);
+const dalvikBytecodeOperationMultiplyIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('mul-int/lit8', 0xDA);
 
 type DalvikBytecodeOperationMultiplyIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationDivideIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('div-int/lit8', 0xdb);
+const dalvikBytecodeOperationDivideIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('div-int/lit8', 0xDB);
 
 type DalvikBytecodeOperationDivideIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationRemainderIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('rem-int/lit8', 0xdc);
+const dalvikBytecodeOperationRemainderIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('rem-int/lit8', 0xDC);
 
 type DalvikBytecodeOperationRemainderIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationAndIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('and-int/lit8', 0xdd);
+const dalvikBytecodeOperationAndIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('and-int/lit8', 0xDD);
 
 type DalvikBytecodeOperationAndIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationOrIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('or-int/lit8', 0xde);
+const dalvikBytecodeOperationOrIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('or-int/lit8', 0xDE);
 
 type DalvikBytecodeOperationOrIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationXorIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('xor-int/lit8', 0xdf);
+const dalvikBytecodeOperationXorIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('xor-int/lit8', 0xDF);
 
 type DalvikBytecodeOperationXorIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationShiftLeftIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('shl-int/lit8', 0xe0);
+const dalvikBytecodeOperationShiftLeftIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('shl-int/lit8', 0xE0);
 
 type DalvikBytecodeOperationShiftLeftIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationShiftRightIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('shr-int/lit8', 0xe1);
+const dalvikBytecodeOperationShiftRightIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('shr-int/lit8', 0xE1);
 
 type DalvikBytecodeOperationShiftRightIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightIntLiteral8Parser>>;
 
-const dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('ushr-int/lit8', 0xe2);
+const dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser = createDalvikBytecodeOperationBinaryOperationLiteral8('ushr-int/lit8', 0xE2);
 
 type DalvikBytecodeOperationUnsignedShiftRightIntLiteral8 = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser>>;
 
@@ -614,7 +873,7 @@ type DalvikBytecodeOperationBinaryOperationLiteral8 =
 	| DalvikBytecodeOperationUnsignedShiftRightIntLiteral8
 ;
 
-const dalvikBytecodeOperationBinaryOperationLiteral8Parser: Parser<DalvikBytecodeOperationBinaryOperationLiteral8, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationBinaryOperationLiteral8Parser: Parser<DalvikBytecodeOperationBinaryOperationLiteral8, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationAddIntLiteral8Parser,
 	dalvikBytecodeOperationReverseSubtractIntLiteral8Parser,
 	dalvikBytecodeOperationMultiplyIntLiteral8Parser,
@@ -646,35 +905,35 @@ const createDalvikBytecodeOperationBinaryOperationLiteral16 = <T extends string>
 	}),
 );
 
-const dalvikBytecodeOperationAddIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('add-int/lit16', 0xd0);
+const dalvikBytecodeOperationAddIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('add-int/lit16', 0xD0);
 
 type DalvikBytecodeOperationAddIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationReverseSubtractIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('rsub-int/lit16', 0xd1);
+const dalvikBytecodeOperationReverseSubtractIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('rsub-int', 0xD1);
 
 type DalvikBytecodeOperationReverseSubtractIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationMultiplyIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('mul-int/lit16', 0xd2);
+const dalvikBytecodeOperationMultiplyIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('mul-int/lit16', 0xD2);
 
 type DalvikBytecodeOperationMultiplyIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationDivideIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('div-int/lit16', 0xd3);
+const dalvikBytecodeOperationDivideIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('div-int/lit16', 0xD3);
 
 type DalvikBytecodeOperationDivideIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationRemainderIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('rem-int/lit16', 0xd4);
+const dalvikBytecodeOperationRemainderIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('rem-int/lit16', 0xD4);
 
 type DalvikBytecodeOperationRemainderIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationAndIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('and-int/lit16', 0xd5);
+const dalvikBytecodeOperationAndIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('and-int/lit16', 0xD5);
 
 type DalvikBytecodeOperationAndIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationOrIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('or-int/lit16', 0xd6);
+const dalvikBytecodeOperationOrIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('or-int/lit16', 0xD6);
 
 type DalvikBytecodeOperationOrIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntLiteral16Parser>>;
 
-const dalvikBytecodeOperationXorIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('xor-int/lit16', 0xd7);
+const dalvikBytecodeOperationXorIntLiteral16Parser = createDalvikBytecodeOperationBinaryOperationLiteral16('xor-int/lit16', 0xD7);
 
 type DalvikBytecodeOperationXorIntLiteral16 = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntLiteral16Parser>>;
 
@@ -689,7 +948,7 @@ type DalvikBytecodeOperationBinaryOperationLiteral16 =
 	| DalvikBytecodeOperationXorIntLiteral16
 ;
 
-const dalvikBytecodeOperationBinaryOperationLiteral16Parser: Parser<DalvikBytecodeOperationBinaryOperationLiteral16, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationBinaryOperationLiteral16Parser: Parser<DalvikBytecodeOperationBinaryOperationLiteral16, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationAddIntLiteral16Parser,
 	dalvikBytecodeOperationReverseSubtractIntLiteral16Parser,
 	dalvikBytecodeOperationMultiplyIntLiteral16Parser,
@@ -716,127 +975,131 @@ const createDalvikBytecodeOperationBinaryOperationInPlace = <T extends string>(o
 	}),
 );
 
-const dalvikBytecodeOperationAddIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-int/2addr', 0xb0);
+const dalvikBytecodeOperationAddIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-int/2addr', 0xB0);
 
 type DalvikBytecodeOperationAddIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddIntInPlaceParser>>;
 
-const dalvikBytecodeOperationReverseSubtractIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rsub-int', 0xb1);
+const dalvikBytecodeOperationReverseSubtractIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-int/2addr', 0xB1);
 
 type DalvikBytecodeOperationReverseSubtractIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractIntInPlaceParser>>;
 
-const dalvikBytecodeOperationMultiplyIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-int/2addr', 0xb2);
+const dalvikBytecodeOperationMultiplyIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-int/2addr', 0xB2);
 
 type DalvikBytecodeOperationMultiplyIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyIntInPlaceParser>>;
 
-const dalvikBytecodeOperationDivideIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-int/2addr', 0xb3);
+const dalvikBytecodeOperationDivideIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-int/2addr', 0xB3);
 
 type DalvikBytecodeOperationDivideIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideIntInPlaceParser>>;
 
-const dalvikBytecodeOperationRemainderIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-int/2addr', 0xb4);
+const dalvikBytecodeOperationRemainderIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-int/2addr', 0xB4);
 
 type DalvikBytecodeOperationRemainderIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderIntInPlaceParser>>;
 
-const dalvikBytecodeOperationAndIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('and-int/2addr', 0xb5);
+const dalvikBytecodeOperationAndIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('and-int/2addr', 0xB5);
 
 type DalvikBytecodeOperationAndIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAndIntInPlaceParser>>;
 
-const dalvikBytecodeOperationOrIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('or-int/2addr', 0xb6);
+const dalvikBytecodeOperationOrIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('or-int/2addr', 0xB6);
 
 type DalvikBytecodeOperationOrIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationOrIntInPlaceParser>>;
 
-const dalvikBytecodeOperationXorIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('xor-int/2addr', 0xb7);
+const dalvikBytecodeOperationXorIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('xor-int/2addr', 0xB7);
 
 type DalvikBytecodeOperationXorIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationXorIntInPlaceParser>>;
 
-const dalvikBytecodeOperationShiftLeftIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shl-int/2addr', 0xb8);
+const dalvikBytecodeOperationShiftLeftIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shl-int/2addr', 0xB8);
 
 type DalvikBytecodeOperationShiftLeftIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftIntInPlaceParser>>;
 
-const dalvikBytecodeOperationShiftRightIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shr-int/2addr', 0xb9);
+const dalvikBytecodeOperationShiftRightIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shr-int/2addr', 0xB9);
 
 type DalvikBytecodeOperationShiftRightIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightIntInPlaceParser>>;
 
-const dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('ushr-int/2addr', 0xba);
+const dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('ushr-int/2addr', 0xBA);
 
 type DalvikBytecodeOperationUnsignedShiftRightIntInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser>>;
 
-const dalvikBytecodeOperationAddLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-long/2addr', 0xbb);
+const dalvikBytecodeOperationAddLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-long/2addr', 0xBB);
 
 type DalvikBytecodeOperationAddLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddLongInPlaceParser>>;
 
-const dalvikBytecodeOperationReverseSubtractLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rsub-long', 0xbc);
+const dalvikBytecodeOperationSubtractLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-long/2addr', 0xBC);
 
-type DalvikBytecodeOperationReverseSubtractLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationReverseSubtractLongInPlaceParser>>;
+type DalvikBytecodeOperationSubtractLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractLongInPlaceParser>>;
 
-const dalvikBytecodeOperationMultiplyLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-long/2addr', 0xbd);
+const dalvikBytecodeOperationMultiplyLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-long/2addr', 0xBD);
 
 type DalvikBytecodeOperationMultiplyLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyLongInPlaceParser>>;
 
-const dalvikBytecodeOperationDivideLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-long/2addr', 0xbe);
+const dalvikBytecodeOperationDivideLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-long/2addr', 0xBE);
 
 type DalvikBytecodeOperationDivideLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideLongInPlaceParser>>;
 
-const dalvikBytecodeOperationRemainderLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-long/2addr', 0xbf);
+const dalvikBytecodeOperationRemainderLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-long/2addr', 0xBF);
 
 type DalvikBytecodeOperationRemainderLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderLongInPlaceParser>>;
 
-const dalvikBytecodeOperationAndLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('and-long/2addr', 0xc0);
+const dalvikBytecodeOperationAndLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('and-long/2addr', 0xC0);
 
 type DalvikBytecodeOperationAndLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAndLongInPlaceParser>>;
 
-const dalvikBytecodeOperationOrLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('or-long/2addr', 0xc1);
+const dalvikBytecodeOperationOrLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('or-long/2addr', 0xC1);
 
 type DalvikBytecodeOperationOrLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationOrLongInPlaceParser>>;
 
-const dalvikBytecodeOperationXorLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('xor-long/2addr', 0xc2);
+const dalvikBytecodeOperationXorLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('xor-long/2addr', 0xC2);
 
 type DalvikBytecodeOperationXorLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationXorLongInPlaceParser>>;
 
-const dalvikBytecodeOperationShiftLeftLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shl-long/2addr', 0xc3);
+const dalvikBytecodeOperationShiftLeftLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shl-long/2addr', 0xC3);
 
 type DalvikBytecodeOperationShiftLeftLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftLongInPlaceParser>>;
 
-const dalvikBytecodeOperationShiftRightLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shr-long/2addr', 0xc4);
+const dalvikBytecodeOperationShiftRightLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('shr-long/2addr', 0xC4);
 
 type DalvikBytecodeOperationShiftRightLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightLongInPlaceParser>>;
 
-const dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('ushr-long/2addr', 0xc5);
+const dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('ushr-long/2addr', 0xC5);
 
 type DalvikBytecodeOperationUnsignedShiftRightLongInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser>>;
 
-const dalvikBytecodeOperationAddFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-float/2addr', 0xc6);
+const dalvikBytecodeOperationAddFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-float/2addr', 0xC6);
 
 type DalvikBytecodeOperationAddFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddFloatInPlaceParser>>;
 
-const dalvikBytecodeOperationSubtractFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-float/2addr', 0xc7);
+const dalvikBytecodeOperationSubtractFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-float/2addr', 0xC7);
 
 type DalvikBytecodeOperationSubtractFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractFloatInPlaceParser>>;
 
-const dalvikBytecodeOperationMultiplyFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-float/2addr', 0xc8);
+const dalvikBytecodeOperationMultiplyFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-float/2addr', 0xC8);
 
 type DalvikBytecodeOperationMultiplyFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyFloatInPlaceParser>>;
 
-const dalvikBytecodeOperationDivideFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-float/2addr', 0xc9);
+const dalvikBytecodeOperationDivideFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-float/2addr', 0xC9);
 
 type DalvikBytecodeOperationDivideFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideFloatInPlaceParser>>;
 
-const dalvikBytecodeOperationAddDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-double/2addr', 0xca);
+const dalvikBytecodeOperationRemainderFloatInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-float/2addr', 0xCA);
+
+type DalvikBytecodeOperationRemainderFloatInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderFloatInPlaceParser>>;
+
+const dalvikBytecodeOperationAddDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('add-double/2addr', 0xCB);
 
 type DalvikBytecodeOperationAddDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationAddDoubleInPlaceParser>>;
 
-const dalvikBytecodeOperationSubtractDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-double/2addr', 0xcb);
+const dalvikBytecodeOperationSubtractDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('sub-double/2addr', 0xCC);
 
 type DalvikBytecodeOperationSubtractDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractDoubleInPlaceParser>>;
 
-const dalvikBytecodeOperationMultiplyDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-double/2addr', 0xcc);
+const dalvikBytecodeOperationMultiplyDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('mul-double/2addr', 0xCD);
 
 type DalvikBytecodeOperationMultiplyDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyDoubleInPlaceParser>>;
 
-const dalvikBytecodeOperationDivideDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-double/2addr', 0xcd);
+const dalvikBytecodeOperationDivideDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('div-double/2addr', 0xCE);
 
 type DalvikBytecodeOperationDivideDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideDoubleInPlaceParser>>;
 
-const dalvikBytecodeOperationRemainderDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-double/2addr', 0xce);
+const dalvikBytecodeOperationRemainderDoubleInPlaceParser = createDalvikBytecodeOperationBinaryOperationInPlace('rem-double/2addr', 0xCF);
 
 type DalvikBytecodeOperationRemainderDoubleInPlace = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderDoubleInPlaceParser>>;
 
@@ -853,7 +1116,7 @@ type DalvikBytecodeOperationBinaryOperationInPlace =
 	| DalvikBytecodeOperationShiftRightIntInPlace
 	| DalvikBytecodeOperationUnsignedShiftRightIntInPlace
 	| DalvikBytecodeOperationAddLongInPlace
-	| DalvikBytecodeOperationReverseSubtractLongInPlace
+	| DalvikBytecodeOperationSubtractLongInPlace
 	| DalvikBytecodeOperationMultiplyLongInPlace
 	| DalvikBytecodeOperationDivideLongInPlace
 	| DalvikBytecodeOperationRemainderLongInPlace
@@ -867,6 +1130,7 @@ type DalvikBytecodeOperationBinaryOperationInPlace =
 	| DalvikBytecodeOperationSubtractFloatInPlace
 	| DalvikBytecodeOperationMultiplyFloatInPlace
 	| DalvikBytecodeOperationDivideFloatInPlace
+	| DalvikBytecodeOperationRemainderFloatInPlace
 	| DalvikBytecodeOperationAddDoubleInPlace
 	| DalvikBytecodeOperationSubtractDoubleInPlace
 	| DalvikBytecodeOperationMultiplyDoubleInPlace
@@ -874,7 +1138,7 @@ type DalvikBytecodeOperationBinaryOperationInPlace =
 	| DalvikBytecodeOperationRemainderDoubleInPlace
 ;
 
-const dalvikBytecodeOperationBinaryOperationInPlaceParser: Parser<DalvikBytecodeOperationBinaryOperationInPlace, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationBinaryOperationInPlaceParser: Parser<DalvikBytecodeOperationBinaryOperationInPlace, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationAddIntInPlaceParser,
 	dalvikBytecodeOperationReverseSubtractIntInPlaceParser,
 	dalvikBytecodeOperationMultiplyIntInPlaceParser,
@@ -887,7 +1151,7 @@ const dalvikBytecodeOperationBinaryOperationInPlaceParser: Parser<DalvikBytecode
 	dalvikBytecodeOperationShiftRightIntInPlaceParser,
 	dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser,
 	dalvikBytecodeOperationAddLongInPlaceParser,
-	dalvikBytecodeOperationReverseSubtractLongInPlaceParser,
+	dalvikBytecodeOperationSubtractLongInPlaceParser,
 	dalvikBytecodeOperationMultiplyLongInPlaceParser,
 	dalvikBytecodeOperationDivideLongInPlaceParser,
 	dalvikBytecodeOperationRemainderLongInPlaceParser,
@@ -901,6 +1165,7 @@ const dalvikBytecodeOperationBinaryOperationInPlaceParser: Parser<DalvikBytecode
 	dalvikBytecodeOperationSubtractFloatInPlaceParser,
 	dalvikBytecodeOperationMultiplyFloatInPlaceParser,
 	dalvikBytecodeOperationDivideFloatInPlaceParser,
+	dalvikBytecodeOperationRemainderFloatInPlaceParser,
 	dalvikBytecodeOperationAddDoubleInPlaceParser,
 	dalvikBytecodeOperationSubtractDoubleInPlaceParser,
 	dalvikBytecodeOperationMultiplyDoubleInPlaceParser,
@@ -964,87 +1229,87 @@ const dalvikBytecodeOperationShiftRightIntParser = createDalvikBytecodeOperation
 
 type DalvikBytecodeOperationShiftRightInt = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightIntParser>>;
 
-const dalvikBytecodeOperationUnsignedShiftRightIntParser = createDalvikBytecodeOperationBinaryOperation('ushr-int', 0x9a);
+const dalvikBytecodeOperationUnsignedShiftRightIntParser = createDalvikBytecodeOperationBinaryOperation('ushr-int', 0x9A);
 
 type DalvikBytecodeOperationUnsignedShiftRightInt = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightIntParser>>;
 
-const dalvikBytecodeOperationAddLongParser = createDalvikBytecodeOperationBinaryOperation('add-long', 0x9b);
+const dalvikBytecodeOperationAddLongParser = createDalvikBytecodeOperationBinaryOperation('add-long', 0x9B);
 
 type DalvikBytecodeOperationAddLong = Awaited<ReturnType<typeof dalvikBytecodeOperationAddLongParser>>;
 
-const dalvikBytecodeOperationSubtractLongParser = createDalvikBytecodeOperationBinaryOperation('sub-long', 0x9c);
+const dalvikBytecodeOperationSubtractLongParser = createDalvikBytecodeOperationBinaryOperation('sub-long', 0x9C);
 
 type DalvikBytecodeOperationSubtractLong = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractLongParser>>;
 
-const dalvikBytecodeOperationMultiplyLongParser = createDalvikBytecodeOperationBinaryOperation('mul-long', 0x9d);
+const dalvikBytecodeOperationMultiplyLongParser = createDalvikBytecodeOperationBinaryOperation('mul-long', 0x9D);
 
 type DalvikBytecodeOperationMultiplyLong = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyLongParser>>;
 
-const dalvikBytecodeOperationDivideLongParser = createDalvikBytecodeOperationBinaryOperation('div-long', 0x9e);
+const dalvikBytecodeOperationDivideLongParser = createDalvikBytecodeOperationBinaryOperation('div-long', 0x9E);
 
 type DalvikBytecodeOperationDivideLong = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideLongParser>>;
 
-const dalvikBytecodeOperationRemainderLongParser = createDalvikBytecodeOperationBinaryOperation('rem-long', 0x9f);
+const dalvikBytecodeOperationRemainderLongParser = createDalvikBytecodeOperationBinaryOperation('rem-long', 0x9F);
 
 type DalvikBytecodeOperationRemainderLong = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderLongParser>>;
 
-const dalvikBytecodeOperationAndLongParser = createDalvikBytecodeOperationBinaryOperation('and-long', 0xa0);
+const dalvikBytecodeOperationAndLongParser = createDalvikBytecodeOperationBinaryOperation('and-long', 0xA0);
 
 type DalvikBytecodeOperationAndLong = Awaited<ReturnType<typeof dalvikBytecodeOperationAndLongParser>>;
 
-const dalvikBytecodeOperationOrLongParser = createDalvikBytecodeOperationBinaryOperation('or-long', 0xa1);
+const dalvikBytecodeOperationOrLongParser = createDalvikBytecodeOperationBinaryOperation('or-long', 0xA1);
 
 type DalvikBytecodeOperationOrLong = Awaited<ReturnType<typeof dalvikBytecodeOperationOrLongParser>>;
 
-const dalvikBytecodeOperationXorLongParser = createDalvikBytecodeOperationBinaryOperation('xor-long', 0xa2);
+const dalvikBytecodeOperationXorLongParser = createDalvikBytecodeOperationBinaryOperation('xor-long', 0xA2);
 
 type DalvikBytecodeOperationXorLong = Awaited<ReturnType<typeof dalvikBytecodeOperationXorLongParser>>;
 
-const dalvikBytecodeOperationShiftLeftLongParser = createDalvikBytecodeOperationBinaryOperation('shl-long', 0xa3);
+const dalvikBytecodeOperationShiftLeftLongParser = createDalvikBytecodeOperationBinaryOperation('shl-long', 0xA3);
 
 type DalvikBytecodeOperationShiftLeftLong = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftLeftLongParser>>;
 
-const dalvikBytecodeOperationShiftRightLongParser = createDalvikBytecodeOperationBinaryOperation('shr-long', 0xa4);
+const dalvikBytecodeOperationShiftRightLongParser = createDalvikBytecodeOperationBinaryOperation('shr-long', 0xA4);
 
 type DalvikBytecodeOperationShiftRightLong = Awaited<ReturnType<typeof dalvikBytecodeOperationShiftRightLongParser>>;
 
-const dalvikBytecodeOperationUnsignedShiftRightLongParser = createDalvikBytecodeOperationBinaryOperation('ushr-long', 0xa5);
+const dalvikBytecodeOperationUnsignedShiftRightLongParser = createDalvikBytecodeOperationBinaryOperation('ushr-long', 0xA5);
 
 type DalvikBytecodeOperationUnsignedShiftRightLong = Awaited<ReturnType<typeof dalvikBytecodeOperationUnsignedShiftRightLongParser>>;
 
-const dalvikBytecodeOperationAddFloatParser = createDalvikBytecodeOperationBinaryOperation('add-float', 0xa6);
+const dalvikBytecodeOperationAddFloatParser = createDalvikBytecodeOperationBinaryOperation('add-float', 0xA6);
 
 type DalvikBytecodeOperationAddFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationAddFloatParser>>;
 
-const dalvikBytecodeOperationSubtractFloatParser = createDalvikBytecodeOperationBinaryOperation('sub-float', 0xa7);
+const dalvikBytecodeOperationSubtractFloatParser = createDalvikBytecodeOperationBinaryOperation('sub-float', 0xA7);
 
 type DalvikBytecodeOperationSubtractFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractFloatParser>>;
 
-const dalvikBytecodeOperationMultiplyFloatParser = createDalvikBytecodeOperationBinaryOperation('mul-float', 0xa8);
+const dalvikBytecodeOperationMultiplyFloatParser = createDalvikBytecodeOperationBinaryOperation('mul-float', 0xA8);
 
 type DalvikBytecodeOperationMultiplyFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyFloatParser>>;
 
-const dalvikBytecodeOperationDivideFloatParser = createDalvikBytecodeOperationBinaryOperation('div-float', 0xa9);
+const dalvikBytecodeOperationDivideFloatParser = createDalvikBytecodeOperationBinaryOperation('div-float', 0xA9);
 
 type DalvikBytecodeOperationDivideFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideFloatParser>>;
 
-const dalvikBytecodeOperationAddDoubleParser = createDalvikBytecodeOperationBinaryOperation('add-double', 0xaa);
+const dalvikBytecodeOperationAddDoubleParser = createDalvikBytecodeOperationBinaryOperation('add-double', 0xAB);
 
 type DalvikBytecodeOperationAddDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationAddDoubleParser>>;
 
-const dalvikBytecodeOperationSubtractDoubleParser = createDalvikBytecodeOperationBinaryOperation('sub-double', 0xab);
+const dalvikBytecodeOperationSubtractDoubleParser = createDalvikBytecodeOperationBinaryOperation('sub-double', 0xAC);
 
 type DalvikBytecodeOperationSubtractDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationSubtractDoubleParser>>;
 
-const dalvikBytecodeOperationMultiplyDoubleParser = createDalvikBytecodeOperationBinaryOperation('mul-double', 0xac);
+const dalvikBytecodeOperationMultiplyDoubleParser = createDalvikBytecodeOperationBinaryOperation('mul-double', 0xAD);
 
 type DalvikBytecodeOperationMultiplyDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationMultiplyDoubleParser>>;
 
-const dalvikBytecodeOperationDivideDoubleParser = createDalvikBytecodeOperationBinaryOperation('div-double', 0xad);
+const dalvikBytecodeOperationDivideDoubleParser = createDalvikBytecodeOperationBinaryOperation('div-double', 0xAE);
 
 type DalvikBytecodeOperationDivideDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationDivideDoubleParser>>;
 
-const dalvikBytecodeOperationRemainderDoubleParser = createDalvikBytecodeOperationBinaryOperation('rem-double', 0xae);
+const dalvikBytecodeOperationRemainderDoubleParser = createDalvikBytecodeOperationBinaryOperation('rem-double', 0xAF);
 
 type DalvikBytecodeOperationRemainderDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationRemainderDoubleParser>>;
 
@@ -1082,7 +1347,7 @@ type DalvikBytecodeOperationBinaryOperation =
 	| DalvikBytecodeOperationRemainderDouble
 ;
 
-const dalvikBytecodeOperationBinaryOperationParser: Parser<DalvikBytecodeOperationBinaryOperation, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationBinaryOperationParser: Parser<DalvikBytecodeOperationBinaryOperation, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationAddIntParser,
 	dalvikBytecodeOperationSubtractIntParser,
 	dalvikBytecodeOperationMultiplyIntParser,
@@ -1132,23 +1397,23 @@ const createDalvikBytecodeOperationUnaryOperation = <T extends string>(operation
 	}),
 );
 
-const dalvikBytecodeOperationNegateIntParser = createDalvikBytecodeOperationUnaryOperation('neg-int', 0x7b);
+const dalvikBytecodeOperationNegateIntParser = createDalvikBytecodeOperationUnaryOperation('neg-int', 0x7B);
 
 type DalvikBytecodeOperationNegateInt = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateIntParser>>;
 
-const dalvikBytecodeOperationNotIntParser = createDalvikBytecodeOperationUnaryOperation('not-int', 0x7c);
+const dalvikBytecodeOperationNotIntParser = createDalvikBytecodeOperationUnaryOperation('not-int', 0x7C);
 
 type DalvikBytecodeOperationNotInt = Awaited<ReturnType<typeof dalvikBytecodeOperationNotIntParser>>;
 
-const dalvikBytecodeOperationNegateLongParser = createDalvikBytecodeOperationUnaryOperation('neg-long', 0x7d);
+const dalvikBytecodeOperationNegateLongParser = createDalvikBytecodeOperationUnaryOperation('neg-long', 0x7D);
 
 type DalvikBytecodeOperationNegateLong = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateLongParser>>;
 
-const dalvikBytecodeOperationNotLongParser = createDalvikBytecodeOperationUnaryOperation('not-long', 0x7e);
+const dalvikBytecodeOperationNotLongParser = createDalvikBytecodeOperationUnaryOperation('not-long', 0x7E);
 
 type DalvikBytecodeOperationNotLong = Awaited<ReturnType<typeof dalvikBytecodeOperationNotLongParser>>;
 
-const dalvikBytecodeOperationNegateFloatParser = createDalvikBytecodeOperationUnaryOperation('neg-float', 0x7f);
+const dalvikBytecodeOperationNegateFloatParser = createDalvikBytecodeOperationUnaryOperation('neg-float', 0x7F);
 
 type DalvikBytecodeOperationNegateFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationNegateFloatParser>>;
 
@@ -1192,27 +1457,27 @@ const dalvikBytecodeOperationFloatToDoubleParser = createDalvikBytecodeOperation
 
 type DalvikBytecodeOperationFloatToDouble = Awaited<ReturnType<typeof dalvikBytecodeOperationFloatToDoubleParser>>;
 
-const dalvikBytecodeOperationDoubleToIntParser = createDalvikBytecodeOperationUnaryOperation('double-to-int', 0x8a);
+const dalvikBytecodeOperationDoubleToIntParser = createDalvikBytecodeOperationUnaryOperation('double-to-int', 0x8A);
 
 type DalvikBytecodeOperationDoubleToInt = Awaited<ReturnType<typeof dalvikBytecodeOperationDoubleToIntParser>>;
 
-const dalvikBytecodeOperationDoubleToLongParser = createDalvikBytecodeOperationUnaryOperation('double-to-long', 0x8b);
+const dalvikBytecodeOperationDoubleToLongParser = createDalvikBytecodeOperationUnaryOperation('double-to-long', 0x8B);
 
 type DalvikBytecodeOperationDoubleToLong = Awaited<ReturnType<typeof dalvikBytecodeOperationDoubleToLongParser>>;
 
-const dalvikBytecodeOperationDoubleToFloatParser = createDalvikBytecodeOperationUnaryOperation('double-to-float', 0x8c);
+const dalvikBytecodeOperationDoubleToFloatParser = createDalvikBytecodeOperationUnaryOperation('double-to-float', 0x8C);
 
 type DalvikBytecodeOperationDoubleToFloat = Awaited<ReturnType<typeof dalvikBytecodeOperationDoubleToFloatParser>>;
 
-const dalvikBytecodeOperationIntToByteParser = createDalvikBytecodeOperationUnaryOperation('int-to-byte', 0x8d);
+const dalvikBytecodeOperationIntToByteParser = createDalvikBytecodeOperationUnaryOperation('int-to-byte', 0x8D);
 
 type DalvikBytecodeOperationIntToByte = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToByteParser>>;
 
-const dalvikBytecodeOperationIntToCharParser = createDalvikBytecodeOperationUnaryOperation('int-to-char', 0x8e);
+const dalvikBytecodeOperationIntToCharParser = createDalvikBytecodeOperationUnaryOperation('int-to-char', 0x8E);
 
 type DalvikBytecodeOperationIntToChar = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToCharParser>>;
 
-const dalvikBytecodeOperationIntToShortParser = createDalvikBytecodeOperationUnaryOperation('int-to-short', 0x8f);
+const dalvikBytecodeOperationIntToShortParser = createDalvikBytecodeOperationUnaryOperation('int-to-short', 0x8F);
 
 type DalvikBytecodeOperationIntToShort = Awaited<ReturnType<typeof dalvikBytecodeOperationIntToShortParser>>;
 
@@ -1240,7 +1505,7 @@ type DalvikBytecodeOperationUnaryOperation =
 	| DalvikBytecodeOperationIntToShort
 ;
 
-const dalvikBytecodeOperationUnaryOperationParser: Parser<DalvikBytecodeOperationUnaryOperation, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationUnaryOperationParser: Parser<DalvikBytecodeOperationUnaryOperation, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationNegateIntParser,
 	dalvikBytecodeOperationNotIntParser,
 	dalvikBytecodeOperationNegateLongParser,
@@ -1266,6 +1531,24 @@ const dalvikBytecodeOperationUnaryOperationParser: Parser<DalvikBytecodeOperatio
 
 setParserName(dalvikBytecodeOperationUnaryOperationParser, 'dalvikBytecodeOperationUnaryOperationParser');
 
+// For commutative comparison operations (if-eq, if-ne), sort registers to match baksmali's canonical output
+const createDalvikBytecodeOperationIfTestCommutative = <T extends string>(operation: T, opcode: number): Parser<{
+	operation: T;
+	registers: number[];
+	branchOffset: number;
+}, Uint8Array> => promiseCompose(
+	createTupleParser([
+		createExactElementParser(opcode),
+		createDalvikBytecodeFormat22tParser(),
+	]),
+	([ _opcode, { registers, branchOffset } ]) => ({
+		operation,
+		registers: registers.sort((a, b) => a - b),
+		branchOffset,
+	}),
+);
+
+// For non-commutative comparison operations (if-lt, if-ge, if-gt, if-le), reverse to get correct semantic order
 const createDalvikBytecodeOperationIfTest = <T extends string>(operation: T, opcode: number): Parser<{
 	operation: T;
 	registers: number[];
@@ -1277,16 +1560,16 @@ const createDalvikBytecodeOperationIfTest = <T extends string>(operation: T, opc
 	]),
 	([ _opcode, { registers, branchOffset } ]) => ({
 		operation,
-		registers,
+		registers: registers.reverse(),
 		branchOffset,
 	}),
 );
 
-const dalvikBytecodeIfEqualParser = createDalvikBytecodeOperationIfTest('if-eq', 0x32);
+const dalvikBytecodeIfEqualParser = createDalvikBytecodeOperationIfTestCommutative('if-eq', 0x32);
 
 type DalvikBytecodeOperationIfEqual = Awaited<ReturnType<typeof dalvikBytecodeIfEqualParser>>;
 
-const dalvikBytecodeIfNotEqualParser = createDalvikBytecodeOperationIfTest('if-neq', 0x33);
+const dalvikBytecodeIfNotEqualParser = createDalvikBytecodeOperationIfTestCommutative('if-ne', 0x33);
 
 type DalvikBytecodeOperationIfNotEqual = Awaited<ReturnType<typeof dalvikBytecodeIfNotEqualParser>>;
 
@@ -1315,7 +1598,7 @@ type DalvikBytecodeOperationIfTest =
 	| DalvikBytecodeOperationIfLessThanOrEqualTo
 ;
 
-const dalvikBytecodeOperationIfTestParser: Parser<DalvikBytecodeOperationIfTest, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationIfTestParser: Parser<DalvikBytecodeOperationIfTest, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeIfEqualParser,
 	dalvikBytecodeIfNotEqualParser,
 	dalvikBytecodeIfLessThanParser,
@@ -1350,19 +1633,19 @@ const dalvikBytecodeIfNotEqualZeroParser = createDalvikBytecodeOperationIfTestZe
 
 type DalvikBytecodeOperationIfNotEqualZero = Awaited<ReturnType<typeof dalvikBytecodeIfNotEqualZeroParser>>;
 
-const dalvikBytecodeIfLessThanZeroParser = createDalvikBytecodeOperationIfTestZero('if-ltz', 0x3a);
+const dalvikBytecodeIfLessThanZeroParser = createDalvikBytecodeOperationIfTestZero('if-ltz', 0x3A);
 
 type DalvikBytecodeOperationIfLessThanZero = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanZeroParser>>;
 
-const dalvikBytecodeIfGreaterThanOrEqualToZeroParser = createDalvikBytecodeOperationIfTestZero('if-gez', 0x3b);
+const dalvikBytecodeIfGreaterThanOrEqualToZeroParser = createDalvikBytecodeOperationIfTestZero('if-gez', 0x3B);
 
 type DalvikBytecodeOperationIfGreaterThanOrEqualToZero = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanOrEqualToZeroParser>>;
 
-const dalvikBytecodeIfGreaterThanZeroParser = createDalvikBytecodeOperationIfTestZero('if-gtz', 0x3c);
+const dalvikBytecodeIfGreaterThanZeroParser = createDalvikBytecodeOperationIfTestZero('if-gtz', 0x3C);
 
 type DalvikBytecodeOperationIfGreaterThanZero = Awaited<ReturnType<typeof dalvikBytecodeIfGreaterThanZeroParser>>;
 
-const dalvikBytecodeIfLessThanOrEqualToZeroParser = createDalvikBytecodeOperationIfTestZero('if-lez', 0x3d);
+const dalvikBytecodeIfLessThanOrEqualToZeroParser = createDalvikBytecodeOperationIfTestZero('if-lez', 0x3D);
 
 type DalvikBytecodeOperationIfLessThanOrEqualToZero = Awaited<ReturnType<typeof dalvikBytecodeIfLessThanOrEqualToZeroParser>>;
 
@@ -1375,7 +1658,7 @@ type DalvikBytecodeOperationIfTestZero =
 	| DalvikBytecodeOperationIfLessThanOrEqualToZero
 ;
 
-const dalvikBytecodeOperationIfTestZeroParser: Parser<DalvikBytecodeOperationIfTestZero, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationIfTestZeroParser: Parser<DalvikBytecodeOperationIfTestZero, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeIfEqualZeroParser,
 	dalvikBytecodeIfNotEqualZeroParser,
 	dalvikBytecodeIfLessThanZeroParser,
@@ -1394,7 +1677,7 @@ type DalvikBytecodeOperationConstString = {
 
 const dalvikBytecodeOperationConstStringParser: Parser<DalvikBytecodeOperationConstString, Uint8Array> = promiseCompose(
 	createTupleParser([
-		createExactElementParser(0x1a),
+		createExactElementParser(0x1A),
 		createDalvikBytecodeFormat21cParser({
 			isoIndex: isoIndexIntoStringIds,
 		}),
@@ -1408,6 +1691,28 @@ const dalvikBytecodeOperationConstStringParser: Parser<DalvikBytecodeOperationCo
 
 setParserName(dalvikBytecodeOperationConstStringParser, 'dalvikBytecodeOperationConstStringParser');
 
+type DalvikBytecodeOperationConstStringJumbo = {
+	operation: 'const-string/jumbo';
+	stringIndex: IndexIntoStringIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationConstStringJumboParser: Parser<DalvikBytecodeOperationConstStringJumbo, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x1B),
+		createDalvikBytecodeFormat31cParser({
+			isoIndex: isoIndexIntoStringIds,
+		}),
+	]),
+	([ _opcode, { index, registers } ]) => ({
+		operation: 'const-string/jumbo',
+		stringIndex: index,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationConstStringJumboParser, 'dalvikBytecodeOperationConstStringJumboParser');
+
 type DalvikBytecodeOperationConstMethodHandle = {
 	operation: 'const-method-handle';
 	methodIndex: IndexIntoMethodIds;
@@ -1416,7 +1721,7 @@ type DalvikBytecodeOperationConstMethodHandle = {
 
 const dalvikBytecodeOperationConstMethodHandleParser: Parser<DalvikBytecodeOperationConstMethodHandle, Uint8Array> = promiseCompose(
 	createTupleParser([
-		createExactElementParser(0xfe),
+		createExactElementParser(0xFE),
 		createDalvikBytecodeFormat21cParser({
 			isoIndex: isoIndexIntoMethodIds,
 		}),
@@ -1474,6 +1779,70 @@ const dalvikBytecodeOperationNewArrayParser: Parser<DalvikBytecodeOperationNewAr
 
 setParserName(dalvikBytecodeOperationNewArrayParser, 'dalvikBytecodeOperationNewArrayParser');
 
+type DalvikBytecodeOperationFilledNewArray = {
+	operation: 'filled-new-array';
+	typeIndex: IndexIntoTypeIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationFilledNewArrayParser: Parser<DalvikBytecodeOperationFilledNewArray, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x24),
+		createDalvikBytecodeFormat35cParser({
+			isoIndex: isoIndexIntoTypeIds,
+		}),
+	]),
+	([ _opcode, { index, registers } ]) => ({
+		operation: 'filled-new-array',
+		typeIndex: index,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationFilledNewArrayParser, 'dalvikBytecodeOperationFilledNewArrayParser');
+
+type DalvikBytecodeOperationFilledNewArrayRange = {
+	operation: 'filled-new-array/range';
+	typeIndex: IndexIntoTypeIds;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationFilledNewArrayRangeParser: Parser<DalvikBytecodeOperationFilledNewArrayRange, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x25),
+		createDalvikBytecodeFormat3rcParser({
+			isoIndex: isoIndexIntoTypeIds,
+		}),
+	]),
+	([ _opcode, { index, registers } ]) => ({
+		operation: 'filled-new-array/range',
+		typeIndex: index,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationFilledNewArrayRangeParser, 'dalvikBytecodeOperationFilledNewArrayRangeParser');
+
+type DalvikBytecodeOperationFillArrayData = {
+	operation: 'fill-array-data';
+	branchOffset: number;
+	registers: number[];
+};
+
+const dalvikBytecodeOperationFillArrayDataParser: Parser<DalvikBytecodeOperationFillArrayData, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x26),
+		dalvikBytecodeFormat31tParser,
+	]),
+	([ _opcode, { branchOffset, registers } ]) => ({
+		operation: 'fill-array-data',
+		branchOffset,
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationFillArrayDataParser, 'dalvikBytecodeOperationFillArrayDataParser');
+
 type DalvikBytecodeOperationCheckCast = {
 	operation: 'check-cast';
 	typeIndex: IndexIntoTypeIds;
@@ -1482,7 +1851,7 @@ type DalvikBytecodeOperationCheckCast = {
 
 const dalvikBytecodeOperationCheckCastParser: Parser<DalvikBytecodeOperationCheckCast, Uint8Array> = promiseCompose(
 	createTupleParser([
-		createExactElementParser(0x1f),
+		createExactElementParser(0x1F),
 		createDalvikBytecodeFormat21cParser({
 			isoIndex: isoIndexIntoTypeIds,
 		}),
@@ -1496,6 +1865,24 @@ const dalvikBytecodeOperationCheckCastParser: Parser<DalvikBytecodeOperationChec
 
 setParserName(dalvikBytecodeOperationCheckCastParser, 'dalvikBytecodeOperationCheckCastParser');
 
+type DalvikBytecodeOperationArrayLength = {
+	operation: 'array-length';
+	registers: number[];
+};
+
+const dalvikBytecodeOperationArrayLengthParser: Parser<DalvikBytecodeOperationArrayLength, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x21),
+		dalvikBytecodeFormat12xParser,
+	]),
+	([ _opcode, { registers } ]) => ({
+		operation: 'array-length',
+		registers: registers.reverse(),
+	}),
+);
+
+setParserName(dalvikBytecodeOperationArrayLengthParser, 'dalvikBytecodeOperationArrayLengthParser');
+
 type DalvikBytecodeOperationConstClass = {
 	operation: 'const-class';
 	typeIndex: IndexIntoTypeIds;
@@ -1504,7 +1891,7 @@ type DalvikBytecodeOperationConstClass = {
 
 const dalvikBytecodeOperationConstClassParser: Parser<DalvikBytecodeOperationConstClass, Uint8Array> = promiseCompose(
 	createTupleParser([
-		createExactElementParser(0x1c),
+		createExactElementParser(0x1C),
 		createDalvikBytecodeFormat21cParser({
 			isoIndex: isoIndexIntoTypeIds,
 		}),
@@ -1518,13 +1905,49 @@ const dalvikBytecodeOperationConstClassParser: Parser<DalvikBytecodeOperationCon
 
 setParserName(dalvikBytecodeOperationConstClassParser, 'dalvikBytecodeOperationConstClassParser');
 
+type DalvikBytecodeOperationMonitorEnter = {
+	operation: 'monitor-enter';
+	registers: number[];
+};
+
+const dalvikBytecodeOperationMonitorEnterParser: Parser<DalvikBytecodeOperationMonitorEnter, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x1D),
+		dalvikBytecodeFormat11xParser,
+	]),
+	([ _opcode, { registers } ]) => ({
+		operation: 'monitor-enter',
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationMonitorEnterParser, 'dalvikBytecodeOperationMonitorEnterParser');
+
+type DalvikBytecodeOperationMonitorExit = {
+	operation: 'monitor-exit';
+	registers: number[];
+};
+
+const dalvikBytecodeOperationMonitorExitParser: Parser<DalvikBytecodeOperationMonitorExit, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x1E),
+		dalvikBytecodeFormat11xParser,
+	]),
+	([ _opcode, { registers } ]) => ({
+		operation: 'monitor-exit',
+		registers,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationMonitorExitParser, 'dalvikBytecodeOperationMonitorExitParser');
+
 type DalvikBytecodeOperationReturnVoid = {
 	operation: 'return-void';
 };
 
 const dalvikBytecodeOperationReturnVoidParser: Parser<DalvikBytecodeOperationReturnVoid, Uint8Array> = promiseCompose(
 	createTupleParser([
-		createExactElementParser(0x0e),
+		createExactElementParser(0x0E),
 		dalvikBytecodeFormat10xParser,
 	]),
 	() => ({
@@ -1548,19 +1971,19 @@ const createDalvikBytecodeMoveResult1Parser = <T extends string>(operation: T, o
 	}),
 );
 
-const dalvikBytecodeMoveResultParser = createDalvikBytecodeMoveResult1Parser('move-result', 0x0a);
+const dalvikBytecodeMoveResultParser = createDalvikBytecodeMoveResult1Parser('move-result', 0x0A);
 
 type DalvikBytecodeOperationMoveResult = Awaited<ReturnType<typeof dalvikBytecodeMoveResultParser>>;
 
-const dalvikBytecodeMoveResultWideParser = createDalvikBytecodeMoveResult1Parser('move-result-wide', 0x0b);
+const dalvikBytecodeMoveResultWideParser = createDalvikBytecodeMoveResult1Parser('move-result-wide', 0x0B);
 
 type DalvikBytecodeOperationMoveResultWide = Awaited<ReturnType<typeof dalvikBytecodeMoveResultWideParser>>;
 
-const dalvikBytecodeMoveResultObjectParser = createDalvikBytecodeMoveResult1Parser('move-result-object', 0x0c);
+const dalvikBytecodeMoveResultObjectParser = createDalvikBytecodeMoveResult1Parser('move-result-object', 0x0C);
 
 type DalvikBytecodeOperationMoveResultObject = Awaited<ReturnType<typeof dalvikBytecodeMoveResultObjectParser>>;
 
-const dalvikBytecodeMoveExceptionParser = createDalvikBytecodeMoveResult1Parser('move-exception', 0x0d);
+const dalvikBytecodeMoveExceptionParser = createDalvikBytecodeMoveResult1Parser('move-exception', 0x0D);
 
 type DalvikBytecodeOperationMoveException = Awaited<ReturnType<typeof dalvikBytecodeMoveExceptionParser>>;
 
@@ -1571,7 +1994,7 @@ type DalvikBytecodeOperationMoveResult1 =
 	| DalvikBytecodeOperationMoveException
 ;
 
-const dalvikBytecodeOperationMoveResult1Parser: Parser<DalvikBytecodeOperationMoveResult1, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationMoveResult1Parser: Parser<DalvikBytecodeOperationMoveResult1, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeMoveResultParser,
 	dalvikBytecodeMoveResultWideParser,
 	dalvikBytecodeMoveResultObjectParser,
@@ -1702,7 +2125,7 @@ setParserName(dalvikBytecodeOperationMoveWide16Parser, 'dalvikBytecodeOperationM
 
 const createDalvikBytecodeOperationReturn1Parser = createDalvikBytecodeMoveResult1Parser;
 
-const dalvikBytecodeOperationReturnParser = createDalvikBytecodeOperationReturn1Parser('return', 0x0f);
+const dalvikBytecodeOperationReturnParser = createDalvikBytecodeOperationReturn1Parser('return', 0x0F);
 
 type DalvikBytecodeOperationReturn = Awaited<ReturnType<typeof dalvikBytecodeOperationReturnParser>>;
 
@@ -1720,7 +2143,7 @@ type DalvikBytecodeOperationReturn1 =
 	| DalvikBytecodeOperationReturnObject
 ;
 
-const dalvikBytecodeOperationReturn1Parser: Parser<DalvikBytecodeOperationReturn1, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationReturn1Parser: Parser<DalvikBytecodeOperationReturn1, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationReturnParser,
 	dalvikBytecodeOperationReturnWideParser,
 	dalvikBytecodeOperationReturnObjectParser,
@@ -1737,20 +2160,15 @@ type DalvikBytecodeOperationConst4 = {
 const dalvikBytecodeOperationConst4Parser: Parser<DalvikBytecodeOperationConst4, Uint8Array> = promiseCompose(
 	createTupleParser([
 		createExactElementParser(0x12),
-		nibblesParser,
+		dalvikBytecodeFormat11nParser,
 	]),
 	([
 		_opcode,
-		[
-			register0,
-			value,
-		],
+		{ value, registers },
 	]) => ({
 		operation: 'const/4',
-		registers: [
-			register0,
-		],
-		value: value << 28 >> 28,
+		registers,
+		value,
 	}),
 );
 
@@ -1816,6 +2234,66 @@ const dalvikBytecodeOperationConstWide16Parser: Parser<DalvikBytecodeOperationCo
 
 setParserName(dalvikBytecodeOperationConstWide16Parser, 'dalvikBytecodeOperationConstWide16Parser');
 
+type DalvikBytecodeOperationConstWide32 = {
+	operation: 'const-wide/32';
+	registers: number[];
+	value: bigint;
+};
+
+const dalvikBytecodeOperationConstWide32Parser: Parser<DalvikBytecodeOperationConstWide32, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x17),
+		dalvikBytecodeFormat31iParser,
+	]),
+	([ _opcode, { registers, value } ]) => ({
+		operation: 'const-wide/32',
+		registers,
+		value: BigInt(value) << 32n >> 32n,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationConstWide32Parser, 'dalvikBytecodeOperationConstWide32Parser');
+
+type DalvikBytecodeOperationConstWide = {
+	operation: 'const-wide';
+	registers: number[];
+	value: bigint;
+};
+
+const dalvikBytecodeOperationConstWideParser: Parser<DalvikBytecodeOperationConstWide, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x18),
+		dalvikBytecodeFormat51lParser,
+	]),
+	([ _opcode, { registers, value } ]) => ({
+		operation: 'const-wide',
+		registers,
+		value,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationConstWideParser, 'dalvikBytecodeOperationConstWideParser');
+
+type DalvikBytecodeOperationConstWideHigh16 = {
+	operation: 'const-wide/high16';
+	registers: number[];
+	value: bigint;
+};
+
+const dalvikBytecodeOperationConstWideHigh16Parser: Parser<DalvikBytecodeOperationConstWideHigh16, Uint8Array> = promiseCompose(
+	createTupleParser([
+		createExactElementParser(0x19),
+		createDalvikBytecodeFormat21sParser(),
+	]),
+	([ _opcode, { registers, value } ]) => ({
+		operation: 'const-wide/high16',
+		registers,
+		value: BigInt(value) << 48n,
+	}),
+);
+
+setParserName(dalvikBytecodeOperationConstWideHigh16Parser, 'dalvikBytecodeOperationConstWideHigh16Parser');
+
 type DalvikBytecodeOperationConst = {
 	operation: 'const';
 	registers: number[];
@@ -1868,15 +2346,15 @@ const createDalvikBytecodeOperationCompare = <T extends string>(operation: T, op
 	}),
 );
 
-const dalvikBytecodeOperationCompareFloatWithLessThanBiasParser = createDalvikBytecodeOperationCompare('cmpl-float', 0x2d);
+const dalvikBytecodeOperationCompareFloatWithLessThanBiasParser = createDalvikBytecodeOperationCompare('cmpl-float', 0x2D);
 
 type DalvikBytecodeOperationCompareFloatWithLessThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareFloatWithLessThanBiasParser>>;
 
-const dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser = createDalvikBytecodeOperationCompare('cmpg-float', 0x2e);
+const dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser = createDalvikBytecodeOperationCompare('cmpg-float', 0x2E);
 
 type DalvikBytecodeOperationCompareFloatWithGreaterThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser>>;
 
-const dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser = createDalvikBytecodeOperationCompare('cmpl-double', 0x2f);
+const dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser = createDalvikBytecodeOperationCompare('cmpl-double', 0x2F);
 
 type DalvikBytecodeOperationCompareDoubleWithLessThanBias = Awaited<ReturnType<typeof dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser>>;
 
@@ -1896,7 +2374,7 @@ type DalvikBytecodeOperationCompare =
 	| DalvikBytecodeOperationCompareLong
 ;
 
-const dalvikBytecodeOperationCompareParser: Parser<DalvikBytecodeOperationCompare, Uint8Array> = createUnionParser([
+const dalvikBytecodeOperationCompareParser: Parser<DalvikBytecodeOperationCompare, Uint8Array> = createDisjunctionParser([
 	dalvikBytecodeOperationCompareFloatWithLessThanBiasParser,
 	dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser,
 	dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser,
@@ -1909,16 +2387,76 @@ setParserName(dalvikBytecodeOperationCompareParser, 'dalvikBytecodeOperationComp
 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
 
-	| DalvikBytecodeOperationReturnVoid
+	| DalvikBytecodeOperationArrayElement
+	| DalvikBytecodeOperationInstanceField
+	| DalvikBytecodeOperationStaticField
 
-	| DalvikBytecodeOperationMoveResult1
-;
+	| DalvikBytecodeOperationConst4
+	| DalvikBytecodeOperationConst16
+	| DalvikBytecodeOperationConstHigh16
+	| DalvikBytecodeOperationConstWide16
+	| DalvikBytecodeOperationConstWide32
+	| DalvikBytecodeOperationConstWide
+	| DalvikBytecodeOperationConstWideHigh16
+	| DalvikBytecodeOperationConst
+
+	| DalvikBytecodeOperationConstString
+	| DalvikBytecodeOperationConstStringJumbo
+	| DalvikBytecodeOperationConstMethodHandle
+	| DalvikBytecodeOperationConstClass
+
+	| DalvikBytecodeOperationMonitorEnter
+	| DalvikBytecodeOperationMonitorExit
 
+	| DalvikBytecodeOperationThrow
+
+	| DalvikBytecodeOperationCompare
+
+	| DalvikBytecodeOperationReturnVoid
+	| DalvikBytecodeOperationReturn1;
 export const dalvikBytecodeOperationCompanion = {
 	getRegisters(operation: DalvikBytecodeOperation): number[] {
 		if (operation && typeof operation === 'object' && 'registers' in operation) {
@@ -1929,73 +2467,336 @@ export const dalvikBytecodeOperationCompanion = {
 	},
 };
 
-const dalvikBytecodeOperationParser: Parser<DalvikBytecodeOperation | undefined, Uint8Array> = promiseCompose(
-	createTupleParser([
-		() => {},
-		//createDebugLogInputParser(),
-		createUnionParser<DalvikBytecodeOperation, Uint8Array>([
-			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,
+// Map of single-byte opcodes to their parsers for O(1) lookup
+const dalvikBytecodeOperationOpcodeMap = new Map<number, Parser<unknown, Uint8Array>>([
+	// Invoke operations
+	[ 0x6E, dalvikBytecodeOperationInvokeVirtualParser ],
+	[ 0x6F, dalvikBytecodeOperationInvokeSuperParser ],
+	[ 0x70, dalvikBytecodeOperationInvokeDirectParser ],
+	[ 0x71, dalvikBytecodeOperationInvokeStaticParser ],
+	[ 0x72, dalvikBytecodeOperationInvokeInterfaceParser ],
+
+	// Invoke range operations
+	[ 0x74, dalvikBytecodeOperationInvokeVirtualRangeParser ],
+	[ 0x75, dalvikBytecodeOperationInvokeSuperRangeParser ],
+	[ 0x76, dalvikBytecodeOperationInvokeDirectRangeParser ],
+	[ 0x77, dalvikBytecodeOperationInvokeStaticRangeParser ],
+	[ 0x78, dalvikBytecodeOperationInvokeInterfaceRangeParser ],
+
+	// Invoke polymorphic operations
+	[ 0xFA, dalvikBytecodeOperationInvokePolymorphicParser ],
+	[ 0xFB, dalvikBytecodeOperationInvokePolymorphicRangeParser ],
+
+	// New instance/array operations
+	[ 0x22, dalvikBytecodeOperationNewInstanceParser ],
+	[ 0x23, dalvikBytecodeOperationNewArrayParser ],
+	[ 0x24, dalvikBytecodeOperationFilledNewArrayParser ],
+	[ 0x25, dalvikBytecodeOperationFilledNewArrayRangeParser ],
+	[ 0x26, dalvikBytecodeOperationFillArrayDataParser ],
+	[ 0x1F, dalvikBytecodeOperationCheckCastParser ],
+	[ 0x20, dalvikBytecodeOperationInstanceOfParser ],
+	[ 0x21, dalvikBytecodeOperationArrayLengthParser ],
+
+	// Array element operations (aget/aput)
+	[ 0x44, dalvikBytecodeOperationArrayElementGetParser ],
+	[ 0x45, dalvikBytecodeOperationArrayElementGetWideParser ],
+	[ 0x46, dalvikBytecodeOperationArrayElementGetObjectParser ],
+	[ 0x47, dalvikBytecodeOperationArrayElementGetBooleanParser ],
+	[ 0x48, dalvikBytecodeOperationArrayElementGetByteParser ],
+	[ 0x49, dalvikBytecodeOperationArrayElementGetCharParser ],
+	[ 0x4A, dalvikBytecodeOperationArrayElementGetShortParser ],
+	[ 0x4B, dalvikBytecodeOperationArrayElementPutParser ],
+	[ 0x4C, dalvikBytecodeOperationArrayElementPutWideParser ],
+	[ 0x4D, dalvikBytecodeOperationArrayElementPutObjectParser ],
+	[ 0x4E, dalvikBytecodeOperationArrayElementPutBooleanParser ],
+	[ 0x4F, dalvikBytecodeOperationArrayElementPutByteParser ],
+	[ 0x50, dalvikBytecodeOperationArrayElementPutCharParser ],
+	[ 0x51, dalvikBytecodeOperationArrayElementPutShortParser ],
+
+	// Instance field operations (iget/iput)
+	[ 0x52, dalvikBytecodeOperationInstanceFieldGetParser ],
+	[ 0x53, dalvikBytecodeOperationInstanceFieldGetWideParser ],
+	[ 0x54, dalvikBytecodeOperationInstanceFieldGetObjectParser ],
+	[ 0x55, dalvikBytecodeOperationInstanceFieldGetBooleanParser ],
+	[ 0x56, dalvikBytecodeOperationInstanceFieldGetByteParser ],
+	[ 0x57, dalvikBytecodeOperationInstanceFieldGetCharParser ],
+	[ 0x58, dalvikBytecodeOperationInstanceFieldGetShortParser ],
+	[ 0x59, dalvikBytecodeOperationInstanceFieldPutParser ],
+	[ 0x5A, dalvikBytecodeOperationInstanceFieldPutWideParser ],
+	[ 0x5B, dalvikBytecodeOperationInstanceFieldPutObjectParser ],
+	[ 0x5C, dalvikBytecodeOperationInstanceFieldPutBooleanParser ],
+	[ 0x5D, dalvikBytecodeOperationInstanceFieldPutByteParser ],
+	[ 0x5E, dalvikBytecodeOperationInstanceFieldPutCharParser ],
+	[ 0x5F, dalvikBytecodeOperationInstanceFieldPutShortParser ],
+
+	// Static field operations (sget/sput)
+	[ 0x60, dalvikBytecodeOperationStaticFieldGetParser ],
+	[ 0x61, dalvikBytecodeOperationStaticFieldGetWideParser ],
+	[ 0x62, dalvikBytecodeOperationStaticFieldGetObjectParser ],
+	[ 0x63, dalvikBytecodeOperationStaticFieldGetBooleanParser ],
+	[ 0x64, dalvikBytecodeOperationStaticFieldGetByteParser ],
+	[ 0x65, dalvikBytecodeOperationStaticFieldGetCharParser ],
+	[ 0x66, dalvikBytecodeOperationStaticFieldGetShortParser ],
+	[ 0x67, dalvikBytecodeOperationStaticFieldPutParser ],
+	[ 0x68, dalvikBytecodeOperationStaticFieldPutWideParser ],
+	[ 0x69, dalvikBytecodeOperationStaticFieldPutObjectParser ],
+	[ 0x6A, dalvikBytecodeOperationStaticFieldPutBooleanParser ],
+	[ 0x6B, dalvikBytecodeOperationStaticFieldPutByteParser ],
+	[ 0x6C, dalvikBytecodeOperationStaticFieldPutCharParser ],
+	[ 0x6D, dalvikBytecodeOperationStaticFieldPutShortParser ],
+
+	// Const operations
+	[ 0x1A, dalvikBytecodeOperationConstStringParser ],
+	[ 0x1B, dalvikBytecodeOperationConstStringJumboParser ],
+	[ 0xFE, dalvikBytecodeOperationConstMethodHandleParser ],
+	[ 0x1C, dalvikBytecodeOperationConstClassParser ],
+
+	// Monitor operations
+	[ 0x1D, dalvikBytecodeOperationMonitorEnterParser ],
+	[ 0x1E, dalvikBytecodeOperationMonitorExitParser ],
+
+	// Return operations
+	[ 0x0E, dalvikBytecodeOperationReturnVoidParser ],
+	[ 0x0F, dalvikBytecodeOperationReturnParser ],
+	[ 0x10, dalvikBytecodeOperationReturnWideParser ],
+	[ 0x11, dalvikBytecodeOperationReturnObjectParser ],
+
+	// Throw operation
+	[ 0x27, dalvikBytecodeOperationThrowParser ],
+
+	// Goto operations
+	[ 0x28, dalvikBytecodeOperationGotoParser ],
+	[ 0x29, dalvikBytecodeOperationGoto16Parser ],
+	[ 0x2A, dalvikBytecodeOperationGoto32Parser ],
+	[ 0x2B, dalvikBytecodeOperationPackedSwitchParser ],
+	[ 0x2C, dalvikBytecodeOperationSparseSwitchParser ],
+
+	// Move result operations
+	[ 0x0A, dalvikBytecodeMoveResultParser ],
+	[ 0x0B, dalvikBytecodeMoveResultWideParser ],
+	[ 0x0C, dalvikBytecodeMoveResultObjectParser ],
+	[ 0x0D, dalvikBytecodeMoveExceptionParser ],
+
+	// Move operations
+	[ 0x01, dalvikBytecodeOperationMoveParser ],
+	[ 0x04, dalvikBytecodeOperationMoveWideParser ],
+	[ 0x07, dalvikBytecodeOperationMoveObjectParser ],
+	[ 0x02, dalvikBytecodeOperationMoveFrom16Parser ],
+	[ 0x05, dalvikBytecodeOperationMoveWideFrom16Parser ],
+	[ 0x08, dalvikBytecodeOperationMoveObjectFrom16Parser ],
+	[ 0x06, dalvikBytecodeOperationMoveWide16Parser ],
+
+	// Const value operations
+	[ 0x12, dalvikBytecodeOperationConst4Parser ],
+	[ 0x13, dalvikBytecodeOperationConst16Parser ],
+	[ 0x15, dalvikBytecodeOperationConstHigh16Parser ],
+	[ 0x16, dalvikBytecodeOperationConstWide16Parser ],
+	[ 0x17, dalvikBytecodeOperationConstWide32Parser ],
+	[ 0x18, dalvikBytecodeOperationConstWideParser ],
+	[ 0x19, dalvikBytecodeOperationConstWideHigh16Parser ],
+	[ 0x14, dalvikBytecodeOperationConstParser ],
+
+	// Compare operations
+	[ 0x2D, dalvikBytecodeOperationCompareFloatWithLessThanBiasParser ],
+	[ 0x2E, dalvikBytecodeOperationCompareFloatWithGreaterThanBiasParser ],
+	[ 0x2F, dalvikBytecodeOperationCompareDoubleWithLessThanBiasParser ],
+	[ 0x30, dalvikBytecodeOperationCompareDoubleWithGreaterThanBiasParser ],
+	[ 0x31, dalvikBytecodeOperationCompareLongParser ],
+
+	// If test operations
+	[ 0x32, dalvikBytecodeIfEqualParser ],
+	[ 0x33, dalvikBytecodeIfNotEqualParser ],
+	[ 0x34, dalvikBytecodeIfLessThanParser ],
+	[ 0x35, dalvikBytecodeIfGreaterThanOrEqualToParser ],
+	[ 0x36, dalvikBytecodeIfGreaterThanParser ],
+	[ 0x37, dalvikBytecodeIfLessThanOrEqualToParser ],
+
+	// If test zero operations
+	[ 0x38, dalvikBytecodeIfEqualZeroParser ],
+	[ 0x39, dalvikBytecodeIfNotEqualZeroParser ],
+	[ 0x3A, dalvikBytecodeIfLessThanZeroParser ],
+	[ 0x3B, dalvikBytecodeIfGreaterThanOrEqualToZeroParser ],
+	[ 0x3C, dalvikBytecodeIfGreaterThanZeroParser ],
+	[ 0x3D, dalvikBytecodeIfLessThanOrEqualToZeroParser ],
+
+	// Binary operations
+	[ 0x90, dalvikBytecodeOperationAddIntParser ],
+	[ 0x91, dalvikBytecodeOperationSubtractIntParser ],
+	[ 0x92, dalvikBytecodeOperationMultiplyIntParser ],
+	[ 0x93, dalvikBytecodeOperationDivideIntParser ],
+	[ 0x94, dalvikBytecodeOperationRemainderIntParser ],
+	[ 0x95, dalvikBytecodeOperationAndIntParser ],
+	[ 0x96, dalvikBytecodeOperationOrIntParser ],
+	[ 0x97, dalvikBytecodeOperationXorIntParser ],
+	[ 0x98, dalvikBytecodeOperationShiftLeftIntParser ],
+	[ 0x99, dalvikBytecodeOperationShiftRightIntParser ],
+	[ 0x9A, dalvikBytecodeOperationUnsignedShiftRightIntParser ],
+	[ 0x9B, dalvikBytecodeOperationAddLongParser ],
+	[ 0x9C, dalvikBytecodeOperationSubtractLongParser ],
+	[ 0x9D, dalvikBytecodeOperationMultiplyLongParser ],
+	[ 0x9E, dalvikBytecodeOperationDivideLongParser ],
+	[ 0x9F, dalvikBytecodeOperationRemainderLongParser ],
+	[ 0xA0, dalvikBytecodeOperationAndLongParser ],
+	[ 0xA1, dalvikBytecodeOperationOrLongParser ],
+	[ 0xA2, dalvikBytecodeOperationXorLongParser ],
+	[ 0xA3, dalvikBytecodeOperationShiftLeftLongParser ],
+	[ 0xA4, dalvikBytecodeOperationShiftRightLongParser ],
+	[ 0xA5, dalvikBytecodeOperationUnsignedShiftRightLongParser ],
+	[ 0xA6, dalvikBytecodeOperationAddFloatParser ],
+	[ 0xA7, dalvikBytecodeOperationSubtractFloatParser ],
+	[ 0xA8, dalvikBytecodeOperationMultiplyFloatParser ],
+	[ 0xA9, dalvikBytecodeOperationDivideFloatParser ],
+	// Note: 0xAA (rem-float) parser is missing in codebase
+	[ 0xAB, dalvikBytecodeOperationAddDoubleParser ],
+	[ 0xAC, dalvikBytecodeOperationSubtractDoubleParser ],
+	[ 0xAD, dalvikBytecodeOperationMultiplyDoubleParser ],
+	[ 0xAE, dalvikBytecodeOperationDivideDoubleParser ],
+	[ 0xAF, dalvikBytecodeOperationRemainderDoubleParser ],
+
+	// Binary operations in place (2addr)
+	[ 0xB0, dalvikBytecodeOperationAddIntInPlaceParser ],
+	[ 0xB1, dalvikBytecodeOperationReverseSubtractIntInPlaceParser ],
+	[ 0xB2, dalvikBytecodeOperationMultiplyIntInPlaceParser ],
+	[ 0xB3, dalvikBytecodeOperationDivideIntInPlaceParser ],
+	[ 0xB4, dalvikBytecodeOperationRemainderIntInPlaceParser ],
+	[ 0xB5, dalvikBytecodeOperationAndIntInPlaceParser ],
+	[ 0xB6, dalvikBytecodeOperationOrIntInPlaceParser ],
+	[ 0xB7, dalvikBytecodeOperationXorIntInPlaceParser ],
+	[ 0xB8, dalvikBytecodeOperationShiftLeftIntInPlaceParser ],
+	[ 0xB9, dalvikBytecodeOperationShiftRightIntInPlaceParser ],
+	[ 0xBA, dalvikBytecodeOperationUnsignedShiftRightIntInPlaceParser ],
+	[ 0xBB, dalvikBytecodeOperationAddLongInPlaceParser ],
+	[ 0xBC, dalvikBytecodeOperationSubtractLongInPlaceParser ],
+	[ 0xBD, dalvikBytecodeOperationMultiplyLongInPlaceParser ],
+	[ 0xBE, dalvikBytecodeOperationDivideLongInPlaceParser ],
+	[ 0xBF, dalvikBytecodeOperationRemainderLongInPlaceParser ],
+	[ 0xC0, dalvikBytecodeOperationAndLongInPlaceParser ],
+	[ 0xC1, dalvikBytecodeOperationOrLongInPlaceParser ],
+	[ 0xC2, dalvikBytecodeOperationXorLongInPlaceParser ],
+	[ 0xC3, dalvikBytecodeOperationShiftLeftLongInPlaceParser ],
+	[ 0xC4, dalvikBytecodeOperationShiftRightLongInPlaceParser ],
+	[ 0xC5, dalvikBytecodeOperationUnsignedShiftRightLongInPlaceParser ],
+	[ 0xC6, dalvikBytecodeOperationAddFloatInPlaceParser ],
+	[ 0xC7, dalvikBytecodeOperationSubtractFloatInPlaceParser ],
+	[ 0xC8, dalvikBytecodeOperationMultiplyFloatInPlaceParser ],
+	[ 0xC9, dalvikBytecodeOperationDivideFloatInPlaceParser ],
+	[ 0xCA, dalvikBytecodeOperationRemainderFloatInPlaceParser ],
+	[ 0xCB, dalvikBytecodeOperationAddDoubleInPlaceParser ],
+	[ 0xCC, dalvikBytecodeOperationSubtractDoubleInPlaceParser ],
+	[ 0xCD, dalvikBytecodeOperationMultiplyDoubleInPlaceParser ],
+	[ 0xCE, dalvikBytecodeOperationDivideDoubleInPlaceParser ],
+	[ 0xCF, dalvikBytecodeOperationRemainderDoubleInPlaceParser ],
+
+	// Binary operations with literal16
+	[ 0xD0, dalvikBytecodeOperationAddIntLiteral16Parser ],
+	[ 0xD1, dalvikBytecodeOperationReverseSubtractIntLiteral16Parser ],
+	[ 0xD2, dalvikBytecodeOperationMultiplyIntLiteral16Parser ],
+	[ 0xD3, dalvikBytecodeOperationDivideIntLiteral16Parser ],
+	[ 0xD4, dalvikBytecodeOperationRemainderIntLiteral16Parser ],
+	[ 0xD5, dalvikBytecodeOperationAndIntLiteral16Parser ],
+	[ 0xD6, dalvikBytecodeOperationOrIntLiteral16Parser ],
+	[ 0xD7, dalvikBytecodeOperationXorIntLiteral16Parser ],
+
+	// Binary operations with literal8
+	[ 0xD8, dalvikBytecodeOperationAddIntLiteral8Parser ],
+	[ 0xD9, dalvikBytecodeOperationReverseSubtractIntLiteral8Parser ],
+	[ 0xDA, dalvikBytecodeOperationMultiplyIntLiteral8Parser ],
+	[ 0xDB, dalvikBytecodeOperationDivideIntLiteral8Parser ],
+	[ 0xDC, dalvikBytecodeOperationRemainderIntLiteral8Parser ],
+	[ 0xDD, dalvikBytecodeOperationAndIntLiteral8Parser ],
+	[ 0xDE, dalvikBytecodeOperationOrIntLiteral8Parser ],
+	[ 0xDF, dalvikBytecodeOperationXorIntLiteral8Parser ],
+	[ 0xE0, dalvikBytecodeOperationShiftLeftIntLiteral8Parser ],
+	[ 0xE1, dalvikBytecodeOperationShiftRightIntLiteral8Parser ],
+	[ 0xE2, dalvikBytecodeOperationUnsignedShiftRightIntLiteral8Parser ],
+
+	// Unary operations
+	[ 0x7B, dalvikBytecodeOperationNegateIntParser ],
+	[ 0x7C, dalvikBytecodeOperationNotIntParser ],
+	[ 0x7D, dalvikBytecodeOperationNegateLongParser ],
+	[ 0x7E, dalvikBytecodeOperationNotLongParser ],
+	[ 0x7F, dalvikBytecodeOperationNegateFloatParser ],
+	[ 0x80, dalvikBytecodeOperationNegateDoubleParser ],
+	[ 0x81, dalvikBytecodeOperationIntToLongParser ],
+	[ 0x82, dalvikBytecodeOperationIntToFloatParser ],
+	[ 0x83, dalvikBytecodeOperationIntToDoubleParser ],
+	[ 0x84, dalvikBytecodeOperationLongToIntParser ],
+	[ 0x85, dalvikBytecodeOperationLongToFloatParser ],
+	[ 0x86, dalvikBytecodeOperationLongToDoubleParser ],
+	[ 0x87, dalvikBytecodeOperationFloatToIntParser ],
+	[ 0x88, dalvikBytecodeOperationFloatToLongParser ],
+	[ 0x89, dalvikBytecodeOperationFloatToDoubleParser ],
+	[ 0x8A, dalvikBytecodeOperationDoubleToIntParser ],
+	[ 0x8B, dalvikBytecodeOperationDoubleToLongParser ],
+	[ 0x8C, dalvikBytecodeOperationDoubleToFloatParser ],
+	[ 0x8D, dalvikBytecodeOperationIntToByteParser ],
+	[ 0x8E, dalvikBytecodeOperationIntToCharParser ],
+	[ 0x8F, dalvikBytecodeOperationIntToShortParser ],
+
+	// Unused opcodes
+	// Range 0x3E-0x43
+	[ 0x3E, dalvikBytecodeOperationUnusedParser ],
+	[ 0x3F, dalvikBytecodeOperationUnusedParser ],
+	[ 0x40, dalvikBytecodeOperationUnusedParser ],
+	[ 0x41, dalvikBytecodeOperationUnusedParser ],
+	[ 0x42, dalvikBytecodeOperationUnusedParser ],
+	[ 0x43, dalvikBytecodeOperationUnusedParser ],
+	// 0x73
+	[ 0x73, dalvikBytecodeOperationUnusedParser ],
+	// Range 0x79-0x7A
+	[ 0x79, dalvikBytecodeOperationUnusedParser ],
+	[ 0x7A, dalvikBytecodeOperationUnusedParser ],
+	// Range 0xE3-0xF9
+	[ 0xE3, dalvikBytecodeOperationUnusedParser ],
+	[ 0xE4, dalvikBytecodeOperationUnusedParser ],
+	[ 0xE5, dalvikBytecodeOperationUnusedParser ],
+	[ 0xE6, dalvikBytecodeOperationUnusedParser ],
+	[ 0xE7, dalvikBytecodeOperationUnusedParser ],
+	[ 0xE8, dalvikBytecodeOperationUnusedParser ],
+	[ 0xE9, dalvikBytecodeOperationUnusedParser ],
+	[ 0xEA, dalvikBytecodeOperationUnusedParser ],
+	[ 0xEB, dalvikBytecodeOperationUnusedParser ],
+	[ 0xEC, dalvikBytecodeOperationUnusedParser ],
+	[ 0xED, dalvikBytecodeOperationUnusedParser ],
+	[ 0xEE, dalvikBytecodeOperationUnusedParser ],
+	[ 0xEF, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF0, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF1, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF2, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF3, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF4, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF5, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF6, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF7, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF8, dalvikBytecodeOperationUnusedParser ],
+	[ 0xF9, dalvikBytecodeOperationUnusedParser ],
+]);
 
-			dalvikBytecodeOperationCompareParser,
+// Fallback parser for multi-byte opcodes (nop and payload instructions)
+const dalvikBytecodeOperationMultiByteParser: Parser<DalvikBytecodeOperation, Uint8Array> = createDisjunctionParser([
+	dalvikBytecodeOperationNoOperationParser,
+	dalvikBytecodeOperationPackedSwitchPayloadParser,
+	dalvikBytecodeOperationSparseSwitchPayloadParser,
+	dalvikBytecodeOperationFillArrayDataPayloadParser,
+]);
 
-			dalvikBytecodeOperationIfTestParser,
-			dalvikBytecodeOperationIfTestZeroParser,
+setParserName(dalvikBytecodeOperationMultiByteParser, 'dalvikBytecodeOperationMultiByteParser');
 
-			dalvikBytecodeOperationBinaryOperationParser,
-			dalvikBytecodeOperationBinaryOperationLiteral8Parser,
-			dalvikBytecodeOperationBinaryOperationLiteral16Parser,
-			dalvikBytecodeOperationBinaryOperationInPlaceParser,
-			dalvikBytecodeOperationUnaryOperationParser,
-		]),
+const dalvikBytecodeOperationParser: Parser<DalvikBytecodeOperation | undefined, Uint8Array> = promiseCompose(
+	createTupleParser([
+		() => {},
+		// CreateDebugLogInputParser(),
+		createElementSwitchParser<DalvikBytecodeOperation, Uint8Array>(
+			dalvikBytecodeOperationOpcodeMap,
+			dalvikBytecodeOperationMultiByteParser,
+		),
 	]),
 	([
 		_debug,
 		operation,
-	]) => {
-		// console.log(operation);
-		return operation;
-	},
+	]) =>
+		// Console.log(operation);
+		operation,
 );
 
 setParserName(dalvikBytecodeOperationParser, 'dalvikBytecodeOperationParser');
@@ -2003,9 +2804,7 @@ setParserName(dalvikBytecodeOperationParser, 'dalvikBytecodeOperationParser');
 export type DalvikBytecode = DalvikBytecodeOperation[];
 
 const dalvikBytecodeParser: Parser<DalvikBytecode, Uint8Array> = promiseCompose(
-	createArrayParser(
-		dalvikBytecodeOperationParser,
-	),
+	createArrayParser(dalvikBytecodeOperationParser),
 	operations => operations.filter((operation): operation is DalvikBytecodeOperation => operation !== undefined),
 );
 
@@ -2014,12 +2813,12 @@ export const createDalvikBytecodeParser = (size: number): Parser<DalvikBytecode,
 type ResolvedDalvikBytecodeOperation<T extends DalvikBytecodeOperation> = T extends { stringIndex: IndexIntoFieldIds }
 	? Omit<T, 'stringIndex'> & { string: string }
 	: T extends { typeIndex: IndexIntoTypeIds }
-	? Omit<T, 'typeIndex'> & { type: string }
-	: T extends { methodIndex: IndexIntoMethodIds }
-	? Omit<T, 'methodIndex'> & { method: DalvikExecutableMethod }
-	: T extends { fieldIndex: IndexIntoFieldIds }
-	? Omit<T, 'fieldIndex'> & { field: DalvikExecutableField }
-	: T;
+		? Omit<T, 'typeIndex'> & { type: string }
+		: T extends { methodIndex: IndexIntoMethodIds }
+			? Omit<T, 'methodIndex'> & { method: DalvikExecutableMethod }
+			: T extends { fieldIndex: IndexIntoFieldIds }
+				? Omit<T, 'fieldIndex'> & { field: DalvikExecutableField }
+				: T;
 
 export type DalvikBytecodeOperationResolvers = {
 	resolveIndexIntoStringIds: (index: IndexIntoStringIds) => string;
@@ -2039,7 +2838,7 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 
 		return {
 			...rest,
-			string: resolveIndexIntoStringIds(stringIndex as IndexIntoStringIds),
+			string: resolveIndexIntoStringIds(stringIndex),
 		} as ResolvedDalvikBytecodeOperation<T>;
 	}
 
@@ -2048,7 +2847,7 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 
 		return {
 			...rest,
-			type: resolveIndexIntoTypeIds(typeIndex as IndexIntoTypeIds),
+			type: resolveIndexIntoTypeIds(typeIndex),
 		} as ResolvedDalvikBytecodeOperation<T>;
 	}
 
@@ -2057,7 +2856,7 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 
 		return {
 			...rest,
-			method: resolveIndexIntoMethodIds(methodIndex as IndexIntoMethodIds),
+			method: resolveIndexIntoMethodIds(methodIndex),
 		} as ResolvedDalvikBytecodeOperation<T>;
 	}
 
@@ -2066,7 +2865,7 @@ export function resolveDalvikBytecodeOperation<T extends DalvikBytecodeOperation
 
 		return {
 			...rest,
-			field: resolveIndexIntoFieldIds(fieldIndex as IndexIntoFieldIds),
+			field: resolveIndexIntoFieldIds(fieldIndex),
 		} as ResolvedDalvikBytecodeOperation<T>;
 	}