Refactor ILs for greater speed and utility

1 files changed, 1914 insertions, 452 deletions

diff --git a/python/mediumlevelil.py b/python/mediumlevelil.py
index 6d038da0..dd219095 100644
--- a/python/mediumlevelil.py
+++ b/python/mediumlevelil.py
@@ -20,7 +20,8 @@
 
 import ctypes
 import struct
-from typing import Optional, List, Any, Union, Mapping, Generator, NewType
+from typing import Optional, List, Union, Mapping, Generator, NewType, Tuple
+from dataclasses import dataclass
 
 # Binary Ninja components
 from . import _binaryninjacore as core
@@ -40,44 +41,28 @@ ExpressionIndex = NewType('ExpressionIndex', int)
 InstructionIndex = NewType('InstructionIndex', int)
 MLILInstructionsType = Generator['MediumLevelILInstruction', None, None]
 MLILBasicBlocksType = Generator['MediumLevelILBasicBlock', None, None]
+OperandsType = Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex]
+MediumLevelILOperandType = Union[
+		int,
+		float,
+		'MediumLevelILOperationAndSize',
+		'MediumLevelILInstruction',
+		'lowlevelil.ILIntrinsic',
+		'variable.Variable',
+		'SSAVariable',
+		List[int],
+		List['SSAVariable'],
+		List['MediumLevelILInstruction'],
+		Mapping[int, int]
+	]
 
-
+@dataclass(frozen=True, repr=False)
 class SSAVariable:
-	def __init__(self, var:'variable.Variable', version:int):
-		self._var = var
-		self._version = version
+	var:'variable.Variable'
+	version:int
 
 	def __repr__(self):
-		return "<ssa %s version %d>" % (repr(self._var), self._version)
-
-	def __eq__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return (self._var, self._version) == (other.var, other.version)
-
-	def __ne__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return not (self == other)
-
-	def __hash__(self):
-		return hash((self._var, self._version))
-
-	@property
-	def var(self) -> 'variable.Variable':
-		return self._var
-
-	@var.setter
-	def var(self, value:'variable.Variable') -> None:
-		self._var = value
-
-	@property
-	def version(self) -> int:
-		return self._version
-
-	@version.setter
-	def version(self, value=int) -> None:
-		self._version = value
+		return f"<ssa {repr(self.var)} version {self.version}>"
 
 
 class MediumLevelILLabel:
@@ -89,40 +74,33 @@ class MediumLevelILLabel:
 			self.handle = handle
 
 
+@dataclass(frozen=True, repr=False)
 class MediumLevelILOperationAndSize:
-	def __init__(self, operation:MediumLevelILOperation, size:int):
-		self._operation = operation
-		self._size = size
+	operation:MediumLevelILOperation
+	size:int
 
 	def __repr__(self):
-		if self._size == 0:
-			return "<%s>" % self._operation.name
-		return "<%s %d>" % (self._operation.name, self._size)
+		if self.size == 0:
+			return f"<{self.operation.name}>"
+		return f"<{self.operation.name} {self.size}>"
 
-	def __eq__(self, other):
-		if isinstance(other, MediumLevelILOperation):
-			return other == self._operation
-		if isinstance(other, self.__class__):
-			return (other.size, other.operation) == (self._size, self._operation)
-		return NotImplemented
-
-	def __ne__(self, other):
-		if isinstance(other, MediumLevelILOperation) or isinstance(other, self.__class__):
-			return not (self == other)
-		return NotImplemented
 
-	def __hash__(self):
-		return hash((self._operation, self._size))
+@dataclass(frozen=True)
+class CoreMediumLevelILInstruction:
+	operation:MediumLevelILOperation
+	source_operand:int
+	size:int
+	operands:OperandsType
+	address:int
 
-	@property
-	def operation(self) -> MediumLevelILOperation:
-		return self._operation
 
-	@property
-	def size(self) -> int:
-		return self._size
+	@classmethod
+	def from_BNMediumLevelILInstruction(cls, instr:core.BNMediumLevelILInstruction) -> 'CoreMediumLevelILInstruction':
+		operands:OperandsType = tuple([ExpressionIndex(instr.operands[i]) for i in range(5)])  # type: ignore
+		return cls(MediumLevelILOperation(instr.operation), instr.sourceOperand, instr.size, operands, instr.address)
 
 
+@dataclass(frozen=True)
 class MediumLevelILInstruction:
 	"""
 	``class MediumLevelILInstruction`` Medium Level Intermediate Language Instructions are infinite length tree-based
@@ -130,241 +108,22 @@ class MediumLevelILInstruction:
 	Infix notation is thus more natural to read than other notations (e.g. x86 ``mov eax, 0`` vs. MLIL ``eax = 0``).
 	"""
 
-	ILOperations = {
-		MediumLevelILOperation.MLIL_NOP: [],
-		MediumLevelILOperation.MLIL_SET_VAR: [("dest", "var"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_FIELD: [("dest", "var"), ("offset", "int"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_SPLIT: [("high", "var"), ("low", "var"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_LOAD: [("src", "expr")],
-		MediumLevelILOperation.MLIL_LOAD_STRUCT: [("src", "expr"), ("offset", "int")],
-		MediumLevelILOperation.MLIL_STORE: [("dest", "expr"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_STORE_STRUCT: [("dest", "expr"), ("offset", "int"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_VAR: [("src", "var")],
-		MediumLevelILOperation.MLIL_VAR_FIELD: [("src", "var"), ("offset", "int")],
-		MediumLevelILOperation.MLIL_VAR_SPLIT: [("high", "var"), ("low", "var")],
-		MediumLevelILOperation.MLIL_ADDRESS_OF: [("src", "var")],
-		MediumLevelILOperation.MLIL_ADDRESS_OF_FIELD: [("src", "var"), ("offset", "int")],
-		MediumLevelILOperation.MLIL_CONST: [("constant", "int")],
-		MediumLevelILOperation.MLIL_CONST_PTR: [("constant", "int")],
-		MediumLevelILOperation.MLIL_EXTERN_PTR: [("constant", "int"), ("offset", "int")],
-		MediumLevelILOperation.MLIL_FLOAT_CONST: [("constant", "float")],
-		MediumLevelILOperation.MLIL_IMPORT: [("constant", "int")],
-		MediumLevelILOperation.MLIL_ADD: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_ADC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		MediumLevelILOperation.MLIL_SUB: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_SBB: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		MediumLevelILOperation.MLIL_AND: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_OR: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_XOR: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_LSL: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_LSR: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_ASR: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_ROL: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_RLC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		MediumLevelILOperation.MLIL_ROR: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_RRC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		MediumLevelILOperation.MLIL_MUL: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_MULU_DP: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_MULS_DP: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_DIVU: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_DIVU_DP: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_DIVS: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_DIVS_DP: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_MODU: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_MODU_DP: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_MODS: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_MODS_DP: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_NEG: [("src", "expr")],
-		MediumLevelILOperation.MLIL_NOT: [("src", "expr")],
-		MediumLevelILOperation.MLIL_SX: [("src", "expr")],
-		MediumLevelILOperation.MLIL_ZX: [("src", "expr")],
-		MediumLevelILOperation.MLIL_LOW_PART: [("src", "expr")],
-		MediumLevelILOperation.MLIL_JUMP: [("dest", "expr")],
-		MediumLevelILOperation.MLIL_JUMP_TO: [("dest", "expr"), ("targets", "target_map")],
-		MediumLevelILOperation.MLIL_RET_HINT: [("dest", "expr")],
-		MediumLevelILOperation.MLIL_CALL: [("output", "var_list"), ("dest", "expr"), ("params", "expr_list")],
-		MediumLevelILOperation.MLIL_CALL_UNTYPED: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
-		MediumLevelILOperation.MLIL_CALL_OUTPUT: [("dest", "var_list")],
-		MediumLevelILOperation.MLIL_CALL_PARAM: [("src", "var_list")],
-		MediumLevelILOperation.MLIL_RET: [("src", "expr_list")],
-		MediumLevelILOperation.MLIL_NORET: [],
-		MediumLevelILOperation.MLIL_IF: [("condition", "expr"), ("true", "int"), ("false", "int")],
-		MediumLevelILOperation.MLIL_GOTO: [("dest", "int")],
-		MediumLevelILOperation.MLIL_CMP_E: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_NE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_SLT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_ULT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_SLE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_ULE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_SGE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_UGE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_SGT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_CMP_UGT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_TEST_BIT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_BOOL_TO_INT: [("src", "expr")],
-		MediumLevelILOperation.MLIL_ADD_OVERFLOW: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_SYSCALL: [("output", "var_list"), ("params", "expr_list")],
-		MediumLevelILOperation.MLIL_SYSCALL_UNTYPED: [("output", "expr"), ("params", "expr"), ("stack", "expr")],
-		MediumLevelILOperation.MLIL_TAILCALL: [("output", "var_list"), ("dest", "expr"), ("params", "expr_list")],
-		MediumLevelILOperation.MLIL_TAILCALL_UNTYPED: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
-		MediumLevelILOperation.MLIL_BP: [],
-		MediumLevelILOperation.MLIL_TRAP: [("vector", "int")],
-		MediumLevelILOperation.MLIL_INTRINSIC: [("output", "var_list"), ("intrinsic", "intrinsic"), ("params", "expr_list")],
-		MediumLevelILOperation.MLIL_INTRINSIC_SSA: [("output", "var_ssa_list"), ("intrinsic", "intrinsic"), ("params", "expr_list")],
-		MediumLevelILOperation.MLIL_FREE_VAR_SLOT: [("dest", "var")],
-		MediumLevelILOperation.MLIL_FREE_VAR_SLOT_SSA: [("prev", "var_ssa_dest_and_src")],
-		MediumLevelILOperation.MLIL_UNDEF: [],
-		MediumLevelILOperation.MLIL_UNIMPL: [],
-		MediumLevelILOperation.MLIL_UNIMPL_MEM: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FADD: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FSUB: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FMUL: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FDIV: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FSQRT: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FNEG: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FABS: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FLOAT_TO_INT: [("src", "expr")],
-		MediumLevelILOperation.MLIL_INT_TO_FLOAT: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FLOAT_CONV: [("src", "expr")],
-		MediumLevelILOperation.MLIL_ROUND_TO_INT: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FLOOR: [("src", "expr")],
-		MediumLevelILOperation.MLIL_CEIL: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FTRUNC: [("src", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_E: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_NE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_LT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_LE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_GE: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_GT: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_O: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_FCMP_UO: [("left", "expr"), ("right", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_SSA: [("dest", "var_ssa"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD: [("prev", "var_ssa_dest_and_src"), ("offset", "int"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA: [("high", "var_ssa"), ("low", "var_ssa"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_ALIASED: [("prev", "var_ssa_dest_and_src"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD: [("prev", "var_ssa_dest_and_src"), ("offset", "int"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_VAR_SSA: [("src", "var_ssa")],
-		MediumLevelILOperation.MLIL_VAR_SSA_FIELD: [("src", "var_ssa"), ("offset", "int")],
-		MediumLevelILOperation.MLIL_VAR_ALIASED: [("src", "var_ssa")],
-		MediumLevelILOperation.MLIL_VAR_ALIASED_FIELD: [("src", "var_ssa"), ("offset", "int")],
-		MediumLevelILOperation.MLIL_VAR_SPLIT_SSA: [("high", "var_ssa"), ("low", "var_ssa")],
-		MediumLevelILOperation.MLIL_CALL_SSA: [("output", "expr"), ("dest", "expr"), ("params", "expr_list"), ("src_memory", "int")],
-		MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
-		MediumLevelILOperation.MLIL_SYSCALL_SSA: [("output", "expr"), ("params", "expr_list"), ("src_memory", "int")],
-		MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA: [("output", "expr"), ("params", "expr"), ("stack", "expr")],
-		MediumLevelILOperation.MLIL_TAILCALL_SSA: [("output", "expr"), ("dest", "expr"), ("params", "expr_list"), ("src_memory", "int")],
-		MediumLevelILOperation.MLIL_TAILCALL_UNTYPED_SSA: [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
-		MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA: [("dest_memory", "int"), ("dest", "var_ssa_list")],
-		MediumLevelILOperation.MLIL_CALL_PARAM_SSA: [("src_memory", "int"), ("src", "var_ssa_list")],
-		MediumLevelILOperation.MLIL_LOAD_SSA: [("src", "expr"), ("src_memory", "int")],
-		MediumLevelILOperation.MLIL_LOAD_STRUCT_SSA: [("src", "expr"), ("offset", "int"), ("src_memory", "int")],
-		MediumLevelILOperation.MLIL_STORE_SSA: [("dest", "expr"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_STORE_STRUCT_SSA: [("dest", "expr"), ("offset", "int"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
-		MediumLevelILOperation.MLIL_VAR_PHI: [("dest", "var_ssa"), ("src", "var_ssa_list")],
-		MediumLevelILOperation.MLIL_MEM_PHI: [("dest_memory", "int"), ("src_memory", "int_list")]
-	}
+	function:'MediumLevelILFunction'
+	expr_index:ExpressionIndex
+	instr:CoreMediumLevelILInstruction
+	instr_index:InstructionIndex
+	operand_names = tuple()
 
-	def __init__(self, func:'MediumLevelILFunction', expr_index:ExpressionIndex, instr_index:InstructionIndex=None):
-		instr = core.BNGetMediumLevelILByIndex(func.handle, expr_index)
-		self._function = func
-		self._expr_index = expr_index
+	@classmethod
+	def create(cls, func:'MediumLevelILFunction', expr_index:ExpressionIndex, instr_index:Optional[InstructionIndex]=None) -> 'MediumLevelILInstruction':
+		assert func.arch is not None, "Attempted to create IL instruction with function missing an Architecture"
+		inst = core.BNGetMediumLevelILByIndex(func.handle, expr_index)
+		assert inst is not None, "core.BNGetMediumLevelILByIndex returned None"
 		if instr_index is None:
-			self._instr_index = core.BNGetMediumLevelILInstructionForExpr(func.handle, expr_index)
-		else:
-			self._instr_index = instr_index
-		self._operation = MediumLevelILOperation(instr.operation)
-		self._size = instr.size
-		self._address = instr.address
-		self._source_operand = instr.sourceOperand
-		operands = MediumLevelILInstruction.ILOperations[instr.operation]
-		self._operands:List[Any] = []
-		i = 0
-		for operand in operands:
-			name, operand_type = operand
-			value = None
-			if operand_type == "int":
-				value = instr.operands[i]
-				value = (value & ((1 << 63) - 1)) - (value & (1 << 63))
-			elif operand_type == "float":
-				if instr.size == 4:
-					value = struct.unpack("f", struct.pack("I", instr.operands[i] & 0xffffffff))[0]
-				elif instr.size == 8:
-					value = struct.unpack("d", struct.pack("Q", instr.operands[i]))[0]
-				else:
-					value = instr.operands[i]
-			elif operand_type == "expr":
-				value = MediumLevelILInstruction(func, instr.operands[i])
-			elif operand_type == "intrinsic":
-				assert func.arch is not None, "Attempting to create ILInstrinsice from function with no Architecture"
-				value = lowlevelil.ILIntrinsic(func.arch, instr.operands[i])
-			elif operand_type == "var":
-				value = variable.Variable.from_identifier(self._function.source_function, instr.operands[i])
-			elif operand_type == "var_ssa":
-				var = variable.Variable.from_identifier(self._function.source_function, instr.operands[i])
-				version = instr.operands[i + 1]
-				i += 1
-				value = SSAVariable(var, version)
-			elif operand_type == "var_ssa_dest_and_src":
-				var = variable.Variable.from_identifier(self._function.source_function, instr.operands[i])
-				dest_version = instr.operands[i + 1]
-				src_version = instr.operands[i + 2]
-				i += 2
-				self._operands.append(SSAVariable(var, dest_version))
-				#TODO: documentation for dest
-				self.dest = SSAVariable(var, dest_version)
-				value = SSAVariable(var, src_version)
-			elif operand_type == "int_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
-				value = []
-				for j in range(count.value):
-					value.append(operand_list[j])
-				core.BNMediumLevelILFreeOperandList(operand_list)
-			elif operand_type == "var_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value):
-					value.append(variable.Variable.from_identifier(self._function.source_function, operand_list[j]))
-				core.BNMediumLevelILFreeOperandList(operand_list)
-			elif operand_type == "var_ssa_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value // 2):
-					var_id = operand_list[j * 2]
-					var_version = operand_list[(j * 2) + 1]
-					value.append(SSAVariable(variable.Variable.from_identifier(self._function.source_function,
-						var_id), var_version))
-				core.BNMediumLevelILFreeOperandList(operand_list)
-			elif operand_type == "expr_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value):
-					value.append(MediumLevelILInstruction(func, operand_list[j]))
-				core.BNMediumLevelILFreeOperandList(operand_list)
-			elif operand_type == "target_map":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNMediumLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
-				i += 1
-				value = {}
-				for j in range(count.value // 2):
-					key = operand_list[j * 2]
-					target = operand_list[(j * 2) + 1]
-					value[key] = target
-				core.BNMediumLevelILFreeOperandList(operand_list)
-			self._operands.append(value)
-			self.__dict__[name] = value
-			i += 1
+			instr_index = core.BNGetMediumLevelILInstructionForExpr(func.handle, expr_index)
+			assert instr_index is not None, "core.BNGetMediumLevelILInstructionForExpr returned None"
+		instr = CoreMediumLevelILInstruction.from_BNMediumLevelILInstruction(inst)
+		return ILInstruction[instr.operation](func, expr_index, instr, instr_index)  # type: ignore
 
 	def __str__(self):
 		tokens = self.tokens
@@ -381,46 +140,46 @@ class MediumLevelILInstruction:
 	def __eq__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return self._function == other.function and self._expr_index == other.expr_index
+		return self.function == other.function and self.expr_index == other.expr_index
 
 	def __lt__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return self._function == other.function and self.expr_index < other.expr_index
+		return self.function == other.function and self.expr_index < other.expr_index
 
 	def __le__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return self._function == other.function and self.expr_index <= other.expr_index
+		return self.function == other.function and self.expr_index <= other.expr_index
 
 	def __gt__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return self._function == other.function and self.expr_index > other.expr_index
+		return self.function == other.function and self.expr_index > other.expr_index
 
 	def __ge__(self, other:'MediumLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return self._function == other.function and self.expr_index >= other.expr_index
+		return self.function == other.function and self.expr_index >= other.expr_index
 
 	def __hash__(self):
-		return hash((self._instr_index, self._function))
+		return hash((self.function, self.expr_index))
 
 	@property
 	def tokens(self) -> OptionalTokens:
 		"""MLIL tokens (read-only)"""
 		count = ctypes.c_ulonglong()
 		tokens = ctypes.POINTER(core.BNInstructionTextToken)()
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Attempting to get tokens for MLIL Function with no Architecture set")
-		if ((self._instr_index is not None) and (self._function.source_function is not None) and
-			(self._expr_index == core.BNGetMediumLevelILIndexForInstruction(self._function.handle, self._instr_index))):
-			if not core.BNGetMediumLevelILInstructionText(self._function.handle, self._function.source_function.handle,
-				self._function.arch.handle, self._instr_index, tokens, count, None):
+		if ((self.instr_index is not None) and (self.function.source_function is not None) and
+			(self.expr_index == core.BNGetMediumLevelILIndexForInstruction(self.function.handle, self.instr_index))):
+			if not core.BNGetMediumLevelILInstructionText(self.function.handle, self.function.source_function.handle,
+				self.function.arch.handle, self.instr_index, tokens, count, None):
 				return None
 		else:
-			if not core.BNGetMediumLevelILExprText(self._function.handle, self._function.arch.handle,
-				self._expr_index, tokens, count, None):
+			if not core.BNGetMediumLevelILExprText(self.function.handle, self.function.arch.handle,
+				self.expr_index, tokens, count, None):
 				return None
 		result = function.InstructionTextToken._from_core_struct(tokens, count.value)
 		core.BNFreeInstructionText(tokens, count.value)
@@ -429,39 +188,39 @@ class MediumLevelILInstruction:
 	@property
 	def il_basic_block(self) -> 'MediumLevelILBasicBlock':
 		"""IL basic block object containing this expression (read-only) (only available on finalized functions)"""
-		core_block = core.BNGetMediumLevelILBasicBlockForInstruction(self._function.handle, self._instr_index)
+		core_block = core.BNGetMediumLevelILBasicBlockForInstruction(self.function.handle, self.instr_index)
 		assert core_block is not None
-		assert self._function.source_function is not None
-		return MediumLevelILBasicBlock(core_block, self._function, self._function.source_function.view)
+		assert self.function.source_function is not None
+		return MediumLevelILBasicBlock(core_block, self.function, self.function.source_function.view)
 
 	@property
 	def ssa_form(self) -> 'MediumLevelILInstruction':
 		"""SSA form of expression (read-only)"""
-		ssa_func = self._function.ssa_form
+		ssa_func = self.function.ssa_form
 		assert ssa_func is not None
-		return MediumLevelILInstruction(ssa_func,
-			core.BNGetMediumLevelILSSAExprIndex(self._function.handle, self._expr_index))
+		return MediumLevelILInstruction.create(ssa_func,
+			core.BNGetMediumLevelILSSAExprIndex(self.function.handle, self.expr_index))
 
 	@property
 	def non_ssa_form(self) -> 'MediumLevelILInstruction':
 		"""Non-SSA form of expression (read-only)"""
-		non_ssa_func = self._function.non_ssa_form
+		non_ssa_func = self.function.non_ssa_form
 		assert non_ssa_func is not None
-		return MediumLevelILInstruction(non_ssa_func,
-			core.BNGetMediumLevelILNonSSAExprIndex(self._function.handle, self._expr_index))
+		return MediumLevelILInstruction.create(non_ssa_func,
+			core.BNGetMediumLevelILNonSSAExprIndex(self.function.handle, self.expr_index))
 
 	@property
 	def value(self) -> variable.RegisterValue:
 		"""Value of expression if constant or a known value (read-only)"""
-		value = core.BNGetMediumLevelILExprValue(self._function.handle, self._expr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		value = core.BNGetMediumLevelILExprValue(self.function.handle, self.expr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	@property
 	def possible_values(self) -> variable.PossibleValueSet:
 		"""Possible values of expression using path-sensitive static data flow analysis (read-only)"""
-		value = core.BNGetMediumLevelILPossibleExprValues(self._function.handle, self._expr_index, None, 0)
-		result = variable.PossibleValueSet(self._function.arch, value)
+		value = core.BNGetMediumLevelILPossibleExprValues(self.function.handle, self.expr_index, None, 0)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
@@ -469,7 +228,7 @@ class MediumLevelILInstruction:
 	def branch_dependence(self) -> Mapping[int, ILBranchDependence]:
 		"""Set of branching instructions that must take the true or false path to reach this instruction"""
 		count = ctypes.c_ulonglong()
-		deps = core.BNGetAllMediumLevelILBranchDependence(self._function.handle, self._instr_index, count)
+		deps = core.BNGetAllMediumLevelILBranchDependence(self.function.handle, self.instr_index, count)
 		assert deps is not None, "core.BNGetAllMediumLevelILBranchDependence returned None"
 		result = {}
 		for i in range(0, count.value):
@@ -480,10 +239,10 @@ class MediumLevelILInstruction:
 	@property
 	def low_level_il(self) -> Optional['lowlevelil.LowLevelILInstruction']:
 		"""Low level IL form of this expression"""
-		expr = self._function.get_low_level_il_expr_index(self._expr_index)
-		if expr is None or self._function.low_level_il is None:
+		expr = self.function.get_low_level_il_expr_index(self.expr_index)
+		if expr is None or self.function.low_level_il is None:
 			return None
-		return lowlevelil.LowLevelILInstruction(self._function.low_level_il.ssa_form, expr)
+		return lowlevelil.LowLevelILInstruction.create(self.function.low_level_il.ssa_form, expr, None)
 
 	@property
 	def llil(self) -> Optional['lowlevelil.LowLevelILInstruction']:
@@ -492,21 +251,21 @@ class MediumLevelILInstruction:
 
 	@property
 	def llils(self) -> List['lowlevelil.LowLevelILInstruction']:
-		exprs = self._function.get_low_level_il_expr_indexes(self.expr_index)
-		if self._function.low_level_il is None:
+		exprs = self.function.get_low_level_il_expr_indexes(self.expr_index)
+		if self.function.low_level_il is None:
 			return []
 		result = []
 		for expr in exprs:
-			result.append(lowlevelil.LowLevelILInstruction(self._function.low_level_il.ssa_form, expr))
+			result.append(lowlevelil.LowLevelILInstruction.create(self.function.low_level_il.ssa_form, expr, None))
 		return result
 
 	@property
 	def high_level_il(self) -> Optional[highlevelil.HighLevelILInstruction]:
 		"""High level IL form of this expression"""
-		expr = self._function.get_high_level_il_expr_index(self._expr_index)
-		if expr is None or self._function.high_level_il is None:
+		expr = self.function.get_high_level_il_expr_index(self.expr_index)
+		if expr is None or self.function.high_level_il is None:
 			return None
-		return highlevelil.HighLevelILInstruction(self._function.high_level_il, expr)
+		return highlevelil.HighLevelILInstruction.create(self.function.high_level_il, expr)
 
 	@property
 	def hlil(self) -> Optional[highlevelil.HighLevelILInstruction]:
@@ -515,91 +274,58 @@ class MediumLevelILInstruction:
 
 	@property
 	def hlils(self) -> List[highlevelil.HighLevelILInstruction]:
-		exprs = self._function.get_high_level_il_expr_indexes(self.expr_index)
+		exprs = self.function.get_high_level_il_expr_indexes(self.expr_index)
 		result = []
-		if self._function.high_level_il is None:
+		if self.function.high_level_il is None:
 			return result
 		for expr in exprs:
-			result.append(highlevelil.HighLevelILInstruction(self._function.high_level_il, expr))
+			result.append(highlevelil.HighLevelILInstruction.create(self.function.high_level_il, expr))
 		return result
 
 	@property
 	def ssa_memory_version(self) -> int:
 		"""Version of active memory contents in SSA form for this instruction"""
-		return core.BNGetMediumLevelILSSAMemoryVersionAtILInstruction(self._function.handle, self._instr_index)
+		return core.BNGetMediumLevelILSSAMemoryVersionAtILInstruction(self.function.handle, self.instr_index)
 
 	@property
-	def prefix_operands(self) -> List[Any]:
+	def prefix_operands(self) -> List[MediumLevelILOperandType]:
 		"""All operands in the expression tree in prefix order"""
-		result = [MediumLevelILOperationAndSize(self._operation, self._size)]
-		for operand in self._operands:
+		result:List[MediumLevelILOperandType] = [MediumLevelILOperationAndSize(self.operation, self.size)]
+		for operand in self.operands:
 			if isinstance(operand, MediumLevelILInstruction):
-				result += operand.prefix_operands
+				result.extend(operand.prefix_operands)
 			else:
 				result.append(operand)
 		return result
 
 	@property
-	def postfix_operands(self) -> List[Any]:
+	def postfix_operands(self) -> List[MediumLevelILOperandType]:
 		"""All operands in the expression tree in postfix order"""
-		result = []
-		for operand in self._operands:
+		result:List[MediumLevelILOperandType] = []
+		for operand in self.operands:
 			if isinstance(operand, MediumLevelILInstruction):
-				result += operand.postfix_operands
+				result.extend(operand.postfix_operands)
 			else:
 				result.append(operand)
-		result.append(MediumLevelILOperationAndSize(self._operation, self._size))
+		result.append(MediumLevelILOperationAndSize(self.operation, self.size))
 		return result
 
 	@property
 	def vars_written(self) -> List[Union[variable.Variable, SSAVariable]]:
 		"""List of variables written by instruction"""
-		# We use self.__dict__ directly to work around the linter
-		if self._operation in [MediumLevelILOperation.MLIL_SET_VAR, MediumLevelILOperation.MLIL_SET_VAR_FIELD,
-			MediumLevelILOperation.MLIL_SET_VAR_SSA, MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD,
-			MediumLevelILOperation.MLIL_SET_VAR_ALIASED, MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD,
-			MediumLevelILOperation.MLIL_VAR_PHI]:
-			return [self.dest]
-		elif self._operation in [MediumLevelILOperation.MLIL_SET_VAR_SPLIT, MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA]:
-			return [self.__dict__['high'], self.__dict__['low']]
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL, MediumLevelILOperation.MLIL_SYSCALL, MediumLevelILOperation.MLIL_TAILCALL]:
-			return self.__dict__['output']
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL_UNTYPED, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED,
-			MediumLevelILOperation.MLIL_CALL_SSA, MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA,
-			MediumLevelILOperation.MLIL_SYSCALL_SSA, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA,
-			MediumLevelILOperation.MLIL_TAILCALL_SSA, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED_SSA]:
-			return self.__dict__['output'].vars_written
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL_OUTPUT, MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA]:
-			return self.__dict__['dest']
 		return []
 
 	@property
-	def vars_read(self) -> List[variable.Variable]:
+	def operands(self) -> Generator[MediumLevelILOperandType, None, None]:
+		for operand_name in self.operand_names:
+			assert hasattr(self, operand_name), f"No operand '{operand_name}' from '{self.operand_names}' for instruction {repr(self)}({self.operation})"
+			yield self.__getattribute__(operand_name)
+
+	@property
+	def vars_read(self) -> List[Union[variable.Variable, SSAVariable]]:
 		"""List of variables read by instruction"""
-		# We use self.__dict__ directly to work around the linter
-		if self._operation in [MediumLevelILOperation.MLIL_SET_VAR, MediumLevelILOperation.MLIL_SET_VAR_FIELD,
-			MediumLevelILOperation.MLIL_SET_VAR_SPLIT, MediumLevelILOperation.MLIL_SET_VAR_SSA,
-			MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA, MediumLevelILOperation.MLIL_SET_VAR_ALIASED]:
-			return self.__dict__['src'].vars_read
-		elif self._operation in [MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD,
-			MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD]:
-			return [self.__dict__['prev']] + self.__dict__['src'].vars_read
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL, MediumLevelILOperation.MLIL_SYSCALL, MediumLevelILOperation.MLIL_TAILCALL,
-			MediumLevelILOperation.MLIL_CALL_SSA, MediumLevelILOperation.MLIL_SYSCALL_SSA, MediumLevelILOperation.MLIL_TAILCALL_SSA]:
-			result = []
-			for param in self.__dict__['params']:
-				result += param.vars_read
-			return result
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL_UNTYPED, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED,
-			MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA, MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA, MediumLevelILOperation.MLIL_TAILCALL_UNTYPED_SSA]:
-			return self.__dict__['params'].vars_read
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL_PARAM, MediumLevelILOperation.MLIL_CALL_PARAM_SSA,
-			MediumLevelILOperation.MLIL_VAR_PHI]:
-			return self.__dict__['src']
-		elif self._operation in [MediumLevelILOperation.MLIL_CALL_OUTPUT, MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA]:
-			return []
 		result = []
-		for operand in self._operands:
+		for operand in self.operands:
 			if (isinstance(operand, variable.Variable)) or (isinstance(operand, SSAVariable)):
 				result.append(operand)
 			elif isinstance(operand, MediumLevelILInstruction):
@@ -609,11 +335,11 @@ class MediumLevelILInstruction:
 	@property
 	def expr_type(self) -> Optional['types.Type']:
 		"""Type of expression"""
-		result = core.BNGetMediumLevelILExprType(self._function.handle, self._expr_index)
+		result = core.BNGetMediumLevelILExprType(self.function.handle, self.expr_index)
 		if result.type:
 			platform = None
-			if self._function.source_function:
-				platform = self._function.source_function.platform
+			if self.function.source_function:
+				platform = self.function.source_function.platform
 			return types.Type(result.type, platform = platform, confidence = result.confidence)
 		return None
 
@@ -623,8 +349,8 @@ class MediumLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleExprValues(self._function.handle, self._expr_index, option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		value = core.BNGetMediumLevelILPossibleExprValues(self.function.handle, self.expr_index, option_array, len(options))
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
@@ -635,118 +361,118 @@ class MediumLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleSSAVarValues(self._function.handle, var_data, ssa_var.version,
-			self._instr_index, option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		value = core.BNGetMediumLevelILPossibleSSAVarValues(self.function.handle, var_data, ssa_var.version,
+			self.instr_index, option_array, len(options))
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_ssa_var_version(self, var:variable.Variable) -> int:
 		var_data = var.to_BNVariable()
-		return core.BNGetMediumLevelILSSAVarVersionAtILInstruction(self._function.handle, var_data, self._instr_index)
+		return core.BNGetMediumLevelILSSAVarVersionAtILInstruction(self.function.handle, var_data, self.instr_index)
 
 	def get_var_for_reg(self, reg:'architecture.RegisterType') -> variable.Variable:
-		reg = self._function.arch.get_reg_index(reg)
-		result = core.BNGetMediumLevelILVariableForRegisterAtInstruction(self._function.handle, reg, self._instr_index)
-		return variable.Variable.from_BNVariable(self._function.source_function, result)
+		reg = self.function.arch.get_reg_index(reg)
+		result = core.BNGetMediumLevelILVariableForRegisterAtInstruction(self.function.handle, reg, self.instr_index)
+		return variable.Variable.from_BNVariable(self.function.source_function, result)
 
 	def get_var_for_flag(self, flag:'architecture.FlagType') -> variable.Variable:
-		flag = self._function.arch.get_flag_index(flag)
-		result = core.BNGetMediumLevelILVariableForFlagAtInstruction(self._function.handle, flag, self._instr_index)
-		return variable.Variable.from_BNVariable(self._function.source_function, result)
+		flag = self.function.arch.get_flag_index(flag)
+		result = core.BNGetMediumLevelILVariableForFlagAtInstruction(self.function.handle, flag, self.instr_index)
+		return variable.Variable.from_BNVariable(self.function.source_function, result)
 
 	def get_var_for_stack_location(self, offset:int) -> variable.Variable:
-		result = core.BNGetMediumLevelILVariableForStackLocationAtInstruction(self._function.handle, offset, self._instr_index)
-		return variable.Variable.from_BNVariable(self._function.source_function, result)
+		result = core.BNGetMediumLevelILVariableForStackLocationAtInstruction(self.function.handle, offset, self.instr_index)
+		return variable.Variable.from_BNVariable(self.function.source_function, result)
 
 	def get_reg_value(self, reg:'architecture.RegisterType') -> 'variable.RegisterValue':
-		reg = self._function.arch.get_reg_index(reg)
-		value = core.BNGetMediumLevelILRegisterValueAtInstruction(self._function.handle, reg, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetMediumLevelILRegisterValueAtInstruction(self.function.handle, reg, self.instr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	def get_reg_value_after(self, reg:'architecture.RegisterType') -> 'variable.RegisterValue':
-		reg = self._function.arch.get_reg_index(reg)
-		value = core.BNGetMediumLevelILRegisterValueAfterInstruction(self._function.handle, reg, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetMediumLevelILRegisterValueAfterInstruction(self.function.handle, reg, self.instr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	def get_possible_reg_values(self, reg:'architecture.RegisterType',
 		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
-		reg = self._function.arch.get_reg_index(reg)
+		reg = self.function.arch.get_reg_index(reg)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleRegisterValuesAtInstruction(self._function.handle, reg, self._instr_index,
+		value = core.BNGetMediumLevelILPossibleRegisterValuesAtInstruction(self.function.handle, reg, self.instr_index,
 			option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_possible_reg_values_after(self, reg:'architecture.RegisterType',
 		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
-		reg = self._function.arch.get_reg_index(reg)
+		reg = self.function.arch.get_reg_index(reg)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(self._function.handle, reg, self._instr_index,
+		value = core.BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(self.function.handle, reg, self.instr_index,
 			option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_flag_value(self, flag:'architecture.FlagType') -> 'variable.RegisterValue':
-		flag = self._function.arch.get_flag_index(flag)
-		value = core.BNGetMediumLevelILFlagValueAtInstruction(self._function.handle, flag, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetMediumLevelILFlagValueAtInstruction(self.function.handle, flag, self.instr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	def get_flag_value_after(self, flag:'architecture.FlagType') -> 'variable.RegisterValue':
-		flag = self._function.arch.get_flag_index(flag)
-		value = core.BNGetMediumLevelILFlagValueAfterInstruction(self._function.handle, flag, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		flag = self.function.arch.get_flag_index(flag)
+		value = core.BNGetMediumLevelILFlagValueAfterInstruction(self.function.handle, flag, self.instr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	def get_possible_flag_values(self, flag:'architecture.FlagType',
 		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
-		flag = self._function.arch.get_flag_index(flag)
+		flag = self.function.arch.get_flag_index(flag)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleFlagValuesAtInstruction(self._function.handle, flag, self._instr_index,
+		value = core.BNGetMediumLevelILPossibleFlagValuesAtInstruction(self.function.handle, flag, self.instr_index,
 			option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_possible_flag_values_after(self, flag:'architecture.FlagType',
 		options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
-		flag = self._function.arch.get_flag_index(flag)
+		flag = self.function.arch.get_flag_index(flag)
 		option_array = (ctypes.c_int * len(options))()
 		idx = 0
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleFlagValuesAfterInstruction(self._function.handle, flag, self._instr_index,
+		value = core.BNGetMediumLevelILPossibleFlagValuesAfterInstruction(self.function.handle, flag, self.instr_index,
 			option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_stack_contents(self, offset:int, size:int) -> 'variable.RegisterValue':
-		value = core.BNGetMediumLevelILStackContentsAtInstruction(self._function.handle, offset, size, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		value = core.BNGetMediumLevelILStackContentsAtInstruction(self.function.handle, offset, size, self.instr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	def get_stack_contents_after(self, offset:int, size:int) -> 'variable.RegisterValue':
-		value = core.BNGetMediumLevelILStackContentsAfterInstruction(self._function.handle, offset, size, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		value = core.BNGetMediumLevelILStackContentsAfterInstruction(self.function.handle, offset, size, self.instr_index)
+		result = variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 		return result
 
 	def get_possible_stack_contents(self, offset:int, size:int,
@@ -756,9 +482,9 @@ class MediumLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleStackContentsAtInstruction(self._function.handle, offset, size, self._instr_index,
+		value = core.BNGetMediumLevelILPossibleStackContentsAtInstruction(self.function.handle, offset, size, self.instr_index,
 			option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
@@ -769,47 +495,1783 @@ class MediumLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetMediumLevelILPossibleStackContentsAfterInstruction(self._function.handle, offset, size, self._instr_index,
+		value = core.BNGetMediumLevelILPossibleStackContentsAfterInstruction(self.function.handle, offset, size, self.instr_index,
 			option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_branch_dependence(self, branch_instr:int) -> ILBranchDependence:
-		return ILBranchDependence(core.BNGetMediumLevelILBranchDependence(self._function.handle, self._instr_index, branch_instr))
+		return ILBranchDependence(core.BNGetMediumLevelILBranchDependence(self.function.handle, self.instr_index, branch_instr))
 
 	@property
-	def function(self) -> 'MediumLevelILFunction':
-		return self._function
+	def operation(self) -> MediumLevelILOperation:
+		return self.instr.operation
 
 	@property
-	def expr_index(self) -> ExpressionIndex:
-		return self._expr_index
+	def size(self) -> int:
+		return self.instr.size
 
 	@property
-	def instr_index(self) -> InstructionIndex:
-		return self._instr_index
+	def address(self) -> int:
+		return self.instr.address
 
 	@property
-	def operation(self) -> MediumLevelILOperation:
-		return self._operation
+	def source_operand(self) -> ExpressionIndex:
+		return ExpressionIndex(self.instr.source_operand)
 
 	@property
-	def size(self) -> int:
-		return self._size
+	def core_operands(self) -> OperandsType:
+		return self.instr.operands
+
+	def get_int(self, operand_index:int) -> int:
+		value = self.instr.operands[operand_index]
+		return (value & ((1 << 63) - 1)) - (value & (1 << 63))
+
+	def get_float(self, operand_index:int) -> float:
+		value = self.instr.operands[operand_index]
+		if self.instr.size == 4:
+			return struct.unpack("f", struct.pack("I", value & 0xffffffff))[0]
+		elif self.instr.size == 8:
+			return struct.unpack("d", struct.pack("Q", value))[0]
+		else:
+			return float(value)
+
+	def get_expr(self, operand_index:int) -> 'MediumLevelILInstruction':
+		return MediumLevelILInstruction.create(self.function,
+			ExpressionIndex(self.instr.operands[operand_index]))
 
+	def get_intrinsic(self, operand_index:int) -> 'lowlevelil.ILIntrinsic':
+		assert self.function.arch is not None, "Attempting to create ILIntrinsic from function with no Architecture"
+		return lowlevelil.ILIntrinsic(self.function.arch,
+			architecture.IntrinsicIndex(self.instr.operands[operand_index]))
+
+	def get_var(self, operand_index:int) -> variable.Variable:
+		value = self.instr.operands[operand_index]
+		return variable.Variable.from_identifier(self.function.source_function, self.instr.operands[operand_index])
+
+	def get_var_ssa(self, operand_index1:int, operand_index2:int) -> SSAVariable:
+		var = variable.Variable.from_identifier(self.function.source_function, self.instr.operands[operand_index1])
+		version = self.instr.operands[operand_index2]
+		return SSAVariable(var, version)
+
+	def get_var_ssa_dest_and_src(self, operand_index1:int, operand_index2:int) -> SSAVariable:
+		var = variable.Variable.from_identifier(self.function.source_function, self.instr.operands[operand_index1])
+		dest_version = self.instr.operands[operand_index2]
+		return SSAVariable(var, dest_version)
+
+	def get_int_list(self, operand_index:int) -> List[int]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNMediumLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
+		value:List[int] = []
+		try:
+			for j in range(count.value):
+				value.append(operand_list[j])
+			return value
+		finally:
+			core.BNMediumLevelILFreeOperandList(operand_list)
+
+	def get_var_list(self, operand_index1:int, operand_index2:int) -> List[variable.Variable]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNMediumLevelILGetOperandList(self.function.handle, self.expr_index, operand_index1, count)
+		assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
+		value:List[variable.Variable] = []
+		try:
+			for j in range(count.value):
+				value.append(variable.Variable.from_identifier(self.function.source_function, operand_list[j]))
+			return value
+		finally:
+			core.BNMediumLevelILFreeOperandList(operand_list)
+
+	def get_var_ssa_list(self, operand_index1:int, _:int) -> List[SSAVariable]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNMediumLevelILGetOperandList(self.function.handle, self.expr_index, operand_index1, count)
+		assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
+		value = []
+		try:
+			for j in range(count.value // 2):
+				var_id = operand_list[j * 2]
+				var_version = operand_list[(j * 2) + 1]
+				value.append(SSAVariable(variable.Variable.from_identifier(self.function.source_function,
+					var_id), var_version))
+			return value
+		finally:
+			core.BNMediumLevelILFreeOperandList(operand_list)
+
+	def get_expr_list(self, operand_index1:int, _:int) -> List['MediumLevelILInstruction']:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNMediumLevelILGetOperandList(self.function.handle, self.expr_index, operand_index1, count)
+		assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
+		value:List['MediumLevelILInstruction'] = []
+		try:
+			for j in range(count.value):
+				value.append(MediumLevelILInstruction.create(self.function, operand_list[j], None))
+			return value
+		finally:
+			core.BNMediumLevelILFreeOperandList(operand_list)
+
+	def get_target_map(self, operand_index1:int, _:int) -> Mapping[int, int]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNMediumLevelILGetOperandList(self.function.handle, self.expr_index, operand_index1, count)
+		assert operand_list is not None, "core.BNMediumLevelILGetOperandList returned None"
+		value:Mapping[int, int] = {}
+		try:
+			for j in range(count.value // 2):
+				key = operand_list[j * 2]
+				target = operand_list[(j * 2) + 1]
+				value[key] = target
+			return value
+		finally:
+			core.BNMediumLevelILFreeOperandList(operand_list)
+
+
+@dataclass(frozen=True, repr=False)
+class Arithmetic(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Memory(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class ControlFlow(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Call(ControlFlow):
 	@property
-	def address(self) -> int:
-		return self._address
+	def output(self) -> List[Union[SSAVariable, variable.Variable]]:
+		return NotImplemented
 
 	@property
-	def source_operand(self) -> ExpressionIndex:
-		return self._source_operand
+	def vars_written(self) -> List[Union[SSAVariable, variable.Variable]]:
+		return self.output
+
+	@property
+	def params(self) -> List[Union[SSAVariable, variable.Variable]]:
+		return NotImplemented
+
+	@property
+	def vars_read(self) -> List[Union[SSAVariable, variable.Variable]]:
+		result = []
+		for param in self.params:
+			if isinstance(param, MediumLevelILInstruction):
+				result.extend(param.vars_read)
+			elif isinstance(param, (variable.Variable, SSAVariable)):
+				result.append(param)
+			else:
+				assert False, "Call.params returned object other than Variable, SSAVariable or MediumLevelILInstruction"
+		return result
+
+@dataclass(frozen=True, repr=False)
+class UnaryOperation(MediumLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class BinaryOperation(MediumLevelILInstruction):
+	operand_names = tuple(["left", "right"])
+
+	@property
+	def left(self):
+		return self.get_expr(0)
+
+	@property
+	def right(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class Carry(Arithmetic):
+	operand_names = tuple(["left", "right", "carry"])
+
+	@property
+	def left(self):
+		return self.get_expr(0)
+
+	@property
+	def right(self):
+		return self.get_expr(1)
+
+	@property
+	def carry(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class Comparison(BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Constant(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Store(Memory):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Load(Memory):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class RegisterStack(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class SSA(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Phi(SSA):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class SetVar(MediumLevelILInstruction):
+	@property
+	def src(self) -> Union[MediumLevelILInstruction, List[Union[SSAVariable, variable.Variable]]]:
+		return NotImplemented
+
+	@property
+	def dest(self) -> Union[SSAVariable, variable.Variable]:
+		return NotImplemented
+
+	@property
+	def vars_written(self) -> List[Union[SSAVariable, variable.Variable]]:
+		d = self.dest
+		if isinstance(d, list):
+			return d
+		return [d]
+
+	@property
+	def vars_read(self) -> List[Union[SSAVariable, variable.Variable]]:
+		result = []
+		src = self.src
+		if isinstance(src, MediumLevelILInstruction):
+			return src.vars_read
+
+		for i in src:
+			if isinstance(i, (variable.Variable, SSAVariable)):
+				result.append(i)
+			else:
+				assert False, "SetVar.src returned object other than, Variable, SSAVariable"
+		return result
+
+@dataclass(frozen=True, repr=False)
+class FloatingPoint(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Terminal(ControlFlow):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Return(Terminal):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Signed(MediumLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class DoublePrecision(Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Syscall(Call):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Tailcall(Call, Terminal):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILNop(MediumLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILNoret(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILBp(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILUndef(MediumLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILUnimpl(MediumLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLoad(Load):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar(MediumLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_var(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAddress_of(MediumLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_var(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILConst(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILConst_ptr(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFloat_const(Constant, FloatingPoint):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_float(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILImport(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILNeg(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILNot(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSx(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILZx(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLow_part(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILJump(Terminal):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRet_hint(ControlFlow):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_output(MediumLevelILInstruction):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self) -> List[variable.Variable]:
+		return self.get_var_list(0, 1)
+
+	@property
+	def vars_written(self) -> List[variable.Variable]:
+		return self.dest
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_param(MediumLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_var_list(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRet(Return):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr_list(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILGoto(Terminal):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILBool_to_int(MediumLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFree_var_slot(RegisterStack):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_var(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILTrap(Terminal):
+	operand_names = tuple(["vector"])
+
+	@property
+	def vector(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFree_var_slot_ssa(RegisterStack):
+	operand_names = tuple(["dest", "prev"])
+
+	@property
+	def dest(self):
+		return self.get_var_ssa_dest_and_src(0, 1)
+
+	@property
+	def prev(self):
+		return self.get_var_ssa_dest_and_src(0, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILUnimpl_mem(Memory):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFsqrt(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFneg(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFabs(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFloat_to_int(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILInt_to_float(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFloat_conv(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRound_to_int(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFloor(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCeil(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFtrunc(UnaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_ssa(SSA):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_var_ssa(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_aliased(SSA):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_var_ssa(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var(SetVar):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var(0)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLoad_struct(Load):
+	operand_names = tuple(["src", "offset"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILStore(Store):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_field(MediumLevelILInstruction):
+	operand_names = tuple(["src", "offset"])
+
+	@property
+	def src(self):
+		return self.get_var(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_split(MediumLevelILInstruction):
+	operand_names = tuple(["high", "low"])
+
+	@property
+	def high(self):
+		return self.get_var(0)
+
+	@property
+	def low(self):
+		return self.get_var(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAddress_of_field(MediumLevelILInstruction):
+	operand_names = tuple(["src", "offset"])
+
+	@property
+	def src(self):
+		return self.get_var(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILExtern_ptr(Constant):
+	operand_names = tuple(["constant", "offset"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAdd(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSub(BinaryOperation, Arithmetic):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAnd(BinaryOperation, Arithmetic):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILOr(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILXor(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLsl(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLsr(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAsr(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRol(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRor(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILMul(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILMulu_dp(BinaryOperation, DoublePrecision):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILMuls_dp(BinaryOperation, DoublePrecision, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILDivu(BinaryOperation, Arithmetic):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILDivu_dp(BinaryOperation, DoublePrecision):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILDivs(BinaryOperation, Arithmetic, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILDivs_dp(BinaryOperation, DoublePrecision, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILModu(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILModu_dp(BinaryOperation, DoublePrecision):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILMods(BinaryOperation, Arithmetic, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILMods_dp(BinaryOperation, DoublePrecision, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_e(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_ne(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_slt(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_ult(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_sle(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_ule(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_sge(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_uge(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_sgt(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCmp_ugt(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILTest_bit(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAdd_overflow(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSyscall(Syscall):
+	operand_names = tuple(["output", "params"])
+
+	@property
+	def output(self):
+		return self.get_var_list(0, 1)
+
+	@property
+	def params(self):
+		return self.get_expr_list(2, 3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_ssa_field(SSA):
+	operand_names = tuple(["src", "offset"])
+
+	@property
+	def src(self):
+		return self.get_var_ssa(0, 1)
+
+	@property
+	def offset(self):
+		return self.get_int(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_aliased_field(SSA):
+	operand_names = tuple(["src", "offset"])
+
+	@property
+	def src(self):
+		return self.get_var_ssa(0, 1)
+
+	@property
+	def offset(self):
+		return self.get_int(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_split_ssa(SSA):
+	operand_names = tuple(["high", "low"])
+
+	@property
+	def high(self):
+		return self.get_var_ssa(0, 1)
+
+	@property
+	def low(self):
+		return self.get_var_ssa(2, 3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_output_ssa(SSA):
+	operand_names = tuple(["dest_memory", "dest"])
+
+	@property
+	def dest_memory(self):
+		return self.get_int(0)
+
+	@property
+	def dest(self) -> List[SSAVariable]:
+		return self.get_var_ssa_list(1, 2)
+
+	@property
+	def vars_written(self) -> List[SSAVariable]:
+		return self.dest
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_param_ssa(SSA):
+	operand_names = tuple(["src_memory", "src"])
+
+	@property
+	def src_memory(self):
+		return self.get_int(0)
+
+	@property
+	def src(self):
+		return self.get_var_ssa_list(1, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLoad_ssa(Load, SSA):
+	operand_names = tuple(["src", "src_memory"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def src_memory(self):
+		return self.get_int(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILVar_phi(Phi, SetVar, SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_var_ssa_list(2, 3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILMem_phi(Memory, Phi):
+	operand_names = tuple(["dest_memory", "src_memory"])
+
+	@property
+	def dest_memory(self):
+		return self.get_int(0)
+
+	@property
+	def src_memory(self):
+		return self.get_int_list(1)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_ssa(SetVar):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_e(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_ne(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_lt(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_le(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_ge(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_gt(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_o(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFcmp_uo(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFadd(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFsub(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFmul(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILFdiv(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILJump_to(Terminal):
+	operand_names = tuple(["dest", "targets"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def targets(self):
+		return self.get_target_map(1, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_aliased(SetVar, SSA):
+	operand_names = tuple(["dest", "prev", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var_ssa_dest_and_src(0, 1)
+
+	@property
+	def prev(self):
+		return self.get_var_ssa_dest_and_src(0, 2)
+
+	@property
+	def src(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSyscall_untyped(Syscall):
+	operand_names = tuple(["output", "params", "stack"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output), "MediumLevelILCall_untyped return bad type for 'output'"
+		return inst.dest
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		inst = self.get_expr(2)
+		assert isinstance(inst, MediumLevelILCall_param), "MediumLevelILCall_untyped return bad type for 'params'"
+		return inst.src
+
+	@property
+	def stack(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILIntrinsic(MediumLevelILInstruction):
+	operand_names = tuple(["output", "intrinsic", "params"])
+
+	@property
+	def output(self):
+		return self.get_var_list(0, 1)
+
+	@property
+	def intrinsic(self):
+		return self.get_intrinsic(2)
+
+	@property
+	def params(self):
+		return self.get_expr_list(3, 4)
+
+	@property
+	def vars_read(self) -> List[variable.Variable]:
+		#return self.params
+		return []
+
+	@property
+	def vars_written(self) -> List[variable.Variable]:
+		#return self.output
+		return []
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILIntrinsic_ssa(SSA):
+	operand_names = tuple(["output", "intrinsic", "params"])
+
+	@property
+	def output(self):
+		return self.get_var_ssa_list(0, 1)
+
+	@property
+	def intrinsic(self):
+		return self.get_intrinsic(2)
+
+	@property
+	def params(self):
+		return self.get_expr_list(3, 4)
+
+	@property
+	def vars_read(self) -> List[SSAVariable]:
+		# return self.params
+		return []
+
+	@property
+	def vars_written(self) -> List[SSAVariable]:
+		# return self.output
+		return []
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_ssa_field(SetVar):
+	operand_names = tuple(["dest", "prev", "offset", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var_ssa_dest_and_src(0, 1)
+
+	@property
+	def prev(self):
+		return self.get_var_ssa_dest_and_src(0, 2)
+
+	@property
+	def offset(self):
+		return self.get_int(3)
+
+	@property
+	def src(self):
+		return self.get_expr(4)
+
+	@property
+	def vars_read(self) -> List[SSAVariable]:
+		return [self.prev, *self.src.vars_read]  # type: ignore we're guaranteed not to return non-SSAVariables here
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_split_ssa(SetVar):
+	operand_names = tuple(["high", "low", "src"])
+
+	@property
+	def high(self):
+		return self.get_var_ssa(0, 1)
+
+	@property
+	def low(self):
+		return self.get_var_ssa(2, 3)
+
+	@property
+	def src(self):
+		return self.get_expr(4)
+
+	@property
+	def vars_written(self) -> List[SSAVariable]:
+		return [self.high, self.low]
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_aliased_field(SetVar, SSA):
+	operand_names = tuple(["dest", "prev", "offset", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var_ssa_dest_and_src(0, 1)
+
+	@property
+	def prev(self):
+		return self.get_var_ssa_dest_and_src(0, 2)
+
+	@property
+	def offset(self):
+		return self.get_int(3)
+
+	@property
+	def src(self):
+		return self.get_expr(4)
+
+	@property
+	def vars_read(self) -> List[SSAVariable]:
+		return [self.prev, *self.src.vars_read]  # type: ignore we're guaranteed not to return non-SSAVariables here
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSyscall_ssa(Syscall, SSA):
+	operand_names = tuple(["output", "params", "src_memory"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILSyscall_ssa return bad type for output"
+		return inst.dest
+
+	@property
+	def output_dest_memory(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILSyscall_ssa return bad type for output"
+		return inst.dest_memory
+
+	@property
+	def params(self):
+		return self.get_expr_list(1, 2)
+
+	@property
+	def src_memory(self):
+		return self.get_int(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSyscall_untyped_ssa(Syscall, SSA):
+	operand_names = tuple(["output", "params", "stack"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILSyscall_untyped_ssa return bad type for 'output'"
+		return inst.dest
+
+	@property
+	def output_dest_memory(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILSyscall_untyped_ssa return bad type for 'output_dest_memory'"
+		return inst.dest_memory
+
+	@property
+	def params(self):
+		inst = self.get_expr(1)
+		assert isinstance(inst, MediumLevelILCall_param_ssa), "MediumLevelILSyscall_untyped_ssa return bad type for 'params'"
+		return inst.src
+
+	@property
+	def params_src_memory(self):
+		inst = self.get_expr(1)
+		assert isinstance(inst, MediumLevelILCall_param_ssa), "MediumLevelILSyscall_untyped_ssa return bad type for 'params_src_memory'"
+		return inst.src_memory
+
+	@property
+	def stack(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILLoad_struct_ssa(Load, SSA):
+	operand_names = tuple(["src", "offset", "src_memory"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+	@property
+	def src_memory(self):
+		return self.get_int(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_field(SetVar):
+	operand_names = tuple(["dest", "offset", "src"])
+
+	@property
+	def dest(self):
+		return self.get_var(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSet_var_split(SetVar):
+	operand_names = tuple(["high", "low", "src"])
+
+	@property
+	def high(self):
+		return self.get_var(0)
+
+	@property
+	def low(self):
+		return self.get_var(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+	@property
+	def vars_written(self) -> List[variable.Variable]:
+		return [self.high, self.low]
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILStore_struct(Store):
+	operand_names = tuple(["dest", "offset", "src"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILAdc(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILSbb(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRlc(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILRrc(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall(Call):
+	operand_names = tuple(["output", "dest", "params"])
+
+	@property
+	def output(self):
+		return self.get_var_list(0, 1)
+
+	@property
+	def dest(self):
+		return self.get_expr(2)
+
+	@property
+	def params(self):
+		return self.get_expr_list(3, 4)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILIf(Terminal):
+	operand_names = tuple(["condition", "true", "false"])
+
+	@property
+	def condition(self):
+		return self.get_expr(0)
+
+	@property
+	def true(self):
+		return self.get_int(1)
+
+	@property
+	def false(self):
+		return self.get_int(2)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILTailcall_untyped(Tailcall):
+	operand_names = tuple(["output", "dest", "params", "stack"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output), "MediumLevelILTailcall_untyped return bad type for 'output'"
+		return inst.dest
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		inst = self.get_expr(2)
+		assert isinstance(inst, MediumLevelILCall_param), "MediumLevelILTailcall_untyped return bad type for 'params'"
+		return inst.src
+
+	@property
+	def stack(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_ssa(Call, SSA):
+	operand_names = tuple(["output", "dest", "params", "src_memory"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILCall_ssa return bad type for output"
+		return inst.dest
+
+	@property
+	def output_dest_memory(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILCall_ssa return bad type for output"
+		return inst.dest_memory
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		return self.get_expr_list(2, 3)
+
+	@property
+	def src_memory(self):
+		return self.get_int(4)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_untyped_ssa(Call, SSA):
+	operand_names = tuple(["output", "dest", "params", "stack"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILCall_untyped_ssa return bad type for output"
+		return inst.dest
+
+	@property
+	def output_dest_memory(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILCall_untyped_ssa return bad type for output"
+		return inst.dest_memory
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		inst = self.get_expr(2)
+		assert isinstance(inst, MediumLevelILCall_param_ssa), "MediumLevelILCall_untyped_ssa return bad type for 'params'"
+		return inst.src
+
+	@property
+	def params_src_memory(self):
+		inst = self.get_expr(2)
+		assert isinstance(inst, MediumLevelILCall_param_ssa), "MediumLevelILCall_untyped_ssa return bad type for 'params_src_memory'"
+		return inst.src_memory
+
+	@property
+	def stack(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILTailcall(Tailcall):
+	operand_names = tuple(["output", "dest", "params"])
+
+	@property
+	def output(self):
+		return self.get_var_list(0, 1)
+
+	@property
+	def dest(self):
+		return self.get_expr(2)
+
+	@property
+	def params(self):
+		return self.get_expr_list(3, 4)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILTailcall_ssa(Tailcall, SSA):
+	operand_names = tuple(["output", "dest", "params", "src_memory"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILTailcall_ssa return bad type for output"
+		return inst.dest
+
+	@property
+	def output_dest_memory(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILTailcall_ssa return bad type for output"
+		return inst.dest_memory
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		return self.get_expr_list(2, 3)
+
+	@property
+	def src_memory(self):
+		return self.get_int(4)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILTailcall_untyped_ssa(Tailcall, SSA):
+	operand_names = tuple(["output", "dest", "params", "stack"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILTailcall_untyped_ssa return bad type for 'output'"
+		return inst.dest
+
+	@property
+	def output_dest_memory(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output_ssa), "MediumLevelILTailcall_untyped_ssa return bad type for 'output'"
+		return inst.dest_memory
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		return self.get_expr(2)
+
+	@property
+	def stack(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILStore_ssa(Store, SSA):
+	operand_names = tuple(["dest", "dest_memory", "src_memory", "src"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(1)
+
+	@property
+	def src_memory(self):
+		return self.get_int(2)
+
+	@property
+	def src(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILCall_untyped(Call):
+	operand_names = tuple(["output", "dest", "params", "stack"])
+
+	@property
+	def output(self):
+		inst = self.get_expr(0)
+		assert isinstance(inst, MediumLevelILCall_output), "MediumLevelILCall_untyped return bad type for 'output'"
+		return inst.dest
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def params(self):
+		inst = self.get_expr(2)
+		assert isinstance(inst, MediumLevelILCall_param), "MediumLevelILCall_untyped return bad type for 'params'"
+		return inst.src
+
+	@property
+	def stack(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class MediumLevelILStore_struct_ssa(Store, SSA):
+	operand_names = tuple(["dest", "offset", "dest_memory", "src_memory", "src"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(2)
+
+	@property
+	def src_memory(self):
+		return self.get_int(3)
 
 	@property
-	def operands(self) -> List[Any]:
-		return self._operands
+	def src(self):
+		return self.get_expr(4)
 
+ILInstruction = {
+	MediumLevelILOperation.MLIL_NOP:MediumLevelILNop,                                      # [],
+	MediumLevelILOperation.MLIL_NORET:MediumLevelILNoret,                                  # [],
+	MediumLevelILOperation.MLIL_BP:MediumLevelILBp,                                        # [],
+	MediumLevelILOperation.MLIL_UNDEF:MediumLevelILUndef,                                  # [],
+	MediumLevelILOperation.MLIL_UNIMPL:MediumLevelILUnimpl,                                # [],
+	MediumLevelILOperation.MLIL_LOAD:MediumLevelILLoad,                                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_VAR:MediumLevelILVar,                                      # [("src", "var")],
+	MediumLevelILOperation.MLIL_ADDRESS_OF:MediumLevelILAddress_of,                        # [("src", "var")],
+	MediumLevelILOperation.MLIL_CONST:MediumLevelILConst,                                  # [("constant", "int")],
+	MediumLevelILOperation.MLIL_CONST_PTR:MediumLevelILConst_ptr,                          # [("constant", "int")],
+	MediumLevelILOperation.MLIL_FLOAT_CONST:MediumLevelILFloat_const,                      # [("constant", "float")],
+	MediumLevelILOperation.MLIL_IMPORT:MediumLevelILImport,                                # [("constant", "int")],
+	MediumLevelILOperation.MLIL_SET_VAR:MediumLevelILSet_var,                              # [("dest", "var"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_LOAD_STRUCT:MediumLevelILLoad_struct,                      # [("src", "expr"), ("offset", "int")],
+	MediumLevelILOperation.MLIL_STORE:MediumLevelILStore,                                  # [("dest", "expr"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_VAR_FIELD:MediumLevelILVar_field,                          # [("src", "var"), ("offset", "int")],
+	MediumLevelILOperation.MLIL_VAR_SPLIT:MediumLevelILVar_split,                          # [("high", "var"), ("low", "var")],
+	MediumLevelILOperation.MLIL_ADDRESS_OF_FIELD:MediumLevelILAddress_of_field,            # [("src", "var"), ("offset", "int")],
+	MediumLevelILOperation.MLIL_EXTERN_PTR:MediumLevelILExtern_ptr,                        # [("constant", "int"), ("offset", "int")],
+	MediumLevelILOperation.MLIL_ADD:MediumLevelILAdd,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_SUB:MediumLevelILSub,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_AND:MediumLevelILAnd,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_OR:MediumLevelILOr,                                        # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_XOR:MediumLevelILXor,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_LSL:MediumLevelILLsl,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_LSR:MediumLevelILLsr,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_ASR:MediumLevelILAsr,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_ROL:MediumLevelILRol,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_ROR:MediumLevelILRor,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MUL:MediumLevelILMul,                                      # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MULU_DP:MediumLevelILMulu_dp,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MULS_DP:MediumLevelILMuls_dp,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_DIVU:MediumLevelILDivu,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_DIVU_DP:MediumLevelILDivu_dp,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_DIVS:MediumLevelILDivs,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_DIVS_DP:MediumLevelILDivs_dp,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MODU:MediumLevelILModu,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MODU_DP:MediumLevelILModu_dp,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MODS:MediumLevelILMods,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_MODS_DP:MediumLevelILMods_dp,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_NEG:MediumLevelILNeg,                                      # [("src", "expr")],
+	MediumLevelILOperation.MLIL_NOT:MediumLevelILNot,                                      # [("src", "expr")],
+	MediumLevelILOperation.MLIL_SX:MediumLevelILSx,                                        # [("src", "expr")],
+	MediumLevelILOperation.MLIL_ZX:MediumLevelILZx,                                        # [("src", "expr")],
+	MediumLevelILOperation.MLIL_LOW_PART:MediumLevelILLow_part,                            # [("src", "expr")],
+	MediumLevelILOperation.MLIL_JUMP:MediumLevelILJump,                                    # [("dest", "expr")],
+	MediumLevelILOperation.MLIL_RET_HINT:MediumLevelILRet_hint,                            # [("dest", "expr")],
+	MediumLevelILOperation.MLIL_CALL_OUTPUT:MediumLevelILCall_output,                      # [("dest", "var_list")],
+	MediumLevelILOperation.MLIL_CALL_PARAM:MediumLevelILCall_param,                        # [("src", "var_list")],
+	MediumLevelILOperation.MLIL_RET:MediumLevelILRet,                                      # [("src", "expr_list")],
+	MediumLevelILOperation.MLIL_GOTO:MediumLevelILGoto,                                    # [("dest", "int")],
+	MediumLevelILOperation.MLIL_BOOL_TO_INT:MediumLevelILBool_to_int,                      # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FREE_VAR_SLOT:MediumLevelILFree_var_slot,                  # [("dest", "var")],
+	MediumLevelILOperation.MLIL_TRAP:MediumLevelILTrap,                                    # [("vector", "int")],
+	MediumLevelILOperation.MLIL_FREE_VAR_SLOT_SSA:MediumLevelILFree_var_slot_ssa,          # [("prev", "var_ssa_dest_and_src")],
+	MediumLevelILOperation.MLIL_UNIMPL_MEM:MediumLevelILUnimpl_mem,                        # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FSQRT:MediumLevelILFsqrt,                                  # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FNEG:MediumLevelILFneg,                                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FABS:MediumLevelILFabs,                                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FLOAT_TO_INT:MediumLevelILFloat_to_int,                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_INT_TO_FLOAT:MediumLevelILInt_to_float,                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FLOAT_CONV:MediumLevelILFloat_conv,                        # [("src", "expr")],
+	MediumLevelILOperation.MLIL_ROUND_TO_INT:MediumLevelILRound_to_int,                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FLOOR:MediumLevelILFloor,                                  # [("src", "expr")],
+	MediumLevelILOperation.MLIL_CEIL:MediumLevelILCeil,                                    # [("src", "expr")],
+	MediumLevelILOperation.MLIL_FTRUNC:MediumLevelILFtrunc,                                # [("src", "expr")],
+	MediumLevelILOperation.MLIL_VAR_SSA:MediumLevelILVar_ssa,                              # [("src", "var_ssa")],
+	MediumLevelILOperation.MLIL_VAR_ALIASED:MediumLevelILVar_aliased,                      # [("src", "var_ssa")],
+	MediumLevelILOperation.MLIL_CMP_E:MediumLevelILCmp_e,                                  # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_NE:MediumLevelILCmp_ne,                                # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_SLT:MediumLevelILCmp_slt,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_ULT:MediumLevelILCmp_ult,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_SLE:MediumLevelILCmp_sle,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_ULE:MediumLevelILCmp_ule,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_SGE:MediumLevelILCmp_sge,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_UGE:MediumLevelILCmp_uge,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_SGT:MediumLevelILCmp_sgt,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_CMP_UGT:MediumLevelILCmp_ugt,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_TEST_BIT:MediumLevelILTest_bit,                            # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_ADD_OVERFLOW:MediumLevelILAdd_overflow,                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_SYSCALL:MediumLevelILSyscall,                              # [("output", "var_list"), ("params", "expr_list")],
+	MediumLevelILOperation.MLIL_VAR_SSA_FIELD:MediumLevelILVar_ssa_field,                  # [("src", "var_ssa"), ("offset", "int")],
+	MediumLevelILOperation.MLIL_VAR_ALIASED_FIELD:MediumLevelILVar_aliased_field,          # [("src", "var_ssa"), ("offset", "int")],
+	MediumLevelILOperation.MLIL_VAR_SPLIT_SSA:MediumLevelILVar_split_ssa,                  # [("high", "var_ssa"), ("low", "var_ssa")],
+	MediumLevelILOperation.MLIL_CALL_OUTPUT_SSA:MediumLevelILCall_output_ssa,              # [("dest_memory", "int"), ("dest", "var_ssa_list")],
+	MediumLevelILOperation.MLIL_CALL_PARAM_SSA:MediumLevelILCall_param_ssa,                # [("src_memory", "int"), ("src", "var_ssa_list")],
+	MediumLevelILOperation.MLIL_LOAD_SSA:MediumLevelILLoad_ssa,                            # [("src", "expr"), ("src_memory", "int")],
+	MediumLevelILOperation.MLIL_VAR_PHI:MediumLevelILVar_phi,                              # [("dest", "var_ssa"), ("src", "var_ssa_list")],
+	MediumLevelILOperation.MLIL_MEM_PHI:MediumLevelILMem_phi,                              # [("dest_memory", "int"), ("src_memory", "int_list")],
+	MediumLevelILOperation.MLIL_SET_VAR_SSA:MediumLevelILSet_var_ssa,                      # [("dest", "var_ssa"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_E:MediumLevelILFcmp_e,                                # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_NE:MediumLevelILFcmp_ne,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_LT:MediumLevelILFcmp_lt,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_LE:MediumLevelILFcmp_le,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_GE:MediumLevelILFcmp_ge,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_GT:MediumLevelILFcmp_gt,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_O:MediumLevelILFcmp_o,                                # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FCMP_UO:MediumLevelILFcmp_uo,                              # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FADD:MediumLevelILFadd,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FSUB:MediumLevelILFsub,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FMUL:MediumLevelILFmul,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_FDIV:MediumLevelILFdiv,                                    # [("left", "expr"), ("right", "expr")],
+	MediumLevelILOperation.MLIL_JUMP_TO:MediumLevelILJump_to,                              # [("dest", "expr"), ("targets", "target_map")],
+	MediumLevelILOperation.MLIL_SET_VAR_ALIASED:MediumLevelILSet_var_aliased,              # [("prev", "var_ssa_dest_and_src"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_SYSCALL_UNTYPED:MediumLevelILSyscall_untyped,              # [("output", "expr"), ("params", "expr"), ("stack", "expr")],
+	MediumLevelILOperation.MLIL_TAILCALL:MediumLevelILTailcall,                            # [("output", "var_list"), ("dest", "expr"), ("params", "expr_list")],
+	MediumLevelILOperation.MLIL_INTRINSIC:MediumLevelILIntrinsic,                          # [("output", "var_list"), ("intrinsic", "intrinsic"), ("params", "expr_list")],
+	MediumLevelILOperation.MLIL_INTRINSIC_SSA:MediumLevelILIntrinsic_ssa,                  # [("output", "var_ssa_list"), ("intrinsic", "intrinsic"), ("params", "expr_list")],
+	MediumLevelILOperation.MLIL_SET_VAR_SSA_FIELD:MediumLevelILSet_var_ssa_field,          # [("prev", "var_ssa_dest_and_src"), ("offset", "int"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_SET_VAR_SPLIT_SSA:MediumLevelILSet_var_split_ssa,          # [("high", "var_ssa"), ("low", "var_ssa"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_SET_VAR_ALIASED_FIELD:MediumLevelILSet_var_aliased_field,  # [("prev", "var_ssa_dest_and_src"), ("offset", "int"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_SYSCALL_SSA:MediumLevelILSyscall_ssa,                      # [("output", "expr"), ("params", "expr_list"), ("src_memory", "int")],
+	MediumLevelILOperation.MLIL_SYSCALL_UNTYPED_SSA:MediumLevelILSyscall_untyped_ssa,      # [("output", "expr"), ("params", "expr"), ("stack", "expr")],
+	MediumLevelILOperation.MLIL_LOAD_STRUCT_SSA:MediumLevelILLoad_struct_ssa,              # [("src", "expr"), ("offset", "int"), ("src_memory", "int")],
+	MediumLevelILOperation.MLIL_SET_VAR_FIELD:MediumLevelILSet_var_field,                  # [("dest", "var"), ("offset", "int"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_SET_VAR_SPLIT:MediumLevelILSet_var_split,                  # [("high", "var"), ("low", "var"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_STORE_STRUCT:MediumLevelILStore_struct,                    # [("dest", "expr"), ("offset", "int"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_ADC:MediumLevelILAdc,                                      # [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	MediumLevelILOperation.MLIL_SBB:MediumLevelILSbb,                                      # [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	MediumLevelILOperation.MLIL_RLC:MediumLevelILRlc,                                      # [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	MediumLevelILOperation.MLIL_RRC:MediumLevelILRrc,                                      # [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	MediumLevelILOperation.MLIL_TAILCALL_UNTYPED:MediumLevelILTailcall_untyped,            # [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
+	MediumLevelILOperation.MLIL_CALL_SSA:MediumLevelILCall_ssa,                            # [("output", "expr"), ("dest", "expr"), ("params", "expr_list"), ("src_memory", "int")],
+	MediumLevelILOperation.MLIL_CALL_UNTYPED_SSA:MediumLevelILCall_untyped_ssa,            # [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
+	MediumLevelILOperation.MLIL_TAILCALL_SSA:MediumLevelILTailcall_ssa,                    # [("output", "expr"), ("dest", "expr"), ("params", "expr_list"), ("src_memory", "int")],
+	MediumLevelILOperation.MLIL_TAILCALL_UNTYPED_SSA:MediumLevelILTailcall_untyped_ssa,    # [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
+	MediumLevelILOperation.MLIL_CALL:MediumLevelILCall,                                    # [("output", "var_list"), ("dest", "expr"), ("params", "expr_list")],
+	MediumLevelILOperation.MLIL_IF:MediumLevelILIf,                                        # [("condition", "expr"), ("true", "int"), ("false", "int")],
+	MediumLevelILOperation.MLIL_STORE_SSA:MediumLevelILStore_ssa,                          # [("dest", "expr"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
+	MediumLevelILOperation.MLIL_CALL_UNTYPED:MediumLevelILCall_untyped,                    # [("output", "expr"), ("dest", "expr"), ("params", "expr"), ("stack", "expr")],
+	MediumLevelILOperation.MLIL_STORE_STRUCT_SSA:MediumLevelILStore_struct_ssa,            # [("dest", "expr"), ("offset", "int"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
+}
 
 class MediumLevelILExpr:
 	"""
@@ -887,11 +2349,11 @@ class MediumLevelILFunction:
 	def __hash__(self):
 		return hash(('MLIL', self._source_function))
 
-	def __getitem__(self, i):
+	def __getitem__(self, i) -> 'MediumLevelILInstruction':
 		if isinstance(i, slice) or isinstance(i, tuple):
 			raise IndexError("expected integer instruction index")
 		if isinstance(i, MediumLevelILExpr):
-			return MediumLevelILInstruction(self, i.index)
+			return MediumLevelILInstruction.create(self, i.index)
 		# for backwards compatibility
 		if isinstance(i, MediumLevelILInstruction):
 			return i
@@ -899,7 +2361,7 @@ class MediumLevelILFunction:
 			raise IndexError("index out of range")
 		if i < 0:
 			i = len(self) + i
-		return MediumLevelILInstruction(self, core.BNGetMediumLevelILIndexForInstruction(self.handle, i), i)
+		return MediumLevelILInstruction.create(self, core.BNGetMediumLevelILIndexForInstruction(self.handle, i), i)
 
 	def __setitem__(self, i, j):
 		raise IndexError("instruction modification not implemented")