Refactor ILs for greater speed and utility

5 files changed, 6085 insertions, 1748 deletions

diff --git a/python/architecture.py b/python/architecture.py
index 3a37b5b6..079d080d 100644
--- a/python/architecture.py
+++ b/python/architecture.py
@@ -929,7 +929,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 				else:
 					operand_list.append(lowlevelil.ILRegister(self, operands[i].reg))
 			return self.get_flag_write_low_level_il(op, size, write_type_name, flag_name, operand_list,
-				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))).index
+				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il)))
 		except (KeyError, OSError):
 			log.log_error(traceback.format_exc())
 			return False
@@ -941,7 +941,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 			else:
 				sem_class_name = None
 			return self.get_flag_condition_low_level_il(cond, sem_class_name,
-				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))).index
+				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il)))
 		except OSError:
 			log.log_error(traceback.format_exc())
 			return 0
@@ -953,7 +953,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 			else:
 				sem_group_name = None
 			return self.get_semantic_flag_group_low_level_il(sem_group_name,
-				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il))).index
+				lowlevelil.LowLevelILFunction(self, core.BNNewLowLevelILFunctionReference(il)))
 		except OSError:
 			log.log_error(traceback.format_exc())
 			return 0
@@ -1361,7 +1361,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 
 	def get_instruction_low_level_il(self, data:bytes, addr:int, il:'lowlevelil.LowLevelILFunction') -> int:
 		"""
-		``get_instruction_low_level_il`` appends LowLevelILExpr objects to ``il`` for the instruction at the given
+		``get_instruction_low_level_il`` appends lowlevelil.ExpressionIndex objects to ``il`` for the instruction at the given
 		virtual address ``addr`` with data ``data``.
 
 		This is used to analyze arbitrary data at an address, if you are working with an existing binary, you likely
@@ -1603,7 +1603,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 		return FlagRole.SpecialFlagRole
 
 	def get_flag_write_low_level_il(self, op:LowLevelILOperation, size:int, write_type:Optional[FlagWriteTypeName], flag:FlagType,
-		operands:List['lowlevelil.ILRegisterType'], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		operands:List['lowlevelil.ILRegisterType'], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param LowLevelILOperation op:
 		:param int size:
@@ -1611,7 +1611,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 		:param operands: a list of either items that are either string register names or constant integer values
 		:type operands: list(str) or list(int)
 		:param LowLevelILFunction il:
-		:rtype: LowLevelILExpr
+		:rtype: lowlevelil.ExpressionIndex
 		"""
 		flag = self.get_flag_index(flag)
 		if flag not in self._flag_roles:
@@ -1619,7 +1619,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 		return self.get_default_flag_write_low_level_il(op, size, self._flag_roles[flag], operands, il)
 
 	def get_default_flag_write_low_level_il(self, op:'lowlevelil.LowLevelILOperation', size:int, role:FlagRole,
-		operands:List['lowlevelil.ILRegisterType'], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		operands:List['lowlevelil.ILRegisterType'], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param LowLevelILOperation op:
 		:param int size:
@@ -1627,7 +1627,7 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 		:param operands: a list of either items that are either string register names or constant integer values
 		:type operands: list(str) or list(int)
 		:param LowLevelILFunction il:
-		:rtype: LowLevelILExpr index
+		:rtype: ExpressionIndex index
 		"""
 		operand_list = (core.BNRegisterOrConstant * len(operands))()
 		for i in range(len(operands)):
@@ -1641,39 +1641,39 @@ class Architecture(metaclass=_ArchitectureMetaClass):
 			else:
 				operand_list[i].constant = True
 				operand_list[i].value = operand
-		return lowlevelil.LowLevelILExpr(core.BNGetDefaultArchitectureFlagWriteLowLevelIL(self.handle, op, size,
+		return lowlevelil.ExpressionIndex(core.BNGetDefaultArchitectureFlagWriteLowLevelIL(self.handle, op, size,
 			role, operand_list, len(operand_list), il.handle))
 
 	def get_flag_condition_low_level_il(self, cond:'lowlevelil.LowLevelILFlagCondition', sem_class:Optional[SemanticClassType],
-		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param LowLevelILFlagCondition cond: Flag condition to be computed
 		:param SemanticClassType sem_class: Semantic class to be used (None for default semantics)
-		:param LowLevelILFunction il: LowLevelILFunction object to append LowLevelILExpr objects to
-		:rtype: LowLevelILExpr
+		:param LowLevelILFunction il: LowLevelILFunction object to append ExpressionIndex objects to
+		:rtype: ExpressionIndex
 		"""
 		return self.get_default_flag_condition_low_level_il(cond, sem_class, il)
 
 	def get_default_flag_condition_low_level_il(self, cond:'lowlevelil.LowLevelILFlagCondition',
-		sem_class:Optional[SemanticClassType], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		sem_class:Optional[SemanticClassType], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param LowLevelILFlagCondition cond:
 		:param SemanticClassType sem_class:
 		:param LowLevelILFunction il:
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_class_index = None
 		if sem_class is not None:
 			_class_index = self.get_semantic_flag_class_index(sem_class)
-		return lowlevelil.LowLevelILExpr(core.BNGetDefaultArchitectureFlagConditionLowLevelIL(self.handle, cond,
+		return lowlevelil.ExpressionIndex(core.BNGetDefaultArchitectureFlagConditionLowLevelIL(self.handle, cond,
 			_class_index, il.handle))
 
 	def get_semantic_flag_group_low_level_il(self, sem_group:Optional[SemanticGroupType],
-		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param Optional[SemanticGroupType] sem_group:
 		:param LowLevelILFunction il:
-		:rtype: LowLevelILExpr
+		:rtype: lowlevelil.ExpressionIndex
 		"""
 		return il.unimplemented()
 
@@ -2306,7 +2306,7 @@ class CoreArchitecture(Architecture):
 
 	def get_instruction_low_level_il(self, data:Union[bytes, str], addr:int, il:lowlevelil.LowLevelILFunction) -> int:
 		"""
-		``get_instruction_low_level_il`` appends LowLevelILExpr objects to ``il`` for the instruction at the given
+		``get_instruction_low_level_il`` appends lowlevelil.ExpressionIndex objects to ``il`` for the instruction at the given
 		virtual address ``addr`` with data ``data``.
 
 		This is used to analyze arbitrary data at an address, if you are working with an existing binary, you likely
@@ -2332,7 +2332,7 @@ class CoreArchitecture(Architecture):
 		return length.value
 
 	def get_flag_write_low_level_il(self, op:LowLevelILOperation, size:int, write_type:FlagWriteTypeName,
-		flag:FlagType, operands:List['lowlevelil.ILRegisterType'], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		flag:FlagType, operands:List['lowlevelil.ILRegisterType'], il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param LowLevelILOperation op:
 		:param int size:
@@ -2340,7 +2340,7 @@ class CoreArchitecture(Architecture):
 		:param operands: a list of either items that are either string register names or constant integer values
 		:type operands: list(str) or list(int)
 		:param LowLevelILFunction il:
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		flag = self.get_flag_index(flag)
 		operand_list = (core.BNRegisterOrConstant * len(operands))()
@@ -2355,30 +2355,30 @@ class CoreArchitecture(Architecture):
 			else:
 				operand_list[i].constant = True
 				operand_list[i].value = operand
-		return lowlevelil.LowLevelILExpr(core.BNGetArchitectureFlagWriteLowLevelIL(self.handle, op, size,
+		return lowlevelil.ExpressionIndex(core.BNGetArchitectureFlagWriteLowLevelIL(self.handle, op, size,
 		        self._flag_write_types[write_type], flag, operand_list, len(operand_list), il.handle))
 
 	def get_flag_condition_low_level_il(self, cond:LowLevelILFlagCondition, sem_class:SemanticClassType,
-		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param LowLevelILFlagCondition cond: Flag condition to be computed
 		:param str sem_class: Semantic class to be used (None for default semantics)
-		:param LowLevelILFunction il: LowLevelILFunction object to append LowLevelILExpr objects to
-		:rtype: LowLevelILExpr
+		:param LowLevelILFunction il: LowLevelILFunction object to append ExpressionIndex objects to
+		:rtype: ExpressionIndex
 		"""
 		class_index = self.get_semantic_flag_class_index(sem_class)
-		return lowlevelil.LowLevelILExpr(core.BNGetArchitectureFlagConditionLowLevelIL(self.handle, cond,
+		return lowlevelil.ExpressionIndex(core.BNGetArchitectureFlagConditionLowLevelIL(self.handle, cond,
 			class_index, il.handle))
 
 	def get_semantic_flag_group_low_level_il(self, sem_group:SemanticGroupName,
-		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.LowLevelILExpr':
+		il:'lowlevelil.LowLevelILFunction') -> 'lowlevelil.ExpressionIndex':
 		"""
 		:param str sem_group:
 		:param LowLevelILFunction il:
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		group_index = self.get_semantic_flag_group_index(sem_group)
-		return lowlevelil.LowLevelILExpr(core.BNGetArchitectureSemanticFlagGroupLowLevelIL(self.handle, group_index, il.handle))
+		return lowlevelil.ExpressionIndex(core.BNGetArchitectureSemanticFlagGroupLowLevelIL(self.handle, group_index, il.handle))
 
 	def assemble(self, code:str, addr:int=0) -> bytes:
 		"""
diff --git a/python/function.py b/python/function.py
index 5111ea5d..36ecc52f 100644
--- a/python/function.py
+++ b/python/function.py
@@ -3530,7 +3530,7 @@ class InstructionTextToken:
 		return result
 
 	@staticmethod
-	def _get_core_struct(tokens:List['InstructionTextToken']) -> ctypes.Array[core.BNInstructionTextToken]:
+	def _get_core_struct(tokens:List['InstructionTextToken']) -> 'ctypes.Array[core.BNInstructionTextToken]':
 		""" Helper method for converting between core.BNInstructionTextToken and InstructionTextToken lists """
 		result = (core.BNInstructionTextToken * len(tokens))()
 		for j in range(len(tokens)):
diff --git a/python/highlevelil.py b/python/highlevelil.py
index 2c4263d5..7f78ece7 100644
--- a/python/highlevelil.py
+++ b/python/highlevelil.py
@@ -20,12 +20,12 @@
 
 import ctypes
 import struct
-from typing import Optional, Generator, List, Union, Any, NewType
+from typing import Optional, Generator, List, Union, Any, NewType, Tuple
+from dataclasses import dataclass
 
 # Binary Ninja components
 from . import _binaryninjacore as core
-from .enums import HighLevelILOperation, InstructionTextTokenType, DataFlowQueryOption, FunctionGraphType
-from .variable import Variable
+from .enums import HighLevelILOperation, DataFlowQueryOption, FunctionGraphType
 from . import function
 from . import binaryview
 from . import architecture
@@ -42,53 +42,36 @@ ExpressionIndex = NewType('ExpressionIndex', int)
 InstructionIndex = NewType('InstructionIndex', int)
 HLILInstructionsType = Generator['HighLevelILInstruction', None, None]
 HLILBasicBlocksType = Generator['HighLevelILBasicBlock', None, None]
+OperandsType = Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex]
+HighLevelILOperandType = Union[
+	'HighLevelILInstruction',
+	'lowlevelil.ILIntrinsic',
+	variable.Variable,
+	'mediumlevelil.SSAVariable',
+	List[int],
+	List[variable.Variable],
+	List['mediumlevelil.SSAVariable'],
+	Optional[int],
+	float,
+	'GotoLabel'
+]
 
+
+@dataclass(frozen=True)
 class HighLevelILOperationAndSize:
-	def __init__(self, operation, size):
-		self._operation = operation
-		self._size = size
+	operation:HighLevelILOperation
+	size:int
 
 	def __repr__(self):
-		if self._size == 0:
-			return "<%s>" % self._operation.name
-		return "<%s %d>" % (self._operation.name, self._size)
-
-	def __eq__(self, other):
-		if isinstance(other, HighLevelILOperation):
-			return other == self._operation
-		if isinstance(other, self.__class__):
-			return other.size == self._size and other.operation == self._operation
-		return NotImplemented
-
-	def __ne__(self, other):
-		if isinstance(other, self.__class__) or isinstance(other, HighLevelILOperation):
-			return not (self == other)
-		return NotImplemented
-
-	def __hash__(self):
-		return hash((self._operation, self._size))
-
-	@property
-	def operation(self):
-		return self._operation
-
-	@operation.setter
-	def operation(self, value):
-		self._operation = value
-
-	@property
-	def size(self):
-		return self._size
-
-	@size.setter
-	def size(self, value):
-		self._size = value
+		if self.size == 0:
+			return "<%s>" % self.operation.name
+		return "<%s %d>" % (self.operation.name, self.size)
 
 
+@dataclass(frozen=True)
 class GotoLabel:
-	def __init__(self, function, id):
-		self._function = function
-		self._id = id
+	function:'HighLevelILFunction'
+	id:int
 
 	def __repr__(self):
 		return "<label: %s>" % self.name
@@ -98,236 +81,63 @@ class GotoLabel:
 
 	@property
 	def label_id(self):
-		return self._id
+		return self.id
 
 	@property
 	def name(self):
-		return core.BNGetGotoLabelName(self._function.source_function.handle, self._id)
+		return core.BNGetGotoLabelName(self.function.source_function.handle, self.id)
 
 	@name.setter
 	def name(self, value):
-		core.BNSetUserGotoLabelName(self._function.source_function.handle, self._id, value)
+		core.BNSetUserGotoLabelName(self.function.source_function.handle, self.id, value)
 
 	@property
 	def definition(self):
-		return self._function.get_label(self._id)
+		return self.function.get_label(self.id)
 
 	@property
 	def uses(self):
-		return self._function.get_label_uses(self._id)
+		return self.function.get_label_uses(self.id)
+
+
+@dataclass(frozen=True, order=True)
+class CoreHighLevelILInstruction:
+	operation:HighLevelILOperation
+	source_operand:int
+	size:int
+	operands:OperandsType
+	address:int
+	parent:ExpressionIndex
+
+	@classmethod
+	def from_BNHighLevelILInstruction(cls, instr:core.BNHighLevelILInstruction) -> 'CoreHighLevelILInstruction':
+		operands:OperandsType = tuple([ExpressionIndex(instr.operands[i]) for i in range(5)])  # type: ignore
+		return cls(HighLevelILOperation(instr.operation), instr.sourceOperand, instr.size, operands, instr.address, instr.parent)
 
 
+@dataclass(frozen=True)
 class HighLevelILInstruction:
 	"""
 	``class HighLevelILInstruction`` High Level Intermediate Language Instructions form an abstract syntax tree of
 	the code. Control flow structures are present as high level constructs in the HLIL tree.
 	"""
+	function:'HighLevelILFunction'
+	expr_index:ExpressionIndex
+	core_instr:CoreHighLevelILInstruction
+	as_ast:bool
+	instr_index:InstructionIndex
+	operand_names = tuple()
 
-	ILOperations = {
-		HighLevelILOperation.HLIL_NOP: [],
-		HighLevelILOperation.HLIL_BLOCK: [("body", "expr_list")],
-		HighLevelILOperation.HLIL_IF: [("condition", "expr"), ("true", "expr"), ("false", "expr")],
-		HighLevelILOperation.HLIL_WHILE: [("condition", "expr"), ("body", "expr")],
-		HighLevelILOperation.HLIL_WHILE_SSA: [("condition_phi", "expr"), ("condition", "expr"), ("body", "expr")],
-		HighLevelILOperation.HLIL_DO_WHILE: [("body", "expr"), ("condition", "expr")],
-		HighLevelILOperation.HLIL_DO_WHILE_SSA: [("body", "expr"), ("condition_phi", "expr"), ("condition", "expr")],
-		HighLevelILOperation.HLIL_FOR: [("init", "expr"), ("condition", "expr"), ("update", "expr"), ("body", "expr")],
-		HighLevelILOperation.HLIL_FOR_SSA: [("init", "expr"), ("condition_phi", "expr"), ("condition", "expr"), ("update", "expr"), ("body", "expr")],
-		HighLevelILOperation.HLIL_SWITCH: [("condition", "expr"), ("default", "expr"), ("cases", "expr_list")],
-		HighLevelILOperation.HLIL_CASE: [("values", "expr_list"), ("body", "expr")],
-		HighLevelILOperation.HLIL_BREAK: [],
-		HighLevelILOperation.HLIL_CONTINUE: [],
-		HighLevelILOperation.HLIL_JUMP: [("dest", "expr")],
-		HighLevelILOperation.HLIL_RET: [("src", "expr_list")],
-		HighLevelILOperation.HLIL_NORET: [],
-		HighLevelILOperation.HLIL_GOTO: [("target", "label")],
-		HighLevelILOperation.HLIL_LABEL: [("target", "label")],
-		HighLevelILOperation.HLIL_VAR_DECLARE: [("var", "var")],
-		HighLevelILOperation.HLIL_VAR_INIT: [("dest", "var"), ("src", "expr")],
-		HighLevelILOperation.HLIL_VAR_INIT_SSA: [("dest", "var_ssa"), ("src", "expr")],
-		HighLevelILOperation.HLIL_ASSIGN: [("dest", "expr"), ("src", "expr")],
-		HighLevelILOperation.HLIL_ASSIGN_UNPACK: [("dest", "expr_list"), ("src", "expr")],
-		HighLevelILOperation.HLIL_ASSIGN_MEM_SSA: [("dest", "expr"), ("dest_memory", "int"), ("src", "expr"), ("src_memory", "int")],
-		HighLevelILOperation.HLIL_ASSIGN_UNPACK_MEM_SSA: [("dest", "expr_list"), ("dest_memory", "int"), ("src", "expr"), ("src_memory", "int")],
-		HighLevelILOperation.HLIL_VAR: [("var", "var")],
-		HighLevelILOperation.HLIL_VAR_SSA: [("var", "var_ssa")],
-		HighLevelILOperation.HLIL_VAR_PHI: [("dest", "var_ssa"), ("src", "var_ssa_list")],
-		HighLevelILOperation.HLIL_MEM_PHI: [("dest", "int"), ("src", "int_list")],
-		HighLevelILOperation.HLIL_STRUCT_FIELD: [("src", "expr"), ("offset", "int"), ("member_index", "member_index")],
-		HighLevelILOperation.HLIL_ARRAY_INDEX: [("src", "expr"), ("index", "expr")],
-		HighLevelILOperation.HLIL_ARRAY_INDEX_SSA: [("src", "expr"), ("src_memory", "int"), ("index", "expr")],
-		HighLevelILOperation.HLIL_SPLIT: [("high", "expr"), ("low", "expr")],
-		HighLevelILOperation.HLIL_DEREF: [("src", "expr")],
-		HighLevelILOperation.HLIL_DEREF_FIELD: [("src", "expr"), ("offset", "int"), ("member_index", "member_index")],
-		HighLevelILOperation.HLIL_DEREF_SSA: [("src", "expr"), ("src_memory", "int")],
-		HighLevelILOperation.HLIL_DEREF_FIELD_SSA: [("src", "expr"), ("src_memory", "int"), ("offset", "int"), ("member_index", "member_index")],
-		HighLevelILOperation.HLIL_ADDRESS_OF: [("src", "expr")],
-		HighLevelILOperation.HLIL_CONST: [("constant", "int")],
-		HighLevelILOperation.HLIL_CONST_PTR: [("constant", "int")],
-		HighLevelILOperation.HLIL_EXTERN_PTR: [("constant", "int"), ("offset", "int")],
-		HighLevelILOperation.HLIL_FLOAT_CONST: [("constant", "float")],
-		HighLevelILOperation.HLIL_IMPORT: [("constant", "int")],
-		HighLevelILOperation.HLIL_ADD: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_ADC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		HighLevelILOperation.HLIL_SUB: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_SBB: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		HighLevelILOperation.HLIL_AND: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_OR: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_XOR: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_LSL: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_LSR: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_ASR: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_ROL: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_RLC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		HighLevelILOperation.HLIL_ROR: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_RRC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		HighLevelILOperation.HLIL_MUL: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_MULU_DP: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_MULS_DP: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_DIVU: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_DIVU_DP: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_DIVS: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_DIVS_DP: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_MODU: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_MODU_DP: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_MODS: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_MODS_DP: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_NEG: [("src", "expr")],
-		HighLevelILOperation.HLIL_NOT: [("src", "expr")],
-		HighLevelILOperation.HLIL_SX: [("src", "expr")],
-		HighLevelILOperation.HLIL_ZX: [("src", "expr")],
-		HighLevelILOperation.HLIL_LOW_PART: [("src", "expr")],
-		HighLevelILOperation.HLIL_CALL: [("dest", "expr"), ("params", "expr_list")],
-		HighLevelILOperation.HLIL_CALL_SSA: [("dest", "expr"), ("params", "expr_list"), ("dest_memory", "int"), ("src_memory", "int")],
-		HighLevelILOperation.HLIL_CMP_E: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_NE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_SLT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_ULT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_SLE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_ULE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_SGE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_UGE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_SGT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_CMP_UGT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_TEST_BIT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_BOOL_TO_INT: [("src", "expr")],
-		HighLevelILOperation.HLIL_ADD_OVERFLOW: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_SYSCALL: [("params", "expr_list")],
-		HighLevelILOperation.HLIL_SYSCALL_SSA: [("params", "expr_list"), ("dest_memory", "int"), ("src_memory", "int")],
-		HighLevelILOperation.HLIL_TAILCALL: [("dest", "expr"), ("params", "expr_list")],
-		HighLevelILOperation.HLIL_BP: [],
-		HighLevelILOperation.HLIL_TRAP: [("vector", "int")],
-		HighLevelILOperation.HLIL_INTRINSIC: [("intrinsic", "intrinsic"), ("params", "expr_list")],
-		HighLevelILOperation.HLIL_INTRINSIC_SSA: [("intrinsic", "intrinsic"), ("params", "expr_list"), ("dest_memory", "int"), ("src_memory", "int")],
-		HighLevelILOperation.HLIL_UNDEF: [],
-		HighLevelILOperation.HLIL_UNIMPL: [],
-		HighLevelILOperation.HLIL_UNIMPL_MEM: [("src", "expr")],
-		HighLevelILOperation.HLIL_FADD: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FSUB: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FMUL: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FDIV: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FSQRT: [("src", "expr")],
-		HighLevelILOperation.HLIL_FNEG: [("src", "expr")],
-		HighLevelILOperation.HLIL_FABS: [("src", "expr")],
-		HighLevelILOperation.HLIL_FLOAT_TO_INT: [("src", "expr")],
-		HighLevelILOperation.HLIL_INT_TO_FLOAT: [("src", "expr")],
-		HighLevelILOperation.HLIL_FLOAT_CONV: [("src", "expr")],
-		HighLevelILOperation.HLIL_ROUND_TO_INT: [("src", "expr")],
-		HighLevelILOperation.HLIL_FLOOR: [("src", "expr")],
-		HighLevelILOperation.HLIL_CEIL: [("src", "expr")],
-		HighLevelILOperation.HLIL_FTRUNC: [("src", "expr")],
-		HighLevelILOperation.HLIL_FCMP_E: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_NE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_LT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_LE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_GE: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_GT: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_O: [("left", "expr"), ("right", "expr")],
-		HighLevelILOperation.HLIL_FCMP_UO: [("left", "expr"), ("right", "expr")]
-	}
-
-	def __init__(self, func:'HighLevelILFunction', expr_index:ExpressionIndex, as_ast:bool = True,
-		instr_index:InstructionIndex = None):
+	@classmethod
+	def create(cls, func:'HighLevelILFunction', expr_index:ExpressionIndex, as_ast:bool=True, instr_index:Optional[InstructionIndex]=None) -> 'HighLevelILInstruction':
+		assert func.arch is not None, "Attempted to create IL instruction with function missing an Architecture"
 		instr = core.BNGetHighLevelILByIndex(func.handle, expr_index, as_ast)
-		self._function = func
-		if func.arch is None:
-			raise Exception("HighLevelILFunction architecture must not be None")
-		self._expr_index = expr_index
+		assert instr is not None, "core.BNGetHighLevelILByIndex returned None"
+		core_instr = CoreHighLevelILInstruction.from_BNHighLevelILInstruction(instr)
 		if instr_index is None:
-			self._instr_index = core.BNGetHighLevelILInstructionForExpr(func.handle, expr_index)
-		else:
-			self._instr_index = instr_index
-		self._operation = HighLevelILOperation(instr.operation)
-		self._size = instr.size
-		self._address = instr.address
-		self._source_operand = instr.sourceOperand
-		self._parent = instr.parent
-		self._as_ast = as_ast
-		operands = HighLevelILInstruction.ILOperations[instr.operation]
-		self._operands = []
-		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 = HighLevelILInstruction(func, instr.operands[i], self._as_ast)
-			elif operand_type == "intrinsic":
-				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 = mediumlevelil.SSAVariable(var, version)
-			elif operand_type == "int_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNHighLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNHighLevelILGetOperandList returned None"
-				value = []
-				for j in range(count.value):
-					value.append(operand_list[j])
-				core.BNHighLevelILFreeOperandList(operand_list)
-			elif operand_type == "expr_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNHighLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNHighLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value):
-					value.append(HighLevelILInstruction(func, operand_list[j], self._as_ast))
-				core.BNHighLevelILFreeOperandList(operand_list)
-			elif operand_type == "var_ssa_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNHighLevelILGetOperandList(func.handle, self._expr_index, i, count)
-				assert operand_list is not None, "core.BNHighLevelILGetOperandList 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(mediumlevelil.SSAVariable(variable.Variable.from_identifier(self._function.source_function,
-						var_id), var_version))
-				core.BNHighLevelILFreeOperandList(operand_list)
-			elif operand_type == "member_index":
-				value = instr.operands[i]
-				if (value & (1 << 63)) != 0:
-					value = None
-			elif operand_type == "label":
-				value = GotoLabel(self.function, instr.operands[i])
-			self._operands.append(value)
-			self.__dict__[name] = value
-			i += 1
+			instr_index = core.BNGetHighLevelILInstructionForExpr(func.handle, expr_index)
+			assert instr_index is not None, "core.BNGetHighLevelILInstructionForExpr returned None"
+		return ILInstruction[instr.operation](func, expr_index, core_instr, as_ast, instr_index)
 
 	def __str__(self):
 		lines = self.lines
@@ -352,52 +162,47 @@ class HighLevelILInstruction:
 				first_line += token.text
 			if len(list(lines)) > 1:
 				continuation = "..."
-		return "<%s: %s%s>" % (self._operation.name, first_line, continuation)
-
-	def __eq__(self, other):
-		if not isinstance(other, self.__class__):
-			return NotImplemented
-		return core.BNHighLevelILExprEqual(self._function.handle, self._expr_index, other._function.handle, other._expr_index)
+		return "<%s: %s%s>" % (self.operation.name, first_line, continuation)
 
-	def __ne__(self, other):
+	def __eq__(self, other:'HighLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return not core.BNHighLevelILExprEqual(self._function.handle, self._expr_index, other._function.handle, other._expr_index)
+		return self.function == other.function and self.expr_index == other.expr_index
 
-	def __lt__(self, other):
+	def __lt__(self, other:'HighLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return core.BNHighLevelILExprLessThan(self._function.handle, self._expr_index, other._function.handle, other._expr_index)
+		return self.function == other.function and self.expr_index < other.expr_index
 
-	def __le__(self, other):
+	def __le__(self, other:'HighLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return not core.BNHighLevelILExprLessThan(other._function.handle, other._expr_index, self._function.handle, self._expr_index)
+		return self.function == other.function and self.expr_index <= other.expr_index
 
-	def __gt__(self, other):
+	def __gt__(self, other:'HighLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return core.BNHighLevelILExprLessThan(other._function.handle, other._expr_index, self._function.handle, self._expr_index)
+		return self.function == other.function and self.expr_index > other.expr_index
 
-	def __ge__(self, other):
+	def __ge__(self, other:'HighLevelILInstruction'):
 		if not isinstance(other, self.__class__):
 			return NotImplemented
-		return not core.BNHighLevelILExprLessThan(self._function.handle, self._expr_index, other._function, other._expr_index)
+		return self.function == other.function and self.expr_index >= other.expr_index
 
 	def __hash__(self):
-		return hash((self._function, self._expr_index))
+		return hash((self.function, self.expr_index))
 
 	@property
 	def lines(self) -> LinesType:
 		"""HLIL text lines (read-only)"""
 		count = ctypes.c_ulonglong()
-		lines = core.BNGetHighLevelILExprText(self._function.handle, self._expr_index, self._as_ast, count, None)
+		lines = core.BNGetHighLevelILExprText(self.function.handle, self.expr_index, self.as_ast, count, None)
 		assert lines is not None, "core.BNGetHighLevelILExprText returned None"
 		try:
 			for i in range(0, count.value):
 				addr = lines[i].addr
 				if lines[i].instrIndex != 0xffffffffffffffff:
-					il_instr = self._function[lines[i].instrIndex]
+					il_instr = self.function[lines[i].instrIndex]
 				else:
 					il_instr = None
 				color = highlight.HighlightColor._from_core_struct(lines[i].highlight)
@@ -407,137 +212,123 @@ class HighLevelILInstruction:
 			core.BNFreeDisassemblyTextLines(lines, count.value)
 
 	@property
-	def prefix_operands(self) -> List[Any]:
+	def prefix_operands(self) -> List[Union[HighLevelILOperandType, HighLevelILOperationAndSize]]:
 		"""All operands in the expression tree in prefix order"""
-		result = [HighLevelILOperationAndSize(self._operation, self._size)]
-		for operand in self._operands:
+		result:List[Union[HighLevelILOperandType, HighLevelILOperationAndSize]] = [
+			HighLevelILOperationAndSize(self.operation, self.size)]
+		for operand in self.operands:
 			if isinstance(operand, HighLevelILInstruction):
-				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[Union[HighLevelILOperandType, HighLevelILOperationAndSize]]:
 		"""All operands in the expression tree in postfix order"""
-		result = []
-		for operand in self._operands:
+		result:List[Union[HighLevelILOperandType, HighLevelILOperationAndSize]] = []
+		for operand in self.operands:
 			if isinstance(operand, HighLevelILInstruction):
-				result += operand.postfix_operands
+				result.extend(operand.postfix_operands)
 			else:
 				result.append(operand)
-		result.append(HighLevelILOperationAndSize(self._operation, self._size))
+		result.append(HighLevelILOperationAndSize(self.operation, self.size))
 		return result
 
 	@property
-	def function(self) -> 'HighLevelILFunction':
-		return self._function
-
-	@property
-	def expr_index(self) -> ExpressionIndex:
-		return self._expr_index
-
-	@expr_index.setter
-	def expr_index(self, value:ExpressionIndex) -> None:
-		self._expr_index = value
-
-	@property
-	def instr_index(self) -> int:
-		"""Index of the statement that this expression belongs to (read-only)"""
-		return core.BNGetHighLevelILInstructionForExpr(self._function.handle, self._expr_index)
-
-	@property
 	def instr(self) -> 'HighLevelILInstruction':
 		"""The statement that this expression belongs to (read-only)"""
-		return self._function[self.instr_index]
+		return self.function[self.instr_index]
 
 	@property
 	def ast(self) -> 'HighLevelILInstruction':
 		"""This expression with full AST printing (read-only)"""
-		if self._as_ast:
+		if self.as_ast:
 			return self
-		return HighLevelILInstruction(self._function, self._expr_index, True)
+		return HighLevelILInstruction.create(self.function, self.expr_index, True)
 
 	@property
 	def non_ast(self) -> 'HighLevelILInstruction':
 		"""This expression without full AST printing (read-only)"""
-		if not self._as_ast:
+		if not self.as_ast:
 			return self
-		return HighLevelILInstruction(self._function, self._expr_index, False)
+		return HighLevelILInstruction.create(self.function, self.expr_index, False)
 
 	@property
 	def operation(self) -> HighLevelILOperation:
-		return self._operation
-
-	@operation.setter
-	def operation(self, value:HighLevelILOperation) -> None:
-		self._operation = value
+		return self.core_instr.operation
 
 	@property
 	def size(self) -> int:
-		return self._size
-
-	@size.setter
-	def size(self, value:int) -> None:
-		self._size = value
+		return self.core_instr.size
 
 	@property
 	def address(self) -> int:
-		return self._address
-
-	@address.setter
-	def address(self, value:int) -> None:
-		self._address = value
+		return self.core_instr.address
 
 	@property
 	def source_operand(self):
-				return self._source_operand
+		return self.core_instr.source_operand
 
-	@source_operand.setter
-	def source_operand(self, value):
-		self._source_operand = value
+	@property
+	def core_operands(self) -> Any:
+		return self.core_instr.operands
 
 	@property
-	def operands(self) -> Any:
-		return self._operands
+	def vars_written(self) -> List[Union[variable.Variable, 'mediumlevelil.SSAVariable']]:
+		"""List of variables written by instruction"""
+		return []
 
-	@operands.setter
-	def operands(self, value: Any):
-		self._operands = value
+	@property
+	def operands(self) -> Generator[HighLevelILOperandType, None, None]:
+		for operand_name in self.operand_names:
+			assert hasattr(self, operand_name), f"No operand '{operand_name}' for instruction {repr(self)}({self.operation})"
+			yield self.__getattribute__(operand_name)
+
+	@property
+	def vars_read(self) -> List[Union[variable.Variable, 'mediumlevelil.SSAVariable']]:
+		"""List of variables read by instruction"""
+		result = []
+		for operand in self.operands:
+			if (isinstance(operand, variable.Variable)) or (isinstance(operand, mediumlevelil.SSAVariable)):
+				result.append(operand)
+			elif isinstance(operand, HighLevelILInstruction):
+				result += operand.vars_read
+		return result
 
 	@property
 	def parent(self) -> Optional['HighLevelILInstruction']:
-		if self._parent >= core.BNGetHighLevelILExprCount(self._function.handle):
+		if self.core_instr.parent >= core.BNGetHighLevelILExprCount(self.function.handle):
 			return None
-		return HighLevelILInstruction(self._function, self._parent, self._as_ast)
+		return HighLevelILInstruction.create(self.function, self.core_instr.parent, self.as_ast)
 
 	@property
 	def ssa_form(self) -> 'HighLevelILInstruction':
 		"""SSA form of expression (read-only)"""
-		assert self._function.ssa_form is not None
-		return HighLevelILInstruction(self._function.ssa_form,
-			core.BNGetHighLevelILSSAExprIndex(self._function.handle, self._expr_index), self._as_ast)
+		assert self.function.ssa_form is not None
+		return HighLevelILInstruction.create(self.function.ssa_form,
+			core.BNGetHighLevelILSSAExprIndex(self.function.handle, self.expr_index), self.as_ast)
 
 	@property
 	def non_ssa_form(self) -> Optional['HighLevelILInstruction']:
 		"""Non-SSA form of expression (read-only)"""
-		if self._function.non_ssa_form is None:
+		if self.function.non_ssa_form is None:
 			return None
-		return HighLevelILInstruction(self._function.non_ssa_form,
-			core.BNGetHighLevelILNonSSAExprIndex(self._function.handle, self._expr_index), self._as_ast)
+		return HighLevelILInstruction.create(self.function.non_ssa_form,
+			core.BNGetHighLevelILNonSSAExprIndex(self.function.handle, self.expr_index), self.as_ast)
 
 	@property
 	def medium_level_il(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
 		"""Medium level IL form of this expression"""
-		expr = self._function.get_medium_level_il_expr_index(self._expr_index)
+		expr = self.function.get_medium_level_il_expr_index(self.expr_index)
 		if expr is None:
 			return None
-		mlil = self._function.medium_level_il
+		mlil = self.function.medium_level_il
 		if mlil is None:
 			return None
 		ssa_func = mlil.ssa_form
 		assert ssa_func is not None, "medium_level_il.ssa_form is None"
-		return mediumlevelil.MediumLevelILInstruction(ssa_func, expr)
+		return mediumlevelil.MediumLevelILInstruction.create(ssa_func, expr)
 
 	@property
 	def mlil(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
@@ -546,13 +337,13 @@ class HighLevelILInstruction:
 
 	@property
 	def mlils(self) -> Generator['mediumlevelil.MediumLevelILInstruction', None, None]:
-		for expr in self._function.get_medium_level_il_expr_indexes(self._expr_index):
-			mlil = self._function.medium_level_il
+		for expr in self.function.get_medium_level_il_expr_indexes(self.expr_index):
+			mlil = self.function.medium_level_il
 			if mlil is None:
 				return
 			ssa_func = mlil.ssa_form
 			assert ssa_func is not None, "medium_level_il.ssa_form is None"
-			yield mediumlevelil.MediumLevelILInstruction(ssa_func, expr)
+			yield mediumlevelil.MediumLevelILInstruction.create(ssa_func, expr)
 
 	@property
 	def low_level_il(self) -> Optional['lowlevelil.LowLevelILInstruction']:
@@ -567,7 +358,7 @@ class HighLevelILInstruction:
 		return self.low_level_il
 
 	@property
-	def llils(self) -> List['lowlevelil.LowLevelILExpr']:
+	def llils(self) -> List['lowlevelil.ExpressionIndex']:
 		result = set()
 		for mlil_expr in self.mlils:
 			for llil_expr in mlil_expr.llils:
@@ -580,10 +371,10 @@ class HighLevelILInstruction:
 		IL basic block object containing this expression (read-only) (only available on finalized functions).
 		Returns None for HLIL_BLOCK expressions as these can contain multiple basic blocks.
 		"""
-		block = core.BNGetHighLevelILBasicBlockForInstruction(self._function.handle, self._instr_index)
-		if not block or self._function.source_function is None:
+		block = core.BNGetHighLevelILBasicBlockForInstruction(self.function.handle, self.instr_index)
+		if not block or self.function.source_function is None:
 			return None
-		return HighLevelILBasicBlock(self._function.source_function.view, block, self._function)
+		return HighLevelILBasicBlock(self.function.source_function.view, block, self.function)
 
 	@property
 	def value(self) -> 'variable.RegisterValue':
@@ -604,11 +395,11 @@ class HighLevelILInstruction:
 	@property
 	def expr_type(self) -> Optional['types.Type']:
 		"""Type of expression"""
-		result = core.BNGetHighLevelILExprType(self._function.handle, self._expr_index)
+		result = core.BNGetHighLevelILExprType(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
 
@@ -621,12 +412,1669 @@ class HighLevelILInstruction:
 	@property
 	def ssa_memory_version(self) -> int:
 		"""Version of active memory contents in SSA form for this instruction"""
-		return core.BNGetHighLevelILSSAMemoryVersionAtILInstruction(self._function.handle, self._instr_index)
+		return core.BNGetHighLevelILSSAMemoryVersionAtILInstruction(self.function.handle, self.instr_index)
 
 	def get_ssa_var_version(self, var:'variable.Variable') -> int:
 		var_data = var.to_BNVariable()
-		return core.BNGetHighLevelILSSAVarVersionAtILInstruction(self._function.handle, var_data, self._instr_index)
+		return core.BNGetHighLevelILSSAVarVersionAtILInstruction(self.function.handle, var_data, self.instr_index)
+
+	def get_int(self, operand_index:int) -> int:
+		value = self.core_instr.operands[operand_index]
+		return (value & ((1 << 63) - 1)) - (value & (1 << 63))
+
+	def get_float(self, operand_index:int) -> float:
+		value = self.core_instr.operands[operand_index]
+		if self.core_instr.size == 4:
+			return struct.unpack("f", struct.pack("I", value & 0xffffffff))[0]
+		elif self.core_instr.size == 8:
+			return struct.unpack("d", struct.pack("Q", value))[0]
+		else:
+			return float(value)
+
+	def get_expr(self, operand_index:int) -> 'HighLevelILInstruction':
+		return HighLevelILInstruction.create(self.function,
+			ExpressionIndex(self.core_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.core_instr.operands[operand_index]))
+
+	def get_var(self, operand_index:int) -> variable.Variable:
+		value = self.core_instr.operands[operand_index]
+		return variable.Variable.from_identifier(self.function.source_function, self.core_instr.operands[operand_index])
+
+	def get_var_ssa(self, operand_index1:int, operand_index2:int) -> 'mediumlevelil.SSAVariable':
+		var = variable.Variable.from_identifier(self.function.source_function, self.core_instr.operands[operand_index1])
+		version = self.core_instr.operands[operand_index2]
+		return mediumlevelil.SSAVariable(var, version)
+
+	def get_var_ssa_dest_and_src(self, operand_index1:int, operand_index2:int) -> 'mediumlevelil.SSAVariable':
+		var = variable.Variable.from_identifier(self.function.source_function, self.core_instr.operands[operand_index1])
+		dest_version = self.core_instr.operands[operand_index2]
+		return mediumlevelil.SSAVariable(var, dest_version)
+
+	def get_int_list(self, operand_index:int) -> List[int]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNHighLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNHighLevelILGetOperandList returned None"
+		value:List[int] = []
+		try:
+			for j in range(count.value):
+				value.append(operand_list[j])
+			return value
+		finally:
+			core.BNHighLevelILFreeOperandList(operand_list)
+
+	def get_expr_list(self, operand_index1:int, operand_index2:int) -> List[variable.Variable]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNHighLevelILGetOperandList(self.function.handle, self.expr_index, operand_index1, count)
+		assert operand_list is not None, "core.BNHighLevelILGetOperandList 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.BNHighLevelILFreeOperandList(operand_list)
+
+	def get_var_ssa_list(self, operand_index1:int, _:int) -> List['mediumlevelil.SSAVariable']:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNHighLevelILGetOperandList(self.function.handle, self.expr_index, operand_index1, count)
+		assert operand_list is not None, "core.BNHighLevelILGetOperandList 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(mediumlevelil.SSAVariable(variable.Variable.from_identifier(self.function.source_function,
+					var_id), var_version))
+			return value
+		finally:
+			core.BNMediumLevelILFreeOperandList(operand_list)
+
+	def get_member_index(self, operand_index:int) -> Optional[int]:
+		value = self.core_instr.operands[operand_index]
+		if (value & (1 << 63)) != 0:
+			value = None
+		return value
+
+	def get_label(self, operand_index:int) -> GotoLabel:
+		return GotoLabel(self.function, self.core_instr.operands[operand_index])
+
+
+@dataclass(frozen=True, repr=False)
+class Arithmetic(HighLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Memory(HighLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class ControlFlow(HighLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Loop(ControlFlow):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Call(ControlFlow):
+
+	@property
+	def params(self) -> List[HighLevelILInstruction]:
+		return NotImplemented
+
+	@property
+	def vars_read(self) -> List[Union['mediumlevelil.SSAVariable', variable.Variable]]:
+		result = []
+		for param in self.params:
+			if isinstance(param, HighLevelILInstruction):
+				result.extend(param.vars_read)
+			else:
+				assert False, "Call.params returned object other than Variable, SSAVariable or MediumLevelILInstruction"
+		return result
+
+@dataclass(frozen=True, repr=False)
+class UnaryOperation(HighLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self) -> HighLevelILInstruction:
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class BinaryOperation(HighLevelILInstruction):
+	operand_names = tuple(["left", "right"])
+
+	@property
+	def left(self) -> HighLevelILInstruction:
+		return self.get_expr(0)
+
+	@property
+	def right(self) -> HighLevelILInstruction:
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class Carry(Arithmetic):
+	operand_names = tuple(["left", "right", "carry"])
+
+	@property
+	def left(self) -> HighLevelILInstruction:
+		return self.get_expr(0)
+
+	@property
+	def right(self) -> HighLevelILInstruction:
+		return self.get_expr(1)
+
+	@property
+	def carry(self) -> HighLevelILInstruction:
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class Comparison(BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Constant(HighLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class SSA(HighLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Phi(SSA):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class FloatingPoint(HighLevelILInstruction):
+	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(HighLevelILInstruction):
+	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):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILNop(HighLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILBlock(HighLevelILInstruction):
+	operand_names = tuple(["body"])
+
+	@property
+	def body(self):
+		return self.get_expr_list(0, 1)
+
+	def __iter__(self):
+		for expr in self.body:
+			yield expr
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILIf(ControlFlow):
+	operand_names = tuple(["condition", "true", "false"])
+
+	@property
+	def condition(self):
+		return self.get_expr(0)
+
+	@property
+	def true(self):
+		return self.get_expr(1)
+
+	@property
+	def false(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILWhile(Loop):
+	operand_names = tuple(["condition", "body"])
+
+	@property
+	def condition(self):
+		return self.get_expr(0)
+
+	@property
+	def body(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILWhile_ssa(Loop, SSA):
+	operand_names = tuple(["condition_phi", "condition", "body"])
+
+	@property
+	def condition_phi(self):
+		return self.get_expr(0)
+
+	@property
+	def condition(self):
+		return self.get_expr(1)
+
+	@property
+	def body(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDo_while(Loop):
+	operand_names = tuple(["body", "condition"])
+
+	@property
+	def body(self):
+		return self.get_expr(0)
+
+	@property
+	def condition(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDo_while_ssa(Loop, SSA):
+	operand_names = tuple(["body", "condition_phi", "condition"])
+
+	@property
+	def body(self):
+		return self.get_expr(0)
+
+	@property
+	def condition_phi(self):
+		return self.get_expr(1)
+
+	@property
+	def condition(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFor(Loop):
+	operand_names = tuple(["init", "condition", "update", "body"])
+
+	@property
+	def init(self):
+		return self.get_expr(0)
+
+	@property
+	def condition(self):
+		return self.get_expr(1)
+
+	@property
+	def update(self):
+		return self.get_expr(2)
+
+	@property
+	def body(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFor_ssa(Loop, SSA):
+	operand_names = tuple(["init", "condition_phi", "condition", "update"])
+
+	@property
+	def init(self):
+		return self.get_expr(0)
+
+	@property
+	def condition_phi(self):
+		return self.get_expr(1)
+
+	@property
+	def condition(self):
+		return self.get_expr(2)
+
+	@property
+	def update(self):
+		return self.get_expr(3)
+
+	@property
+	def body(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSwitch(ControlFlow):
+	operand_names = tuple(["condition", "default", "cases"])
+
+	@property
+	def condition(self):
+		return self.get_expr(0)
+
+	@property
+	def default(self):
+		return self.get_expr(1)
+
+	@property
+	def cases(self):
+		return self.get_expr_list(2, 3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILCase(HighLevelILInstruction):
+	operand_names = tuple(["values", "body"])
+
+	@property
+	def values(self):
+		return self.get_expr_list(0, 1)
+
+	@property
+	def body(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILBreak(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILContinue(ControlFlow):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILJump(Terminal):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILRet(ControlFlow):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr_list(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILNoret(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILGoto(Terminal):
+	operand_names = tuple(["target"])
+
+	@property
+	def target(self):
+		return self.get_label(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILLabel(HighLevelILInstruction):
+	operand_names = tuple(["target"])
+
+	@property
+	def target(self):
+		return self.get_label(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILVar_declare(HighLevelILInstruction):
+	operand_names = tuple(["var"])
+
+	@property
+	def var(self):
+		return self.get_var(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILVar_init(HighLevelILInstruction):
+	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 HighLevelILVar_init_ssa(SSA):
+	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 HighLevelILAssign(HighLevelILInstruction):
+	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 HighLevelILAssign_unpack(HighLevelILInstruction):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_expr_list(0, 1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAssign_mem_ssa(SSA):
+	operand_names = tuple(["dest", "dest_memory", "src", "src_memory"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+	@property
+	def src_memory(self):
+		return self.get_int(3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAssign_unpack_mem_ssa(SSA):
+	operand_names = tuple(["dest", "dest_memory", "src", "src_memory"])
+
+	@property
+	def dest(self):
+		return self.get_expr_list(0, 1)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(2)
+
+	@property
+	def src(self):
+		return self.get_expr(3)
+
+	@property
+	def src_memory(self):
+		return self.get_int(4)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILVar(HighLevelILInstruction):
+	operand_names = tuple(["var"])
+
+	@property
+	def var(self):
+		return self.get_var(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILVar_ssa(SSA):
+	operand_names = tuple(["var"])
+
+	@property
+	def var(self):
+		return self.get_var_ssa(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILVar_phi(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 HighLevelILMem_phi(Memory):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_int(0)
+
+	@property
+	def src(self):
+		return self.get_int_list(1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILStruct_field(HighLevelILInstruction):
+	operand_names = tuple(["src", "offset", "member_index"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+	@property
+	def member_index(self):
+		return self.get_member_index(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILArray_index(HighLevelILInstruction):
+	operand_names = tuple(["src", "index"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def index(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILArray_index_ssa(SSA):
+	operand_names = tuple(["src", "src_memory", "index"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def src_memory(self):
+		return self.get_int(1)
+
+	@property
+	def index(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSplit(HighLevelILInstruction):
+	operand_names = tuple(["high", "low"])
+
+	@property
+	def high(self):
+		return self.get_expr(0)
+
+	@property
+	def low(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDeref(HighLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDeref_field(HighLevelILInstruction):
+	operand_names = tuple(["src", "offset", "member_index"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def offset(self):
+		return self.get_int(1)
+
+	@property
+	def member_index(self):
+		return self.get_member_index(2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDeref_ssa(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 HighLevelILDeref_field_ssa(SSA):
+	operand_names = tuple(["src", "src_memory", "offset", "member_index"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+	@property
+	def src_memory(self):
+		return self.get_int(1)
+
+	@property
+	def offset(self):
+		return self.get_int(2)
+
+	@property
+	def member_index(self):
+		return self.get_member_index(3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAddress_of(HighLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILConst(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILConst_ptr(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
 
+@dataclass(frozen=True, repr=False)
+class HighLevelILExtern_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 HighLevelILFloat_const(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_float(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILImport(Constant):
+	operand_names = tuple(["constant"])
+
+	@property
+	def constant(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAdd(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAdc(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSub(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSbb(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAnd(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILOr(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILXor(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILLsl(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILLsr(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAsr(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILRol(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILRlc(Arithmetic, BinaryOperation):
+	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 HighLevelILRor(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILRrc(Carry):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILMul(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILMulu_dp(BinaryOperation, DoublePrecision):
+	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 HighLevelILMuls_dp(Signed, BinaryOperation, DoublePrecision):
+	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 HighLevelILDivu(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDivu_dp(BinaryOperation, DoublePrecision):
+	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 HighLevelILDivs(Signed, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILDivs_dp(Signed, BinaryOperation, DoublePrecision):
+	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 HighLevelILModu(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILModu_dp(BinaryOperation, DoublePrecision):
+	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 HighLevelILMods(Signed, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILMods_dp(Signed, BinaryOperation, DoublePrecision):
+	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 HighLevelILNeg(Arithmetic, UnaryOperation):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILNot(Arithmetic, UnaryOperation):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSx(Arithmetic, UnaryOperation):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILZx(Arithmetic, UnaryOperation):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILLow_part(Arithmetic, UnaryOperation):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILCall(Call):
+	operand_names = tuple(["dest", "params"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def params(self):
+		return self.get_expr_list(1, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILCall_ssa(Call, SSA):
+	operand_names = tuple(["dest", "params", "dest_memory", "src_memory"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def params(self):
+		return self.get_expr_list(1, 2)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(3)
+
+	@property
+	def src_memory(self):
+		return self.get_int(4)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILCmp_e(Comparison):
+	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 HighLevelILCmp_ne(Comparison):
+	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 HighLevelILCmp_slt(Comparison, Signed):
+	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 HighLevelILCmp_ult(Comparison):
+	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 HighLevelILCmp_sle(Comparison, Signed):
+	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 HighLevelILCmp_ule(Comparison):
+	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 HighLevelILCmp_sge(Comparison, Signed):
+	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 HighLevelILCmp_uge(Comparison):
+	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 HighLevelILCmp_sgt(Comparison, Signed):
+	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 HighLevelILCmp_ugt(Comparison):
+	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 HighLevelILTest_bit(Comparison):
+	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 HighLevelILBool_to_int(HighLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILAdd_overflow(Arithmetic, BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSyscall(Call):
+	operand_names = tuple(["params"])
+
+	@property
+	def params(self):
+		return self.get_expr_list(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILSyscall_ssa(Call, SSA):
+	operand_names = tuple(["params", "dest_memory", "src_memory"])
+
+	@property
+	def params(self):
+		return self.get_expr_list(0, 1)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(2)
+
+	@property
+	def src_memory(self):
+		return self.get_int(3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILTailcall(Tailcall):
+	operand_names = tuple(["dest", "params"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def params(self):
+		return self.get_expr_list(1, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILBp(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILTrap(Terminal):
+	operand_names = tuple(["vector"])
+
+	@property
+	def vector(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILIntrinsic(HighLevelILInstruction):
+	operand_names = tuple(["intrinsic", "params"])
+
+	@property
+	def intrinsic(self):
+		return self.get_intrinsic(0)
+
+	@property
+	def params(self):
+		return self.get_expr_list(1, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILIntrinsic_ssa(SSA):
+	operand_names = tuple(["intrinsic", "params", "dest_memory", "src_memory"])
+
+	@property
+	def intrinsic(self):
+		return self.get_intrinsic(0)
+
+	@property
+	def params(self):
+		return self.get_expr_list(1, 2)
+
+	@property
+	def dest_memory(self):
+		return self.get_int(2)
+
+	@property
+	def src_memory(self):
+		return self.get_int(3)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILUndef(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILUnimpl(HighLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILUnimpl_mem(Memory):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFadd(FloatingPoint):
+	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 HighLevelILFsub(FloatingPoint):
+	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 HighLevelILFmul(FloatingPoint):
+	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 HighLevelILFdiv(FloatingPoint):
+	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 HighLevelILFsqrt(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFneg(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFabs(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFloat_to_int(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILInt_to_float(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFloat_conv(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILRound_to_int(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFloor(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILCeil(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFtrunc(FloatingPoint):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class HighLevelILFcmp_e(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_ne(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_lt(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_le(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_ge(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_gt(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_o(FloatingPoint, Comparison):
+	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 HighLevelILFcmp_uo(FloatingPoint, Comparison):
+	operand_names = tuple(["left", "right"])
+
+	@property
+	def left(self):
+		return self.get_expr(0)
+
+	@property
+	def right(self):
+		return self.get_expr(1)
+
+
+ILInstruction = {
+	HighLevelILOperation.HLIL_NOP:HighLevelILNop,                                      #  ,
+	HighLevelILOperation.HLIL_BLOCK:HighLevelILBlock,                                  #  ("body", "expr_list"),
+	HighLevelILOperation.HLIL_IF:HighLevelILIf,                                        #  ("condition", "expr"), ("true", "expr"), ("false", "expr"),
+	HighLevelILOperation.HLIL_WHILE:HighLevelILWhile,                                  #  ("condition", "expr"), ("body", "expr"),
+	HighLevelILOperation.HLIL_WHILE_SSA:HighLevelILWhile_ssa,                          #  ("condition_phi", "expr"), ("condition", "expr"), ("body", "expr"),
+	HighLevelILOperation.HLIL_DO_WHILE:HighLevelILDo_while,                            #  ("body", "expr"), ("condition", "expr"),
+	HighLevelILOperation.HLIL_DO_WHILE_SSA:HighLevelILDo_while_ssa,                    #  ("body", "expr"), ("condition_phi", "expr"), ("condition", "expr"),
+	HighLevelILOperation.HLIL_FOR:HighLevelILFor,                                      #  ("init", "expr"), ("condition", "expr"), ("update", "expr"), ("body", "expr"),
+	HighLevelILOperation.HLIL_FOR_SSA:HighLevelILFor_ssa,                              #  ("init", "expr"), ("condition_phi", "expr"), ("condition", "expr"), ("update", "expr"), ("body", "expr"),
+	HighLevelILOperation.HLIL_SWITCH:HighLevelILSwitch,                                #  ("condition", "expr"), ("default", "expr"), ("cases", "expr_list"),
+	HighLevelILOperation.HLIL_CASE:HighLevelILCase,                                    #  ("values", "expr_list"), ("body", "expr"),
+	HighLevelILOperation.HLIL_BREAK:HighLevelILBreak,                                  #  ,
+	HighLevelILOperation.HLIL_CONTINUE:HighLevelILContinue,                            #  ,
+	HighLevelILOperation.HLIL_JUMP:HighLevelILJump,                                    #  ("dest", "expr"),
+	HighLevelILOperation.HLIL_RET:HighLevelILRet,                                      #  ("src", "expr_list"),
+	HighLevelILOperation.HLIL_NORET:HighLevelILNoret,                                  #  ,
+	HighLevelILOperation.HLIL_GOTO:HighLevelILGoto,                                    #  ("target", "label"),
+	HighLevelILOperation.HLIL_LABEL:HighLevelILLabel,                                  #  ("target", "label"),
+	HighLevelILOperation.HLIL_VAR_DECLARE:HighLevelILVar_declare,                      #  ("var", "var"),
+	HighLevelILOperation.HLIL_VAR_INIT:HighLevelILVar_init,                            #  ("dest", "var"), ("src", "expr"),
+	HighLevelILOperation.HLIL_VAR_INIT_SSA:HighLevelILVar_init_ssa,                    #  ("dest", "var_ssa"), ("src", "expr"),
+	HighLevelILOperation.HLIL_ASSIGN:HighLevelILAssign,                                #  ("dest", "expr"), ("src", "expr"),
+	HighLevelILOperation.HLIL_ASSIGN_UNPACK:HighLevelILAssign_unpack,                  #  ("dest", "expr_list"), ("src", "expr"),
+	HighLevelILOperation.HLIL_ASSIGN_MEM_SSA:HighLevelILAssign_mem_ssa,                #  ("dest", "expr"), ("dest_memory", "int"), ("src", "expr"), ("src_memory", "int"),
+	HighLevelILOperation.HLIL_ASSIGN_UNPACK_MEM_SSA:HighLevelILAssign_unpack_mem_ssa,  #  ("dest", "expr_list"), ("dest_memory", "int"), ("src", "expr"), ("src_memory", "int"),
+	HighLevelILOperation.HLIL_VAR:HighLevelILVar,                                      #  ("var", "var"),
+	HighLevelILOperation.HLIL_VAR_SSA:HighLevelILVar_ssa,                              #  ("var", "var_ssa"),
+	HighLevelILOperation.HLIL_VAR_PHI:HighLevelILVar_phi,                              #  ("dest", "var_ssa"), ("src", "var_ssa_list"),
+	HighLevelILOperation.HLIL_MEM_PHI:HighLevelILMem_phi,                              #  ("dest", "int"), ("src", "int_list"),
+	HighLevelILOperation.HLIL_STRUCT_FIELD:HighLevelILStruct_field,                    #  ("src", "expr"), ("offset", "int"), ("member_index", "member_index"),
+	HighLevelILOperation.HLIL_ARRAY_INDEX:HighLevelILArray_index,                      #  ("src", "expr"), ("index", "expr"),
+	HighLevelILOperation.HLIL_ARRAY_INDEX_SSA:HighLevelILArray_index_ssa,              #  ("src", "expr"), ("src_memory", "int"), ("index", "expr"),
+	HighLevelILOperation.HLIL_SPLIT:HighLevelILSplit,                                  #  ("high", "expr"), ("low", "expr"),
+	HighLevelILOperation.HLIL_DEREF:HighLevelILDeref,                                  #  ("src", "expr"),
+	HighLevelILOperation.HLIL_DEREF_FIELD:HighLevelILDeref_field,                      #  ("src", "expr"), ("offset", "int"), ("member_index", "member_index"),
+	HighLevelILOperation.HLIL_DEREF_SSA:HighLevelILDeref_ssa,                          #  ("src", "expr"), ("src_memory", "int"),
+	HighLevelILOperation.HLIL_DEREF_FIELD_SSA:HighLevelILDeref_field_ssa,              #  ("src", "expr"), ("src_memory", "int"), ("offset", "int"), ("member_index", "member_index"),
+	HighLevelILOperation.HLIL_ADDRESS_OF:HighLevelILAddress_of,                        #  ("src", "expr"),
+	HighLevelILOperation.HLIL_CONST:HighLevelILConst,                                  #  ("constant", "int"),
+	HighLevelILOperation.HLIL_CONST_PTR:HighLevelILConst_ptr,                          #  ("constant", "int"),
+	HighLevelILOperation.HLIL_EXTERN_PTR:HighLevelILExtern_ptr,                        #  ("constant", "int"), ("offset", "int"),
+	HighLevelILOperation.HLIL_FLOAT_CONST:HighLevelILFloat_const,                      #  ("constant", "float"),
+	HighLevelILOperation.HLIL_IMPORT:HighLevelILImport,                                #  ("constant", "int"),
+	HighLevelILOperation.HLIL_ADD:HighLevelILAdd,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_ADC:HighLevelILAdc,                                      #  ("left", "expr"), ("right", "expr"), ("carry", "expr"),
+	HighLevelILOperation.HLIL_SUB:HighLevelILSub,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_SBB:HighLevelILSbb,                                      #  ("left", "expr"), ("right", "expr"), ("carry", "expr"),
+	HighLevelILOperation.HLIL_AND:HighLevelILAnd,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_OR:HighLevelILOr,                                        #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_XOR:HighLevelILXor,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_LSL:HighLevelILLsl,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_LSR:HighLevelILLsr,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_ASR:HighLevelILAsr,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_ROL:HighLevelILRol,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_RLC:HighLevelILRlc,                                      #  ("left", "expr"), ("right", "expr"), ("carry", "expr"),
+	HighLevelILOperation.HLIL_ROR:HighLevelILRor,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_RRC:HighLevelILRrc,                                      #  ("left", "expr"), ("right", "expr"), ("carry", "expr"),
+	HighLevelILOperation.HLIL_MUL:HighLevelILMul,                                      #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_MULU_DP:HighLevelILMulu_dp,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_MULS_DP:HighLevelILMuls_dp,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_DIVU:HighLevelILDivu,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_DIVU_DP:HighLevelILDivu_dp,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_DIVS:HighLevelILDivs,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_DIVS_DP:HighLevelILDivs_dp,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_MODU:HighLevelILModu,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_MODU_DP:HighLevelILModu_dp,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_MODS:HighLevelILMods,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_MODS_DP:HighLevelILMods_dp,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_NEG:HighLevelILNeg,                                      #  ("src", "expr"),
+	HighLevelILOperation.HLIL_NOT:HighLevelILNot,                                      #  ("src", "expr"),
+	HighLevelILOperation.HLIL_SX:HighLevelILSx,                                        #  ("src", "expr"),
+	HighLevelILOperation.HLIL_ZX:HighLevelILZx,                                        #  ("src", "expr"),
+	HighLevelILOperation.HLIL_LOW_PART:HighLevelILLow_part,                            #  ("src", "expr"),
+	HighLevelILOperation.HLIL_CALL:HighLevelILCall,                                    #  ("dest", "expr"), ("params", "expr_list"),
+	HighLevelILOperation.HLIL_CALL_SSA:HighLevelILCall_ssa,                            #  ("dest", "expr"), ("params", "expr_list"), ("dest_memory", "int"), ("src_memory", "int"),
+	HighLevelILOperation.HLIL_CMP_E:HighLevelILCmp_e,                                  #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_NE:HighLevelILCmp_ne,                                #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_SLT:HighLevelILCmp_slt,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_ULT:HighLevelILCmp_ult,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_SLE:HighLevelILCmp_sle,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_ULE:HighLevelILCmp_ule,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_SGE:HighLevelILCmp_sge,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_UGE:HighLevelILCmp_uge,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_SGT:HighLevelILCmp_sgt,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_CMP_UGT:HighLevelILCmp_ugt,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_TEST_BIT:HighLevelILTest_bit,                            #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_BOOL_TO_INT:HighLevelILBool_to_int,                      #  ("src", "expr"),
+	HighLevelILOperation.HLIL_ADD_OVERFLOW:HighLevelILAdd_overflow,                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_SYSCALL:HighLevelILSyscall,                              #  ("params", "expr_list"),
+	HighLevelILOperation.HLIL_SYSCALL_SSA:HighLevelILSyscall_ssa,                      #  ("params", "expr_list"), ("dest_memory", "int"), ("src_memory", "int"),
+	HighLevelILOperation.HLIL_TAILCALL:HighLevelILTailcall,                            #  ("dest", "expr"), ("params", "expr_list"),
+	HighLevelILOperation.HLIL_BP:HighLevelILBp,                                        #  ,
+	HighLevelILOperation.HLIL_TRAP:HighLevelILTrap,                                    #  ("vector", "int"),
+	HighLevelILOperation.HLIL_INTRINSIC:HighLevelILIntrinsic,                          #  ("intrinsic", "intrinsic"), ("params", "expr_list"),
+	HighLevelILOperation.HLIL_INTRINSIC_SSA:HighLevelILIntrinsic_ssa,                  #  ("intrinsic", "intrinsic"), ("params", "expr_list"), ("dest_memory", "int"), ("src_memory", "int"),
+	HighLevelILOperation.HLIL_UNDEF:HighLevelILUndef,                                  #  ,
+	HighLevelILOperation.HLIL_UNIMPL:HighLevelILUnimpl,                                #  ,
+	HighLevelILOperation.HLIL_UNIMPL_MEM:HighLevelILUnimpl_mem,                        #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FADD:HighLevelILFadd,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FSUB:HighLevelILFsub,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FMUL:HighLevelILFmul,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FDIV:HighLevelILFdiv,                                    #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FSQRT:HighLevelILFsqrt,                                  #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FNEG:HighLevelILFneg,                                    #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FABS:HighLevelILFabs,                                    #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FLOAT_TO_INT:HighLevelILFloat_to_int,                    #  ("src", "expr"),
+	HighLevelILOperation.HLIL_INT_TO_FLOAT:HighLevelILInt_to_float,                    #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FLOAT_CONV:HighLevelILFloat_conv,                        #  ("src", "expr"),
+	HighLevelILOperation.HLIL_ROUND_TO_INT:HighLevelILRound_to_int,                    #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FLOOR:HighLevelILFloor,                                  #  ("src", "expr"),
+	HighLevelILOperation.HLIL_CEIL:HighLevelILCeil,                                    #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FTRUNC:HighLevelILFtrunc,                                #  ("src", "expr"),
+	HighLevelILOperation.HLIL_FCMP_E:HighLevelILFcmp_e,                                #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_NE:HighLevelILFcmp_ne,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_LT:HighLevelILFcmp_lt,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_LE:HighLevelILFcmp_le,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_GE:HighLevelILFcmp_ge,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_GT:HighLevelILFcmp_gt,                              #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_O:HighLevelILFcmp_o,                                #  ("left", "expr"), ("right", "expr"),
+	HighLevelILOperation.HLIL_FCMP_UO:HighLevelILFcmp_uo,                              #  ("left", "expr"), ("right", "expr"),
+}
 
 class HighLevelILExpr:
 	"""
@@ -643,7 +2091,6 @@ class HighLevelILExpr:
 		return self._index
 
 
-
 class HighLevelILFunction:
 	"""
 	``class HighLevelILFunction`` contains the a HighLevelILInstruction object that makes up the abstract syntax tree of
@@ -701,19 +2148,16 @@ class HighLevelILFunction:
 	def __len__(self):
 		return int(core.BNGetHighLevelILInstructionCount(self.handle))
 
-	def __getitem__(self, i:Union[HighLevelILExpr, HighLevelILInstruction, int]) -> HighLevelILInstruction:
+	def __getitem__(self, i:Union[HighLevelILExpr, int]) -> HighLevelILInstruction:
 		if isinstance(i, slice) or isinstance(i, tuple):
 			raise IndexError("expected integer instruction index")
 		if isinstance(i, HighLevelILExpr):
-			return HighLevelILInstruction(self, i.index)
-		# for backwards compatibility
-		if isinstance(i, HighLevelILInstruction):
-			return i
+			return HighLevelILInstruction.create(self, i.index)
 		if i < -len(self) or i >= len(self):
 			raise IndexError("index out of range")
 		if i < 0:
 			i = len(self) + i
-		return HighLevelILInstruction(self, core.BNGetHighLevelILIndexForInstruction(self.handle, i), False,
+		return HighLevelILInstruction.create(self, core.BNGetHighLevelILIndexForInstruction(self.handle, i), False,
 			InstructionIndex(i))
 
 	def __setitem__(self, i, j):
@@ -757,7 +2201,7 @@ class HighLevelILFunction:
 		expr_index = core.BNGetHighLevelILRootExpr(self.handle)
 		if expr_index >= core.BNGetHighLevelILExprCount(self.handle):
 			return None
-		return HighLevelILInstruction(self, expr_index)
+		return HighLevelILInstruction.create(self, expr_index)
 
 	@root.setter
 	def root(self, value:HighLevelILInstruction) -> None:
@@ -838,13 +2282,13 @@ class HighLevelILFunction:
 		result = core.BNGetHighLevelILSSAVarDefinition(self.handle, var_data, ssa_var.version)
 		if result >= core.BNGetHighLevelILExprCount(self.handle):
 			return None
-		return HighLevelILInstruction(self, result)
+		return HighLevelILInstruction.create(self, result)
 
 	def get_ssa_memory_definition(self, version:int) -> Optional[HighLevelILInstruction]:
 		result = core.BNGetHighLevelILSSAMemoryDefinition(self.handle, version)
 		if result >= core.BNGetHighLevelILExprCount(self.handle):
 			return None
-		return HighLevelILInstruction(self, result)
+		return HighLevelILInstruction.create(self, result)
 
 	def get_ssa_var_uses(self, ssa_var:'mediumlevelil.SSAVariable') -> List[HighLevelILInstruction]:
 		count = ctypes.c_ulonglong()
@@ -853,7 +2297,7 @@ class HighLevelILFunction:
 		assert instrs is not None, "core.BNGetHighLevelILSSAVarUses returned None"
 		result = []
 		for i in range(0, count.value):
-			result.append(HighLevelILInstruction(self, instrs[i]))
+			result.append(HighLevelILInstruction.create(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
@@ -863,7 +2307,7 @@ class HighLevelILFunction:
 		assert instrs is not None, "core.BNGetHighLevelILSSAMemoryUses returned None"
 		result = []
 		for i in range(0, count.value):
-			result.append(HighLevelILInstruction(self, instrs[i]))
+			result.append(HighLevelILInstruction.create(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
@@ -885,7 +2329,7 @@ class HighLevelILFunction:
 		assert instrs is not None, "core.BNGetHighLevelILVariableDefinitions returned None"
 		result = []
 		for i in range(0, count.value):
-			result.append(HighLevelILInstruction(self, instrs[i]))
+			result.append(HighLevelILInstruction.create(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
@@ -896,7 +2340,7 @@ class HighLevelILFunction:
 		assert instrs is not None, "core.BNGetHighLevelILVariableUses returned None"
 		result = []
 		for i in range(0, count.value):
-			result.append(HighLevelILInstruction(self, instrs[i]))
+			result.append(HighLevelILInstruction.create(self, instrs[i]))
 		core.BNFreeILInstructionList(instrs)
 		return result
 
@@ -1029,7 +2473,7 @@ class HighLevelILFunction:
 		result = core.BNGetHighLevelILExprIndexForLabel(self.handle, label_idx)
 		if result >= core.BNGetHighLevelILExprCount(self.handle):
 			return None
-		return HighLevelILInstruction(self, result)
+		return HighLevelILInstruction.create(self, result)
 
 	def get_label_uses(self, label_idx:int) -> List[HighLevelILInstruction]:
 		count = ctypes.c_ulonglong()
@@ -1037,7 +2481,7 @@ class HighLevelILFunction:
 		assert uses is not None, "core.BNGetHighLevelILUsesForLabel returned None"
 		result = []
 		for i in range(0, count.value):
-			result.append(HighLevelILInstruction(self, uses[i]))
+			result.append(HighLevelILInstruction.create(self, uses[i]))
 		core.BNFreeILInstructionList(uses)
 		return result
 
diff --git a/python/lowlevelil.py b/python/lowlevelil.py
index 093dd212..21b12909 100644
--- a/python/lowlevelil.py
+++ b/python/lowlevelil.py
@@ -21,11 +21,11 @@
 import ctypes
 from enum import Flag
 import struct
-from typing import Generator, List, Optional, Any, Mapping, Union, Tuple, NewType
+from typing import Generator, List, Optional, Mapping, Union, Tuple, NewType
 from dataclasses import dataclass
 
 # Binary Ninja components
-from .enums import LowLevelILOperation, LowLevelILFlagCondition, InstructionTextTokenType, DataFlowQueryOption, FunctionGraphType
+from .enums import LowLevelILOperation, LowLevelILFlagCondition, DataFlowQueryOption, FunctionGraphType
 from . import _binaryninjacore as core
 from . import basicblock #required for LowLevelILBasicBlock
 from . import function
@@ -41,11 +41,11 @@ ExpressionIndex = NewType('ExpressionIndex', int)
 InstructionIndex = NewType('InstructionIndex', int)
 Index = Union[ExpressionIndex, InstructionIndex]
 TokenList = List['function.InstructionTextToken']
-InstructionOrExpression = Union['LowLevelILInstruction', 'LowLevelILExpr', Index]
+InstructionOrExpression = Union['LowLevelILInstruction', Index]
 ILRegisterType = Union[str, 'ILRegister', int]
 LLILInstructionsType = Generator['LowLevelILInstruction', None, None]
 LLILBasicBlocksType = Generator['LowLevelILBasicBlock', None, None]
-
+OperandsType = Tuple[ExpressionIndex, ExpressionIndex, ExpressionIndex, ExpressionIndex]
 
 class LowLevelILLabel:
 	def __init__(self, handle:core.BNLowLevelILLabel=None):
@@ -87,7 +87,7 @@ class ILRegister:
 		return (self.index & 0x80000000) != 0
 
 	@property
-	def name(self) -> architecture.RegisterName:
+	def name(self) -> 'architecture.RegisterName':
 		if self.temp:
 			return architecture.RegisterName(f"temp{self.index & 0x7fffffff}")
 		else:
@@ -251,9 +251,50 @@ class LowLevelILOperationAndSize:
 	def __repr__(self):
 		if self.size == 0:
 			return f"<{self.operation.name}>"
-		return "<{self.operation.name} {self.size}>"
+		return f"<{self.operation.name} {self.size}>"
+
+LowLevelILOperandType = Union[
+	LowLevelILOperationAndSize,
+	ILRegister,
+	ILFlag,
+	ILIntrinsic,
+	ILRegisterStack,
+	int,
+	Mapping[int, int],
+	float,
+	'LowLevelILInstruction',
+	Mapping['architecture.RegisterStackName', int],
+	SSAFlag,
+	SSARegister,
+	SSARegisterStack,
+	ILSemanticFlagClass,
+	ILSemanticFlagGroup,
+	LowLevelILFlagCondition,
+	List[int],
+	List['LowLevelILInstruction'],
+	List[Union[ILFlag, ILRegister]],
+	List[SSARegister],
+	List[SSARegisterStack],
+	List[SSAFlag],
+	List[SSARegisterOrFlag],
+]
+
+@dataclass(frozen=True)
+class CoreLowLevelILInstruction:
+	operation:LowLevelILOperation
+	size:int
+	flags:int
+	source_operand:ExpressionIndex
+	operands:OperandsType
+	address:int
+
+	@classmethod
+	def from_BNLowLevelILInstruction(cls, instr:core.BNLowLevelILInstruction) -> 'CoreLowLevelILInstruction':
+		operands:OperandsType = tuple([ExpressionIndex(instr.operands[i]) for i in range(4)])  # type: ignore
+		return cls(LowLevelILOperation(instr.operation), instr.size, instr.flags, instr.sourceOperand, operands, instr.address)
 
 
+@dataclass(frozen=True)
 class LowLevelILInstruction:
 	"""
 	``class LowLevelILInstruction`` Low Level Intermediate Language Instructions are infinite length tree-based
@@ -261,322 +302,19 @@ class LowLevelILInstruction:
 	Infix notation is thus more natural to read than other notations (e.g. x86 ``mov eax, 0`` vs. LLIL ``eax = 0``).
 	"""
 
-	ILOperations = {
-		LowLevelILOperation.LLIL_NOP: [],
-		LowLevelILOperation.LLIL_SET_REG: [("dest", "reg"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_SPLIT: [("hi", "reg"), ("lo", "reg"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_STACK_REL: [("stack", "reg_stack"), ("dest", "expr"), ("src", "expr")],
-		LowLevelILOperation.LLIL_REG_STACK_PUSH: [("stack", "reg_stack"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_FLAG: [("dest", "flag"), ("src", "expr")],
-		LowLevelILOperation.LLIL_LOAD: [("src", "expr")],
-		LowLevelILOperation.LLIL_STORE: [("dest", "expr"), ("src", "expr")],
-		LowLevelILOperation.LLIL_PUSH: [("src", "expr")],
-		LowLevelILOperation.LLIL_POP: [],
-		LowLevelILOperation.LLIL_REG: [("src", "reg")],
-		LowLevelILOperation.LLIL_REG_SPLIT: [("hi", "reg"), ("lo", "reg")],
-		LowLevelILOperation.LLIL_REG_STACK_REL: [("stack", "reg_stack"), ("src", "expr")],
-		LowLevelILOperation.LLIL_REG_STACK_POP: [("stack", "reg_stack")],
-		LowLevelILOperation.LLIL_REG_STACK_FREE_REG: [("dest", "reg")],
-		LowLevelILOperation.LLIL_REG_STACK_FREE_REL: [("stack", "reg_stack"), ("dest", "expr")],
-		LowLevelILOperation.LLIL_CONST: [("constant", "int")],
-		LowLevelILOperation.LLIL_CONST_PTR: [("constant", "int")],
-		LowLevelILOperation.LLIL_EXTERN_PTR: [("constant", "int"), ("offset", "int")],
-		LowLevelILOperation.LLIL_FLOAT_CONST: [("constant", "float")],
-		LowLevelILOperation.LLIL_FLAG: [("src", "flag")],
-		LowLevelILOperation.LLIL_FLAG_BIT: [("src", "flag"), ("bit", "int")],
-		LowLevelILOperation.LLIL_ADD: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_ADC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		LowLevelILOperation.LLIL_SUB: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_SBB: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		LowLevelILOperation.LLIL_AND: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_OR: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_XOR: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_LSL: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_LSR: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_ASR: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_ROL: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_RLC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		LowLevelILOperation.LLIL_ROR: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_RRC: [("left", "expr"), ("right", "expr"), ("carry", "expr")],
-		LowLevelILOperation.LLIL_MUL: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_MULU_DP: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_MULS_DP: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_DIVU: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_DIVU_DP: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_DIVS: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_DIVS_DP: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_MODU: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_MODU_DP: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_MODS: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_MODS_DP: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_NEG: [("src", "expr")],
-		LowLevelILOperation.LLIL_NOT: [("src", "expr")],
-		LowLevelILOperation.LLIL_SX: [("src", "expr")],
-		LowLevelILOperation.LLIL_ZX: [("src", "expr")],
-		LowLevelILOperation.LLIL_LOW_PART: [("src", "expr")],
-		LowLevelILOperation.LLIL_JUMP: [("dest", "expr")],
-		LowLevelILOperation.LLIL_JUMP_TO: [("dest", "expr"), ("targets", "target_map")],
-		LowLevelILOperation.LLIL_CALL: [("dest", "expr")],
-		LowLevelILOperation.LLIL_CALL_STACK_ADJUST: [("dest", "expr"), ("stack_adjustment", "int"), ("reg_stack_adjustments", "reg_stack_adjust")],
-		LowLevelILOperation.LLIL_TAILCALL: [("dest", "expr")],
-		LowLevelILOperation.LLIL_RET: [("dest", "expr")],
-		LowLevelILOperation.LLIL_NORET: [],
-		LowLevelILOperation.LLIL_IF: [("condition", "expr"), ("true", "int"), ("false", "int")],
-		LowLevelILOperation.LLIL_GOTO: [("dest", "int")],
-		LowLevelILOperation.LLIL_FLAG_COND: [("condition", "cond"), ("semantic_class", "sem_class")],
-		LowLevelILOperation.LLIL_FLAG_GROUP: [("semantic_group", "sem_group")],
-		LowLevelILOperation.LLIL_CMP_E: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_NE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_SLT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_ULT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_SLE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_ULE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_SGE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_UGE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_SGT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_CMP_UGT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_TEST_BIT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_BOOL_TO_INT: [("src", "expr")],
-		LowLevelILOperation.LLIL_ADD_OVERFLOW: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_SYSCALL: [],
-		LowLevelILOperation.LLIL_INTRINSIC: [("output", "reg_or_flag_list"), ("intrinsic", "intrinsic"), ("param", "expr")],
-		LowLevelILOperation.LLIL_INTRINSIC_SSA: [("output", "reg_or_flag_ssa_list"), ("intrinsic", "intrinsic"), ("param", "expr")],
-		LowLevelILOperation.LLIL_BP: [],
-		LowLevelILOperation.LLIL_TRAP: [("vector", "int")],
-		LowLevelILOperation.LLIL_UNDEF: [],
-		LowLevelILOperation.LLIL_UNIMPL: [],
-		LowLevelILOperation.LLIL_UNIMPL_MEM: [("src", "expr")],
-		LowLevelILOperation.LLIL_FADD: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FSUB: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FMUL: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FDIV: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FSQRT: [("src", "expr")],
-		LowLevelILOperation.LLIL_FNEG: [("src", "expr")],
-		LowLevelILOperation.LLIL_FABS: [("src", "expr")],
-		LowLevelILOperation.LLIL_FLOAT_TO_INT: [("src", "expr")],
-		LowLevelILOperation.LLIL_INT_TO_FLOAT: [("src", "expr")],
-		LowLevelILOperation.LLIL_FLOAT_CONV: [("src", "expr")],
-		LowLevelILOperation.LLIL_ROUND_TO_INT: [("src", "expr")],
-		LowLevelILOperation.LLIL_FLOOR: [("src", "expr")],
-		LowLevelILOperation.LLIL_CEIL: [("src", "expr")],
-		LowLevelILOperation.LLIL_FTRUNC: [("src", "expr")],
-		LowLevelILOperation.LLIL_FCMP_E: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_NE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_LT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_LE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_GE: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_GT: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_O: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_FCMP_UO: [("left", "expr"), ("right", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_SSA: [("dest", "reg_ssa"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_SSA_PARTIAL: [("full_reg", "reg_ssa"), ("dest", "reg"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_SPLIT_SSA: [("hi", "expr"), ("lo", "expr"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_STACK_REL_SSA: [("stack", "expr"), ("dest", "expr"), ("top", "expr"), ("src", "expr")],
-		LowLevelILOperation.LLIL_SET_REG_STACK_ABS_SSA: [("stack", "expr"), ("dest", "reg"), ("src", "expr")],
-		LowLevelILOperation.LLIL_REG_SPLIT_DEST_SSA: [("dest", "reg_ssa")],
-		LowLevelILOperation.LLIL_REG_STACK_DEST_SSA: [("src", "reg_stack_ssa_dest_and_src")],
-		LowLevelILOperation.LLIL_REG_SSA: [("src", "reg_ssa")],
-		LowLevelILOperation.LLIL_REG_SSA_PARTIAL: [("full_reg", "reg_ssa"), ("src", "reg")],
-		LowLevelILOperation.LLIL_REG_SPLIT_SSA: [("hi", "reg_ssa"), ("lo", "reg_ssa")],
-		LowLevelILOperation.LLIL_REG_STACK_REL_SSA: [("stack", "reg_stack_ssa"), ("src", "expr"), ("top", "expr")],
-		LowLevelILOperation.LLIL_REG_STACK_ABS_SSA: [("stack", "reg_stack_ssa"), ("src", "reg")],
-		LowLevelILOperation.LLIL_REG_STACK_FREE_REL_SSA: [("stack", "expr"), ("dest", "expr"), ("top", "expr")],
-		LowLevelILOperation.LLIL_REG_STACK_FREE_ABS_SSA: [("stack", "expr"), ("dest", "reg")],
-		LowLevelILOperation.LLIL_SET_FLAG_SSA: [("dest", "flag_ssa"), ("src", "expr")],
-		LowLevelILOperation.LLIL_FLAG_SSA: [("src", "flag_ssa")],
-		LowLevelILOperation.LLIL_FLAG_BIT_SSA: [("src", "flag_ssa"), ("bit", "int")],
-		LowLevelILOperation.LLIL_CALL_SSA: [("output", "expr"), ("dest", "expr"), ("stack", "expr"), ("param", "expr")],
-		LowLevelILOperation.LLIL_SYSCALL_SSA: [("output", "expr"), ("stack", "expr"), ("param", "expr")],
-		LowLevelILOperation.LLIL_TAILCALL_SSA: [("output", "expr"), ("dest", "expr"), ("stack", "expr"), ("param", "expr")],
-		LowLevelILOperation.LLIL_CALL_OUTPUT_SSA: [("dest_memory", "int"), ("dest", "reg_ssa_list")],
-		LowLevelILOperation.LLIL_CALL_STACK_SSA: [("src", "reg_ssa"), ("src_memory", "int")],
-		LowLevelILOperation.LLIL_CALL_PARAM: [("src", "expr_list")],
-		LowLevelILOperation.LLIL_LOAD_SSA: [("src", "expr"), ("src_memory", "int")],
-		LowLevelILOperation.LLIL_STORE_SSA: [("dest", "expr"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
-		LowLevelILOperation.LLIL_REG_PHI: [("dest", "reg_ssa"), ("src", "reg_ssa_list")],
-		LowLevelILOperation.LLIL_REG_STACK_PHI: [("dest", "reg_stack_ssa"), ("src", "reg_stack_ssa_list")],
-		LowLevelILOperation.LLIL_FLAG_PHI: [("dest", "flag_ssa"), ("src", "flag_ssa_list")],
-		LowLevelILOperation.LLIL_MEM_PHI: [("dest_memory", "int"), ("src_memory", "int_list")]
-	}
-
-	def __init__(self, func:'LowLevelILFunction', expr_index:ExpressionIndex, instr_index:InstructionIndex=None):
-		instr = core.BNGetLowLevelILByIndex(func.handle, expr_index)
-		if func.arch is None:
-			raise Exception("Attempting to create a LowLevelILInstruction with function that doesn't have an architecture.")
-		self._function = func
-		self._expr_index = expr_index
-		self._instr_index = instr_index
-		self._operation = LowLevelILOperation(instr.operation)
-		self._size = instr.size
-		self._address = instr.address
-		self._source_operand = instr.sourceOperand
-		if instr.flags == 0:
-			self._flags = None
-		else:
-			self._flags = func.arch.get_flag_write_type_name(instr.flags)
-		if self._source_operand == 0xffffffff:
-			self._source_operand = None
-		operands = LowLevelILInstruction.ILOperations[instr.operation]
-		self._operands = []
-		i = 0
+	function:'LowLevelILFunction'
+	expr_index:ExpressionIndex
+	instr:CoreLowLevelILInstruction
+	instr_index:Optional[InstructionIndex]
+	operand_names = tuple()
 
-		for operand in operands:
-			name, operand_type = operand
-			value:Optional[Any] = None
-			if operand_type == "int":
-				value = instr.operands[i]
-				assert isinstance(value, int)
-				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 = LowLevelILInstruction(func, instr.operands[i])
-			elif operand_type == "reg":
-				value = ILRegister(func.arch, instr.operands[i])
-			elif operand_type == "reg_stack":
-				value = ILRegisterStack(func.arch, instr.operands[i])
-			elif operand_type == "intrinsic":
-				value = ILIntrinsic(func.arch, instr.operands[i])
-			elif operand_type == "reg_ssa":
-				reg = ILRegister(func.arch, instr.operands[i])
-				i += 1
-				value = SSARegister(reg, instr.operands[i])
-			elif operand_type == "reg_stack_ssa":
-				reg_stack = ILRegisterStack(func.arch, instr.operands[i])
-				i += 1
-				value = SSARegisterStack(reg_stack, instr.operands[i])
-			elif operand_type == "reg_stack_ssa_dest_and_src":
-				reg_stack = ILRegisterStack(func.arch, instr.operands[i])
-				i += 1
-				value = SSARegisterStack(reg_stack, instr.operands[i])
-				i += 1
-				self._operands.append(value)
-				self.__dict__['dest'] = value
-				value = SSARegisterStack(reg_stack, instr.operands[i])
-			elif operand_type == "flag":
-				value = ILFlag(func.arch, instr.operands[i])
-			elif operand_type == "flag_ssa":
-				flag = ILFlag(func.arch, instr.operands[i])
-				i += 1
-				value = SSAFlag(flag, instr.operands[i])
-			elif operand_type == "sem_class":
-				if instr.operands[i] == 0:
-					value = None
-				else:
-					value = ILSemanticFlagClass(func.arch, instr.operands[i])
-			elif operand_type == "sem_group":
-				value = ILSemanticFlagGroup(func.arch, instr.operands[i])
-			elif operand_type == "cond":
-				value = LowLevelILFlagCondition(instr.operands[i])
-			elif operand_type == "int_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value):
-					value.append(operand_list[j])
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "expr_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value):
-					value.append(LowLevelILInstruction(func, operand_list[j]))
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "reg_or_flag_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value):
-					if (operand_list[j] & (1 << 32)) != 0:
-						value.append(ILFlag(func.arch, operand_list[j] & 0xffffffff))
-					else:
-						value.append(ILRegister(func.arch, operand_list[j] & 0xffffffff))
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "reg_ssa_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value // 2):
-					reg = operand_list[j * 2]
-					reg_version = operand_list[(j * 2) + 1]
-					value.append(SSARegister(ILRegister(func.arch, reg), reg_version))
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "reg_stack_ssa_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value // 2):
-					reg_stack = operand_list[j * 2]
-					reg_version = operand_list[(j * 2) + 1]
-					value.append(SSARegisterStack(ILRegisterStack(func.arch, reg_stack), reg_version))
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "flag_ssa_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value // 2):
-					flag = operand_list[j * 2]
-					flag_version = operand_list[(j * 2) + 1]
-					value.append(SSAFlag(ILFlag(func.arch, flag), flag_version))
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "reg_or_flag_ssa_list":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = []
-				for j in range(count.value // 2):
-					if (operand_list[j * 2] & (1 << 32)) != 0:
-						reg_or_flag = ILFlag(func.arch, operand_list[j * 2] & 0xffffffff)
-					else:
-						reg_or_flag = ILRegister(func.arch, operand_list[j * 2] & 0xffffffff)
-					reg_version = operand_list[(j * 2) + 1]
-					value.append(SSARegisterOrFlag(reg_or_flag, reg_version))
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "reg_stack_adjust":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
-				i += 1
-				value = {}
-				for j in range(count.value // 2):
-					reg_stack = operand_list[j * 2]
-					adjust = operand_list[(j * 2) + 1]
-					if adjust & 0x80000000:
-						adjust |= ~0x80000000
-					value[func.arch.get_reg_stack_name(reg_stack)] = adjust
-				core.BNLowLevelILFreeOperandList(operand_list)
-			elif operand_type == "target_map":
-				count = ctypes.c_ulonglong()
-				operand_list = core.BNLowLevelILGetOperandList(func.handle, self.expr_index, i, count)
-				assert operand_list is not None, "core.BNLowLevelILGetOperandList 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.BNLowLevelILFreeOperandList(operand_list)
-			self._operands.append(value)
-			self.__dict__[name] = value
-			i += 1
+	@classmethod
+	def create(cls, func:'LowLevelILFunction', expr_index:ExpressionIndex, instr_index:Optional[InstructionIndex]=None) -> 'LowLevelILInstruction':
+		assert func.arch is not None, "Attempted to create IL instruction with function missing an Architecture"
+		inst = core.BNGetLowLevelILByIndex(func.handle, expr_index)
+		assert inst is not None, "core.BNGetLowLevelILByIndex returned None"
+		core_inst = CoreLowLevelILInstruction.from_BNLowLevelILInstruction(inst)
+		return ILInstruction[core_inst.operation](func, expr_index, core_inst, instr_index)  # type: ignore
 
 	def __str__(self):
 		tokens = self.tokens
@@ -593,7 +331,7 @@ class LowLevelILInstruction:
 	def __eq__(self, other):
 		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 __ne__(self, other):
 		if not isinstance(other, self.__class__):
@@ -603,39 +341,51 @@ class LowLevelILInstruction:
 	def __lt__(self, other):
 		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):
 		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):
 		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):
 		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._function, self.expr_index))
+		return hash((self.function, self.expr_index))
+
+	@property
+	def address(self) -> int:
+		return self.instr.address
+
+	@property
+	def operation(self) -> LowLevelILOperation:
+		return self.instr.operation
+
+	@property
+	def source_operand(self) -> Optional[ExpressionIndex]:
+		return self.instr.source_operand
 
 	@property
 	def tokens(self) -> Optional[TokenList]:
 		"""LLIL tokens (read-only)"""
 		count = ctypes.c_ulonglong()
-		assert self._function.arch is not None
+		assert self.function.arch is not None, f"type(self.function): {type(self.function)} "
 		tokens = ctypes.POINTER(core.BNInstructionTextToken)()
-		if (self._instr_index is not None) and (self._function.source_function is not None):
-			if not core.BNGetLowLevelILInstructionText(self._function.handle, self._function.source_function.handle,
-				self._function.arch.handle, self._instr_index, tokens, count):
+		if (self.instr_index is not None) and (self.function.source_function is not None):
+			if not core.BNGetLowLevelILInstructionText(self.function.handle, self.function.source_function.handle,
+				self.function.arch.handle, self.instr_index, tokens, count):
 				return None
 		else:
 			# TODO: Special case LLIL_CALL_OUTPUT_SSA
-			if not core.BNGetLowLevelILExprText(self._function.handle, self._function.arch.handle,
+			if not core.BNGetLowLevelILExprText(self.function.handle, self.function.arch.handle,
 				self.expr_index, tokens, count):
 				return None
 		result = function.InstructionTextToken._from_core_struct(tokens, count.value)
@@ -645,39 +395,39 @@ class LowLevelILInstruction:
 	@property
 	def il_basic_block(self) -> 'LowLevelILBasicBlock':
 		"""IL basic block object containing this expression (read-only) (only available on finalized functions)"""
-		assert self._function.source_function is not None
-		view = self._function.source_function.view
-		core_block = core.BNGetLowLevelILBasicBlockForInstruction(self._function.handle, self._insstr_index)
+		assert self.function.source_function is not None
+		view = self.function.source_function.view
+		core_block = core.BNGetLowLevelILBasicBlockForInstruction(self.function.handle, self.instr_index)
 		assert core_block is not None, "BNGetLowLevelILBasicBlockForInstruction returned None"
-		return LowLevelILBasicBlock(view, core_block, self._function)
+		return LowLevelILBasicBlock(view, core_block, self.function)
 
 	@property
 	def ssa_form(self) -> 'LowLevelILInstruction':
 		"""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 LowLevelILInstruction(ssa_func,
-			core.BNGetLowLevelILSSAExprIndex(self._function.handle, self.expr_index),
-			core.BNGetLowLevelILSSAInstructionIndex(self._function.handle, self._instr_index) if self._instr_index is not None else None)
+		return LowLevelILInstruction.create(ssa_func,
+			core.BNGetLowLevelILSSAExprIndex(self.function.handle, self.expr_index),
+			core.BNGetLowLevelILSSAInstructionIndex(self.function.handle, self.instr_index) if self.instr_index is not None else None)
 
 	@property
 	def non_ssa_form(self) -> 'LowLevelILInstruction':
 		"""Non-SSA form of expression (read-only)"""
-		non_ssa_function = self._function.non_ssa_form
+		non_ssa_function = self.function.non_ssa_form
 		assert non_ssa_function is not None
-		return LowLevelILInstruction(non_ssa_function,
-			core.BNGetLowLevelILNonSSAExprIndex(self._function.handle, self.expr_index),
-			core.BNGetLowLevelILNonSSAInstructionIndex(self._function.handle, self._instr_index) if self._instr_index is not None else None)
+		return LowLevelILInstruction.create(non_ssa_function,
+			core.BNGetLowLevelILNonSSAExprIndex(self.function.handle, self.expr_index),
+			core.BNGetLowLevelILNonSSAInstructionIndex(self.function.handle, self.instr_index) if self.instr_index is not None else None)
 
 	@property
 	def medium_level_il(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
 		"""Gets the medium level IL expression corresponding to this expression (may be None for eliminated instructions)"""
-		expr = self._function.get_medium_level_il_expr_index(self.expr_index)
+		expr = self.function.get_medium_level_il_expr_index(self.expr_index)
 		if expr is None:
 			return None
-		mlil_func = self._function.medium_level_il
-		assert mlil_func is not None, "self._function.medium_level_il is None"
-		return mediumlevelil.MediumLevelILInstruction(mlil_func, expr)
+		mlil_func = self.function.medium_level_il
+		assert mlil_func is not None, "self.function.medium_level_il is None"
+		return mediumlevelil.MediumLevelILInstruction.create(mlil_func, expr)
 
 	@property
 	def mlil(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
@@ -686,17 +436,17 @@ class LowLevelILInstruction:
 	@property
 	def mlils(self) -> List['mediumlevelil.MediumLevelILInstruction']:
 		result = []
-		for expr in self._function.get_medium_level_il_expr_indexes(self.expr_index):
-			result.append(mediumlevelil.MediumLevelILInstruction(self._function.medium_level_il, expr))
+		for expr in self.function.get_medium_level_il_expr_indexes(self.expr_index):
+			result.append(mediumlevelil.MediumLevelILInstruction.create(self.function.medium_level_il, expr))
 		return result
 
 	@property
 	def mapped_medium_level_il(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
 		"""Gets the mapped medium level IL expression corresponding to this expression"""
-		expr = self._function.get_mapped_medium_level_il_expr_index(self.expr_index)
+		expr = self.function.get_mapped_medium_level_il_expr_index(self.expr_index)
 		if expr is None:
 			return None
-		return mediumlevelil.MediumLevelILInstruction(self._function.mapped_medium_level_il, expr)
+		return mediumlevelil.MediumLevelILInstruction.create(self.function.mapped_medium_level_il, expr)
 
 	@property
 	def mmlil(self) -> Optional['mediumlevelil.MediumLevelILInstruction']:
@@ -718,46 +468,55 @@ class LowLevelILInstruction:
 		result = set()
 		for mlil_expr in self.mlils:
 			for hlil_expr in mlil_expr.hlils:
-				result.add(hlil_expr)
+				try:
+					result.add(hlil_expr)
+				except:
+					assert False, f"mlil_expr.hlils returned list of lists: {hlil_expr} {type(hlil_expr)}"
 		return list(result)
 
 	@property
 	def value(self) -> 'variable.RegisterValue':
 		"""Value of expression if constant or a known value (read-only)"""
-		value = core.BNGetLowLevelILExprValue(self._function.handle, self.expr_index)
-		return variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		value = core.BNGetLowLevelILExprValue(self.function.handle, self.expr_index)
+		return variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 
 	@property
 	def possible_values(self) -> 'variable.PossibleValueSet':
 		"""Possible values of expression using path-sensitive static data flow analysis (read-only)"""
-		value = core.BNGetLowLevelILPossibleExprValues(self._function.handle, self.expr_index, None, 0)
-		result = variable.PossibleValueSet(self._function.arch, value)
+		value = core.BNGetLowLevelILPossibleExprValues(self.function.handle, self.expr_index, None, 0)
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	@property
-	def prefix_operands(self) -> List[Any]:
+	def operands(self) -> Generator[LowLevelILOperandType, None, None]:
+		for operand_name in self.operand_names:
+			assert hasattr(self, operand_name), f"No operand '{operand_name}' for instruction {repr(self)}({self.operation})"
+			yield self.__getattribute__(operand_name)
+
+	@property
+	def prefix_operands(self) -> List[LowLevelILOperandType]:
 		"""All operands in the expression tree in prefix order"""
-		# TODO: There is probably a much better type hint we can provide here
-		result = [LowLevelILOperationAndSize(self._operation, self._size)]
-		for operand in self._operands:
+		result:List[LowLevelILOperandType] = [LowLevelILOperationAndSize(self.instr.operation, self.instr.size)]
+		for operand in self.operands:
 			if isinstance(operand, LowLevelILInstruction):
-				result += operand.prefix_operands
+				assert id(self) != id(operand), f"circular reference {operand}({repr(operand)}) is {self}({repr(self)})"
+				result.extend(operand.prefix_operands)
 			else:
 				result.append(operand)
 		return result
 
 	@property
-	def postfix_operands(self) -> List[Any]:
+	def postfix_operands(self) -> List[LowLevelILOperandType]:
 		"""All operands in the expression tree in postfix order"""
-		# TODO: There is probably a much better type hint we can provide here
-		result = []
-		for operand in self._operands:
+		result:List[LowLevelILOperandType] = []
+		for operand in self.operands:
 			if isinstance(operand, LowLevelILInstruction):
-				result += operand.postfix_operands
+				assert id(self) != id(operand), f"circular reference {operand}({repr(operand)}) is {self}({repr(self)})"
+				result.extend(operand.postfix_operands)
 			else:
 				result.append(operand)
-		result.append(LowLevelILOperationAndSize(self._operation, self._size))
+		result.append(LowLevelILOperationAndSize(self.instr.operation, self.instr.size))
 		return result
 
 	def get_possible_values(self, options:List[DataFlowQueryOption]=[]) -> variable.PossibleValueSet:
@@ -766,109 +525,109 @@ class LowLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetLowLevelILPossibleExprValues(self._function.handle, self.expr_index, option_array, len(options))
-		result = variable.PossibleValueSet(self._function.arch, value)
+		value = core.BNGetLowLevelILPossibleExprValues(self.function.handle, self.expr_index, option_array, len(options))
+		result = variable.PossibleValueSet(self.function.arch, value)
 		core.BNFreePossibleValueSet(value)
 		return result
 
 	def get_reg_value(self, reg:'architecture.RegisterType') -> variable.RegisterValue:
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_reg_value on function with Architecture set to None")
-		reg = self._function.arch.get_reg_index(reg)
-		value = core.BNGetLowLevelILRegisterValueAtInstruction(self._function.handle, reg, self._instr_index)
-		return variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetLowLevelILRegisterValueAtInstruction(self.function.handle, reg, self.instr_index)
+		return variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 
 	def get_reg_value_after(self, reg:'architecture.RegisterType') -> variable.RegisterValue:
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_reg_value_after on function with Architecture set to None")
-		reg = self._function.arch.get_reg_index(reg)
-		value = core.BNGetLowLevelILRegisterValueAfterInstruction(self._function.handle, reg, self._instr_index)
-		return variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		reg = self.function.arch.get_reg_index(reg)
+		value = core.BNGetLowLevelILRegisterValueAfterInstruction(self.function.handle, reg, self.instr_index)
+		return variable.RegisterValue.from_BNRegisterValue(value, self.function.arch)
 
 	def get_possible_reg_values(self, reg:'architecture.RegisterType', options:List[DataFlowQueryOption]=[]) -> 'variable.PossibleValueSet':
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_possible_reg_values on function with Architecture set to None")
-		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.BNGetLowLevelILPossibleRegisterValuesAtInstruction(self._function.handle, reg, self._instr_index,
+		value = core.BNGetLowLevelILPossibleRegisterValuesAtInstruction(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':
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_possible_reg_values_after on function with Architecture set to None")
-		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.BNGetLowLevelILPossibleRegisterValuesAfterInstruction(self._function.handle, reg, self._instr_index,
+		value = core.BNGetLowLevelILPossibleRegisterValuesAfterInstruction(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':
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_flag_value on function with Architecture set to None")
-		flag = self._function.arch.get_flag_index(flag)
-		value = core.BNGetLowLevelILFlagValueAtInstruction(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.BNGetLowLevelILFlagValueAtInstruction(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':
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_flag_value_after on function with Architecture set to None")
-		flag = self._function.arch.get_flag_index(flag)
-		value = core.BNGetLowLevelILFlagValueAfterInstruction(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.BNGetLowLevelILFlagValueAfterInstruction(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':
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_possible_flag_values on function with Architecture set to None")
-		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.BNGetLowLevelILPossibleFlagValuesAtInstruction(self._function.handle, flag, self._instr_index,
+		value = core.BNGetLowLevelILPossibleFlagValuesAtInstruction(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':
-		if self._function.arch is None:
+		if self.function.arch is None:
 			raise Exception("Can not call get_possible_flag_values_after on function with Architecture set to None")
-		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.BNGetLowLevelILPossibleFlagValuesAfterInstruction(self._function.handle, flag, self._instr_index,
+		value = core.BNGetLowLevelILPossibleFlagValuesAfterInstruction(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.BNGetLowLevelILStackContentsAtInstruction(self._function.handle, offset, size, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		value = core.BNGetLowLevelILStackContentsAtInstruction(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.BNGetLowLevelILStackContentsAfterInstruction(self._function.handle, offset, size, self._instr_index)
-		result = variable.RegisterValue.from_BNRegisterValue(value, self._function.arch)
+		value = core.BNGetLowLevelILStackContentsAfterInstruction(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, options:List[DataFlowQueryOption]=[]) -> variable.PossibleValueSet:
@@ -877,9 +636,9 @@ class LowLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetLowLevelILPossibleStackContentsAtInstruction(self._function.handle, offset, size, self._instr_index,
+		value = core.BNGetLowLevelILPossibleStackContentsAtInstruction(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
 
@@ -889,68 +648,1747 @@ class LowLevelILInstruction:
 		for option in options:
 			option_array[idx] = option
 			idx += 1
-		value = core.BNGetLowLevelILPossibleStackContentsAfterInstruction(self._function.handle, offset, size, self._instr_index,
+		value = core.BNGetLowLevelILPossibleStackContentsAfterInstruction(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
 
 	@property
-	def function(self) -> 'LowLevelILFunction':
-		return self._function
+	def flags(self) -> Optional['architecture.FlagWriteTypeName']:
+		return self.function.arch.get_flag_write_type_name(architecture.FlagWriteTypeIndex(self.instr.flags))
+
+	def get_reg(self, operand_index:int) -> ILRegister:
+		return ILRegister(self.function.arch, architecture.RegisterIndex(self.instr.operands[operand_index]))
+
+	def get_flag(self, operand_index:int) -> ILFlag:
+		return ILFlag(self.function.arch, architecture.FlagIndex(self.instr.operands[operand_index]))
+
+	def get_intrinsic(self, operand_index:int) -> ILIntrinsic:
+		return ILIntrinsic(self.function.arch, architecture.IntrinsicIndex(self.instr.operands[operand_index]))
+
+	def get_reg_stack(self, operand_index:int) -> ILRegisterStack:
+		return ILRegisterStack(self.function.arch, architecture.RegisterStackIndex(self.instr.operands[operand_index]))
+
+	def get_int(self, operand_index:int) -> int:
+		return (self.instr.operands[operand_index] & ((1 << 63) - 1)) - (self.instr.operands[operand_index] & (1 << 63))
+
+	def get_target_map(self, operand_index:int) -> Mapping[int, int]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		try:
+			value:Mapping[int, int] = {}
+			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.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_float(self, operand_index:int) -> float:
+		if self.instr.size == 4:
+			return struct.unpack("f", struct.pack("I", self.instr.operands[operand_index] & 0xffffffff))[0]
+		elif self.instr.size == 8:
+			return struct.unpack("d", struct.pack("Q", self.instr.operands[operand_index]))[0]
+		else:
+			return float(self.instr.operands[operand_index])
+
+	def get_expr(self, operand_index:int) -> 'LowLevelILInstruction':
+		return LowLevelILInstruction.create(self.function, self.instr.operands[operand_index], self.instr_index)
+
+	def get_reg_stack_adjust(self, operand_index:int) -> Mapping['architecture.RegisterStackName', int]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		result:Mapping['architecture.RegisterStackName', int] = {}
+		try:
+			for j in range(count.value // 2):
+				reg_stack = operand_list[j * 2]
+				adjust = operand_list[(j * 2) + 1]
+				if adjust & 0x80000000:
+					adjust |= ~0x80000000
+				result[self.function.arch.get_reg_stack_name(reg_stack)] = adjust
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_flag_ssa(self, operand_index1:int, operand_index2:int) -> SSAFlag:
+		return SSAFlag(ILFlag(self.function.arch, architecture.FlagIndex(self.instr.operands[operand_index1])),
+			self.instr.operands[operand_index2])
+
+	def get_reg_ssa(self, operand_index1:int, operand_index2:int) -> SSARegister:
+		return SSARegister(ILRegister(self.function.arch,
+			architecture.RegisterIndex(self.instr.operands[operand_index1])),
+			self.instr.operands[operand_index2])
+
+	def get_reg_stack_ssa(self, operand_index1:int, operand_index2:int) -> SSARegisterStack:
+		reg_stack = ILRegisterStack(self.function.arch,
+			architecture.RegisterStackIndex(self.instr.operands[operand_index1]))
+		return SSARegisterStack(reg_stack, self.instr.operands[operand_index2])
+
+	def get_sem_class(self, operand_index:int) -> ILSemanticFlagClass:
+		return ILSemanticFlagClass(self.function.arch,
+			architecture.SemanticClassIndex(self.instr.operands[operand_index]))
+
+	def get_sem_group(self, operand_index:int) -> ILSemanticFlagGroup:
+		return ILSemanticFlagGroup(self.function.arch,
+			architecture.SemanticGroupIndex(self.instr.operands[operand_index]))
+
+	def get_cond(self, operand_index:int) -> LowLevelILFlagCondition:
+		return LowLevelILFlagCondition(self.instr.operands[operand_index])
+
+	def get_int_list(self, operand_index:int) -> List[int]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		result:List[int] = []
+		try:
+			for j in range(count.value):
+				result.append(operand_list[j])
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_expr_list(self, operand_index:int) -> List['LowLevelILInstruction']:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		result = []
+		try:
+			for j in range(count.value):
+				result.append(LowLevelILInstruction.create(self.function, operand_list[j], None))
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_reg_or_flag_list(self, operand_index:int) -> List[Union[ILFlag, ILRegister]]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+
+		result:List[Union[ILFlag, ILRegister]] = []
+		try:
+			for j in range(count.value):
+				if (operand_list[j] & (1 << 32)) != 0:
+					result.append(ILFlag(self.function.arch, operand_list[j] & 0xffffffff))
+				else:
+					result.append(ILRegister(self.function.arch, operand_list[j] & 0xffffffff))
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_reg_ssa_list(self, operand_index:int) -> List[SSARegister]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		result = []
+		try:
+			for j in range(count.value // 2):
+				reg = operand_list[j * 2]
+				reg_version = operand_list[(j * 2) + 1]
+				result.append(SSARegister(ILRegister(self.function.arch, reg), reg_version))
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_reg_stack_ssa_list(self, operand_index:int) -> List[SSARegisterStack]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		result:List[SSARegisterStack] = []
+		try:
+			for j in range(count.value // 2):
+				reg_stack = operand_list[j * 2]
+				reg_version = operand_list[(j * 2) + 1]
+				result.append(SSARegisterStack(ILRegisterStack(self.function.arch, reg_stack), reg_version))
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_flag_ssa_list(self, operand_index:int) -> List[SSAFlag]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		try:
+			result:List[SSAFlag] = []
+			for j in range(count.value // 2):
+				flag = operand_list[j * 2]
+				flag_version = operand_list[(j * 2) + 1]
+				result.append(SSAFlag(ILFlag(self.function.arch, flag), flag_version))
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+	def get_reg_or_flag_ssa_list(self, operand_index:int) -> List[SSARegisterOrFlag]:
+		count = ctypes.c_ulonglong()
+		operand_list = core.BNLowLevelILGetOperandList(self.function.handle, self.expr_index, operand_index, count)
+		assert operand_list is not None, "core.BNLowLevelILGetOperandList returned None"
+		result:List[SSARegisterOrFlag] = []
+		try:
+			for j in range(count.value // 2):
+				if (operand_list[j * 2] & (1 << 32)) != 0:
+					reg_or_flag = ILFlag(self.function.arch, operand_list[j * 2] & 0xffffffff)
+				else:
+					reg_or_flag = ILRegister(self.function.arch, operand_list[j * 2] & 0xffffffff)
+				reg_version = operand_list[(j * 2) + 1]
+				result.append(SSARegisterOrFlag(reg_or_flag, reg_version))
+			return result
+		finally:
+			core.BNLowLevelILFreeOperandList(operand_list)
+
+
+@dataclass(frozen=True, repr=False)
+class Terminal(LowLevelILInstruction):
+	"""This class indicates that the instruction ends a BasicBlock"""
+	pass
+
+@dataclass(frozen=True, repr=False)
+class BinaryOperation(LowLevelILInstruction):
+	operand_names = tuple(['left', 'right'])
 
 	@property
-	def expr_index(self) -> ExpressionIndex:
-		return self._expr_index
+	def left(self) -> LowLevelILInstruction:
+		return self.get_expr(0)
 
 	@property
-	def instr_index(self) -> Optional[InstructionIndex]:
-		return self._instr_index
+	def right(self) -> LowLevelILInstruction:
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class UnaryOperation(LowLevelILInstruction):
+	operand_names = tuple(['src'])
 
 	@property
-	def operation(self) -> LowLevelILOperation:
-		return self._operation
+	def src(self) -> LowLevelILInstruction:
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class Arithmetic(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Signed(LowLevelILInstruction):
+	"""The operation is a signed operation"""
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Carry(LowLevelILInstruction):
+	"""Arithmetic with carry operation"""
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Comparison(BinaryOperation):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Constant(LowLevelILInstruction):
+	operand_names = tuple(['constant'])
+
+	def __int__(self):
+		return self.constant
+
+	def __bool__(self):
+		return self.constant != 0
+
+	def __eq__(self, other):
+		return int(self) == int(other)
+
+	def __ne__(self, other):
+		return int(self) != int(other)
+
+	def __lt__(self, other):
+		return int(self) < int(other)
+
+	def __gt__(self, other):
+		return int(self) > int(other)
+
+	def __le__(self, other):
+		return int(self) <= int(other)
+
+	def __ge__(self, other):
+		return int(self) >= int(other)
 
 	@property
-	def size(self) -> int:
-		return self._size
+	def constant(self) -> int:
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class FloatingPoint(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class ControlFlow(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Memory(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class Return(Terminal):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class RegisterStack(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class SSA(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class StackOperation(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class SetReg(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class DoublePrecision(LowLevelILInstruction):
+	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 Call(LowLevelILInstruction):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILNop(LowLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILPop(StackOperation):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILNoret(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSyscall(Call):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILBp(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILUndef(Terminal):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILUnimpl(LowLevelILInstruction):
+	operand_names = tuple()
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILNeg(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILNot(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSx(UnaryOperation, Arithmetic):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILZx(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILLow_part(UnaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILJump(ControlFlow, Terminal):
+	operand_names = tuple(["dest"])
 
 	@property
-	def address(self) -> int:
-		return self._address
+	def dest(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCall(Call):
+	operand_names = tuple(["dest"])
 
 	@property
-	def source_operand(self) -> Optional[ExpressionIndex]:
-		return self._source_operand
+	def dest(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILTailcall(Call):
+	operand_names = tuple(["dest"])
 
 	@property
-	def flags(self) -> Optional[str]:
-		return self._flags
+	def dest(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILRet(Return):
+	operand_names = tuple(["dest"])
 
 	@property
-	def operands(self) -> List[Any]:
-		return self._operands
+	def dest(self):
+		return self.get_expr(0)
 
 
-@dataclass(frozen=True)
-class LowLevelILExpr:
-	"""
-	``class LowLevelILExpr`` hold the index of IL Expressions.
+@dataclass(frozen=True, repr=False)
+class LowLevelILUnimpl_mem(Memory):
+	operand_names = tuple(["src"])
 
-	.. note:: This class shouldn't be instantiated directly. Rather the helper members of LowLevelILFunction should be \
-	used instead.
-	"""
-	index:ExpressionIndex
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFsqrt(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFneg(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFabs(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFloat_to_int(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILInt_to_float(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFloat_conv(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILRound_to_int(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFloor(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCeil(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFtrunc(FloatingPoint, Arithmetic):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILLoad(Memory):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILPush(StackOperation):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg(LowLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_reg(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_pop(RegisterStack):
+	operand_names = tuple(["stack"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_free_reg(RegisterStack):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_reg(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILConst(Constant):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILConst_ptr(Constant):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFloat_const(Constant, FloatingPoint):
+
+	@property
+	def constant(self) -> float:
+		return self.get_float(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFlag(LowLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_flag(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILGoto(Terminal):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFlag_group(LowLevelILInstruction):
+	operand_names = tuple(["semantic_group"])
+
+	@property
+	def semantic_group(self):
+		return self.get_sem_group(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILBool_to_int(LowLevelILInstruction):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILTrap(Terminal):
+	operand_names = tuple(["vector"])
+
+	@property
+	def vector(self):
+		return self.get_int(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_split_dest_ssa(SSA):
+	operand_names = tuple(["dest"])
+
+	@property
+	def dest(self):
+		return self.get_reg_ssa(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_dest_ssa(RegisterStack, SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_reg_stack_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_reg_stack_ssa(0, 2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_ssa(SSA):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_reg_ssa(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFlag_ssa(SSA):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_flag_ssa(0, 1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCall_param(SSA):
+	operand_names = tuple(["src"])
+
+	@property
+	def src(self):
+		return self.get_expr_list(0)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILMem_phi(Memory, SSA):
+	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 LowLevelILSet_reg(SetReg):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_reg(0)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_push(RegisterStack):
+	operand_names = tuple(["stack", "src"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack(0)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_flag(LowLevelILInstruction):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_flag(0)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILStore(Memory):
+	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 LowLevelILReg_split(LowLevelILInstruction):
+	operand_names = tuple(["hi", "lo"])
+
+	@property
+	def hi(self):
+		return self.get_reg(0)
+
+	@property
+	def lo(self):
+		return self.get_reg(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_rel(RegisterStack):
+	operand_names = tuple(["stack", "src"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack(0)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_free_rel(RegisterStack):
+	operand_names = tuple(["stack", "dest"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack(0)
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILExtern_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 LowLevelILFlag_bit(LowLevelILInstruction):
+	operand_names = tuple(["src", "bit"])
+
+	@property
+	def src(self):
+		return self.get_flag(0)
+
+	@property
+	def bit(self):
+		return self.get_int(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILAdd(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSub(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILAnd(BinaryOperation, Arithmetic):
+	pass
 
-	def __int__(self) -> int:
-		return self.index
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILOr(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILXor(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILLsl(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILLsr(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILAsr(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILRol(BinaryOperation, Arithmetic):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILRor(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILMul(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILMulu_dp(BinaryOperation, DoublePrecision):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILMuls_dp(BinaryOperation, DoublePrecision):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILDivu(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILDivu_dp(BinaryOperation, DoublePrecision):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILDivs(BinaryOperation, Arithmetic, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILDivs_dp(BinaryOperation, DoublePrecision, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILModu(BinaryOperation, Arithmetic):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILModu_dp(BinaryOperation, DoublePrecision):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILMods(BinaryOperation, Arithmetic, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILMods_dp(BinaryOperation, DoublePrecision, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_e(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_ne(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_slt(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_ult(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_sle(Comparison,Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_ule(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_sge(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_uge(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_sgt(Comparison, Signed):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCmp_ugt(Comparison):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILTest_bit(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFadd(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFsub(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFmul(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFdiv(BinaryOperation, Arithmetic, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_e(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_ne(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_lt(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_le(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_ge(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_gt(Comparison, FloatingPoint):
+	pass
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_o(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFcmp_uo(Comparison, FloatingPoint):
+	pass
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILJump_to(LowLevelILInstruction):
+	operand_names = tuple(["dest", "targets"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def targets(self):
+		return self.get_target_map(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFlag_cond(LowLevelILInstruction):
+	operand_names = tuple(["condition", "semantic_class"])
+
+	@property
+	def condition(self):
+		return self.get_cond(0)
+
+	@property
+	def semantic_class(self):
+		return self.get_sem_class(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILAdd_overflow(BinaryOperation, Arithmetic):
+	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 LowLevelILSet_reg_ssa(SetReg, SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_reg_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_expr(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_ssa_partial(SetReg, SSA):
+	operand_names = tuple(["full_reg", "src"])
+
+	@property
+	def full_reg(self):
+		return self.get_reg_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_reg(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_split_ssa(SetReg, SSA):
+	operand_names = tuple(["hi", "lo"])
+
+	@property
+	def hi(self):
+		return self.get_reg_ssa(0, 1)
+
+	@property
+	def lo(self):
+		return self.get_reg_ssa(2, 3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_abs_ssa(RegisterStack, SSA):
+	operand_names = tuple(["stack", "src"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_reg(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_free_abs_ssa(RegisterStack):
+	operand_names = tuple(["stack", "dest"])
+
+	@property
+	def stack(self):
+		return self.get_expr(0)
+
+	@property
+	def dest(self):
+		return self.get_reg(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_flag_ssa(SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_flag_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFlag_bit_ssa(SSA):
+	operand_names = tuple(["src", "bit"])
+
+	@property
+	def src(self):
+		return self.get_flag_ssa(0, 1)
+
+	@property
+	def bit(self):
+		return self.get_int(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCall_output_ssa(SSA):
+	operand_names = tuple(["dest_memory", "dest"])
+
+	@property
+	def dest_memory(self):
+		return self.get_int(0)
+
+	@property
+	def dest(self):
+		return self.get_reg_ssa_list(1)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCall_stack_ssa(SSA):
+	operand_names = tuple(["src", "src_memory"])
+
+	@property
+	def src(self):
+		return self.get_reg_ssa(0, 1)
+
+	@property
+	def src_memory(self):
+		return self.get_int(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILLoad_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 LowLevelILReg_phi(SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_reg_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_reg_ssa_list(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_phi(RegisterStack, SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_reg_stack_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_reg_stack_ssa_list(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILFlag_phi(SSA):
+	operand_names = tuple(["dest", "src"])
+
+	@property
+	def dest(self):
+		return self.get_flag_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_flag_ssa_list(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_reg_split(SetReg):
+	operand_names = tuple(["hi", "lo", "src"])
+
+	@property
+	def hi(self):
+		return self.get_reg(0)
+
+	@property
+	def lo(self):
+		return self.get_reg(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_reg_stack_rel(RegisterStack):
+	operand_names = tuple(["stack", "dest", "src"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack(0)
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSbb(Carry):
+	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 LowLevelILAdc(Carry):
+	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 LowLevelILRlc(Carry):
+	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 LowLevelILRrc(Carry):
+	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 LowLevelILCall_stack_adjust(Call):
+	operand_names = tuple(["dest", "stack_adjustment", "reg_stack_adjustments"])
+
+	@property
+	def dest(self):
+		return self.get_expr(0)
+
+	@property
+	def stack_adjustment(self):
+		return self.get_int(1)
+
+	@property
+	def reg_stack_adjustments(self):
+		return self.get_reg_stack_adjust(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILIf(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 LowLevelILIntrinsic(LowLevelILInstruction):
+	operand_names = tuple(["output", "intrinsic", "param"])
+
+	@property
+	def output(self):
+		return self.get_reg_or_flag_list(0)
+
+	@property
+	def intrinsic(self):
+		return self.get_intrinsic(2)
+
+	@property
+	def param(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILIntrinsic_ssa(SSA):
+	operand_names = tuple(["output", "intrinsic", "param"])
+
+	@property
+	def output(self):
+		return self.get_reg_or_flag_ssa_list(0)
+
+	@property
+	def intrinsic(self):
+		return self.get_intrinsic(2)
+
+	@property
+	def param(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_reg_ssa_partial(SetReg, SSA):
+	operand_names = tuple(["full_reg", "dest", "src"])
+
+	@property
+	def full_reg(self):
+		return self.get_reg_ssa(0, 1)
+
+	@property
+	def dest(self):
+		return self.get_reg(2)
+
+	@property
+	def src(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_reg_split_ssa(SetReg, SSA):
+	operand_names = tuple(["hi", "lo", "src"])
+
+	@property
+	def hi(self):
+		return self.get_expr(0)
+
+	@property
+	def lo(self):
+		return self.get_expr(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_reg_stack_abs_ssa(RegisterStack, SSA):
+	operand_names = tuple(["stack", "dest", "src"])
+
+	@property
+	def stack(self):
+		return self.get_expr(0)
+
+	@property
+	def dest(self):
+		return self.get_reg(1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_rel_ssa(RegisterStack, SSA):
+	operand_names = tuple(["stack", "src", "top"])
+
+	@property
+	def stack(self):
+		return self.get_reg_stack_ssa(0, 1)
+
+	@property
+	def src(self):
+		return self.get_expr(2)
+
+	@property
+	def top(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILReg_stack_free_rel_ssa(RegisterStack, SSA):
+	operand_names = tuple(["stack", "dest", "top"])
+
+	@property
+	def stack(self):
+		return self.get_expr(0)
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def top(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSyscall_ssa(Call, SSA):
+	operand_names = tuple(["output", "stack", "param"])
+
+	@property
+	def output(self):
+		return self.get_expr(0)
+
+	@property
+	def stack(self):
+		return self.get_expr(1)
+
+	@property
+	def param(self):
+		return self.get_expr(2)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILSet_reg_stack_rel_ssa(RegisterStack, SSA):
+	operand_names = tuple(["stack", "dest", "top", "src"])
+
+	@property
+	def stack(self):
+		return self.get_expr(0)
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def top(self):
+		return self.get_expr(2)
+
+	@property
+	def src(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILCall_ssa(Call, SSA):
+	operand_names = tuple(["output", "dest", "stack", "param"])
+
+	@property
+	def output(self):
+		return self.get_expr(0)
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def stack(self):
+		return self.get_expr(2)
+
+	@property
+	def param(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILTailcall_ssa(Call, SSA, Terminal):
+	operand_names = tuple(["output", "dest", "stack", "param"])
+
+	@property
+	def output(self):
+		return self.get_expr(0)
+
+	@property
+	def dest(self):
+		return self.get_expr(1)
+
+	@property
+	def stack(self):
+		return self.get_expr(2)
+
+	@property
+	def param(self):
+		return self.get_expr(3)
+
+
+@dataclass(frozen=True, repr=False)
+class LowLevelILStore_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)
+
+
+
+
+
+ILInstruction:Mapping[LowLevelILOperation, LowLevelILInstruction] = {  # type: ignore
+	LowLevelILOperation.LLIL_NOP: LowLevelILNop,                                        #  [],
+	LowLevelILOperation.LLIL_SET_REG: LowLevelILSet_reg,                                #  [("dest", "reg"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_SPLIT: LowLevelILSet_reg_split,                    #  [("hi", "reg"), ("lo", "reg"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_STACK_REL: LowLevelILSet_reg_stack_rel,            #  [("stack", "reg_stack"), ("dest", "expr"), ("src", "expr")],
+	LowLevelILOperation.LLIL_REG_STACK_PUSH: LowLevelILReg_stack_push,                  #  [("stack", "reg_stack"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_FLAG: LowLevelILSet_flag,                              #  [("dest", "flag"), ("src", "expr")],
+	LowLevelILOperation.LLIL_LOAD: LowLevelILLoad,                                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_STORE: LowLevelILStore,                                    #  [("dest", "expr"), ("src", "expr")],
+	LowLevelILOperation.LLIL_PUSH: LowLevelILPush,                                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_POP: LowLevelILPop,                                        #  [],
+	LowLevelILOperation.LLIL_REG: LowLevelILReg,                                        #  [("src", "reg")],
+	LowLevelILOperation.LLIL_REG_SPLIT: LowLevelILReg_split,                            #  [("hi", "reg"), ("lo", "reg")],
+	LowLevelILOperation.LLIL_REG_STACK_REL: LowLevelILReg_stack_rel,                    #  [("stack", "reg_stack"), ("src", "expr")],
+	LowLevelILOperation.LLIL_REG_STACK_POP: LowLevelILReg_stack_pop,                    #  [("stack", "reg_stack")],
+	LowLevelILOperation.LLIL_REG_STACK_FREE_REG: LowLevelILReg_stack_free_reg,          #  [("dest", "reg")],
+	LowLevelILOperation.LLIL_REG_STACK_FREE_REL: LowLevelILReg_stack_free_rel,          #  [("stack", "reg_stack"), ("dest", "expr")],
+	LowLevelILOperation.LLIL_CONST: LowLevelILConst,                                    #  [("constant", "int")],
+	LowLevelILOperation.LLIL_CONST_PTR: LowLevelILConst_ptr,                            #  [("constant", "int")],
+	LowLevelILOperation.LLIL_EXTERN_PTR: LowLevelILExtern_ptr,                          #  [("constant", "int"), ("offset", "int")],
+	LowLevelILOperation.LLIL_FLOAT_CONST: LowLevelILFloat_const,                        #  [("constant", "float")],
+	LowLevelILOperation.LLIL_FLAG: LowLevelILFlag,                                      #  [("src", "flag")],
+	LowLevelILOperation.LLIL_FLAG_BIT: LowLevelILFlag_bit,                              #  [("src", "flag"), ("bit", "int")],
+	LowLevelILOperation.LLIL_ADD: LowLevelILAdd,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_ADC: LowLevelILAdc,                                        #  [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	LowLevelILOperation.LLIL_SUB: LowLevelILSub,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_SBB: LowLevelILSbb,                                        #  [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	LowLevelILOperation.LLIL_AND: LowLevelILAnd,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_OR: LowLevelILOr,                                          #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_XOR: LowLevelILXor,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_LSL: LowLevelILLsl,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_LSR: LowLevelILLsr,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_ASR: LowLevelILAsr,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_ROL: LowLevelILRol,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_RLC: LowLevelILRlc,                                        #  [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	LowLevelILOperation.LLIL_ROR: LowLevelILRor,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_RRC: LowLevelILRrc,                                        #  [("left", "expr"), ("right", "expr"), ("carry", "expr")],
+	LowLevelILOperation.LLIL_MUL: LowLevelILMul,                                        #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_MULU_DP: LowLevelILMulu_dp,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_MULS_DP: LowLevelILMuls_dp,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_DIVU: LowLevelILDivu,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_DIVU_DP: LowLevelILDivu_dp,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_DIVS: LowLevelILDivs,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_DIVS_DP: LowLevelILDivs_dp,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_MODU: LowLevelILModu,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_MODU_DP: LowLevelILModu_dp,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_MODS: LowLevelILMods,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_MODS_DP: LowLevelILMods_dp,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_NEG: LowLevelILNeg,                                        #  [("src", "expr")],
+	LowLevelILOperation.LLIL_NOT: LowLevelILNot,                                        #  [("src", "expr")],
+	LowLevelILOperation.LLIL_SX: LowLevelILSx,                                          #  [("src", "expr")],
+	LowLevelILOperation.LLIL_ZX: LowLevelILZx,                                          #  [("src", "expr")],
+	LowLevelILOperation.LLIL_LOW_PART: LowLevelILLow_part,                              #  [("src", "expr")],
+	LowLevelILOperation.LLIL_JUMP: LowLevelILJump,                                      #  [("dest", "expr")],
+	LowLevelILOperation.LLIL_JUMP_TO: LowLevelILJump_to,                                #  [("dest", "expr"), ("targets", "target_map")],
+	LowLevelILOperation.LLIL_CALL: LowLevelILCall,                                      #  [("dest", "expr")],
+	LowLevelILOperation.LLIL_CALL_STACK_ADJUST: LowLevelILCall_stack_adjust,            #  [("dest", "expr"), ("stack_adjustment", "int"), ("reg_stack_adjustments", "reg_stack_adjust")],
+	LowLevelILOperation.LLIL_TAILCALL: LowLevelILTailcall,                              #  [("dest", "expr")],
+	LowLevelILOperation.LLIL_RET: LowLevelILRet,                                        #  [("dest", "expr")],
+	LowLevelILOperation.LLIL_NORET: LowLevelILNoret,                                    #  [],
+	LowLevelILOperation.LLIL_IF: LowLevelILIf,                                          #  [("condition", "expr"), ("true", "int"), ("false", "int")],
+	LowLevelILOperation.LLIL_GOTO: LowLevelILGoto,                                      #  [("dest", "int")],
+	LowLevelILOperation.LLIL_FLAG_COND: LowLevelILFlag_cond,                            #  [("condition", "cond"), ("semantic_class", "sem_class")],
+	LowLevelILOperation.LLIL_FLAG_GROUP: LowLevelILFlag_group,                          #  [("semantic_group", "sem_group")],
+	LowLevelILOperation.LLIL_CMP_E: LowLevelILCmp_e,                                    #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_NE: LowLevelILCmp_ne,                                  #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_SLT: LowLevelILCmp_slt,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_ULT: LowLevelILCmp_ult,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_SLE: LowLevelILCmp_sle,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_ULE: LowLevelILCmp_ule,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_SGE: LowLevelILCmp_sge,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_UGE: LowLevelILCmp_uge,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_SGT: LowLevelILCmp_sgt,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_CMP_UGT: LowLevelILCmp_ugt,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_TEST_BIT: LowLevelILTest_bit,                              #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_BOOL_TO_INT: LowLevelILBool_to_int,                        #  [("src", "expr")],
+	LowLevelILOperation.LLIL_ADD_OVERFLOW: LowLevelILAdd_overflow,                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_SYSCALL: LowLevelILSyscall,                                #  [],
+	LowLevelILOperation.LLIL_INTRINSIC: LowLevelILIntrinsic,                            #  [("output", "reg_or_flag_list"), ("intrinsic", "intrinsic"), ("param", "expr")],
+	LowLevelILOperation.LLIL_INTRINSIC_SSA: LowLevelILIntrinsic_ssa,                    #  [("output", "reg_or_flag_ssa_list"), ("intrinsic", "intrinsic"), ("param", "expr")],
+	LowLevelILOperation.LLIL_BP: LowLevelILBp,                                          #  [],
+	LowLevelILOperation.LLIL_TRAP: LowLevelILTrap,                                      #  [("vector", "int")],
+	LowLevelILOperation.LLIL_UNDEF: LowLevelILUndef,                                    #  [],
+	LowLevelILOperation.LLIL_UNIMPL: LowLevelILUnimpl,                                  #  [],
+	LowLevelILOperation.LLIL_UNIMPL_MEM: LowLevelILUnimpl_mem,                          #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FADD: LowLevelILFadd,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FSUB: LowLevelILFsub,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FMUL: LowLevelILFmul,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FDIV: LowLevelILFdiv,                                      #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FSQRT: LowLevelILFsqrt,                                    #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FNEG: LowLevelILFneg,                                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FABS: LowLevelILFabs,                                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FLOAT_TO_INT: LowLevelILFloat_to_int,                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_INT_TO_FLOAT: LowLevelILInt_to_float,                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FLOAT_CONV: LowLevelILFloat_conv,                          #  [("src", "expr")],
+	LowLevelILOperation.LLIL_ROUND_TO_INT: LowLevelILRound_to_int,                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FLOOR: LowLevelILFloor,                                    #  [("src", "expr")],
+	LowLevelILOperation.LLIL_CEIL: LowLevelILCeil,                                      #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FTRUNC: LowLevelILFtrunc,                                  #  [("src", "expr")],
+	LowLevelILOperation.LLIL_FCMP_E: LowLevelILFcmp_e,                                  #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_NE: LowLevelILFcmp_ne,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_LT: LowLevelILFcmp_lt,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_LE: LowLevelILFcmp_le,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_GE: LowLevelILFcmp_ge,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_GT: LowLevelILFcmp_gt,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_O: LowLevelILFcmp_o,                                  #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_FCMP_UO: LowLevelILFcmp_uo,                                #  [("left", "expr"), ("right", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_SSA: LowLevelILSet_reg_ssa,                        #  [("dest", "reg_ssa"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_SSA_PARTIAL: LowLevelILSet_reg_ssa_partial,        #  [("full_reg", "reg_ssa"), ("dest", "reg"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_SPLIT_SSA: LowLevelILSet_reg_split_ssa,            #  [("hi", "expr"), ("lo", "expr"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_STACK_REL_SSA: LowLevelILSet_reg_stack_rel_ssa,    #  [("stack", "expr"), ("dest", "expr"), ("top", "expr"), ("src", "expr")],
+	LowLevelILOperation.LLIL_SET_REG_STACK_ABS_SSA: LowLevelILSet_reg_stack_abs_ssa,    #  [("stack", "expr"), ("dest", "reg"), ("src", "expr")],
+	LowLevelILOperation.LLIL_REG_SPLIT_DEST_SSA: LowLevelILReg_split_dest_ssa,          #  [("dest", "reg_ssa")],
+	LowLevelILOperation.LLIL_REG_STACK_DEST_SSA: LowLevelILReg_stack_dest_ssa,          #  [("src", "reg_stack_ssa_dest_and_src")],
+	LowLevelILOperation.LLIL_REG_SSA: LowLevelILReg_ssa,                                #  [("src", "reg_ssa")],
+	LowLevelILOperation.LLIL_REG_SSA_PARTIAL: LowLevelILReg_ssa_partial,                #  [("full_reg", "reg_ssa"), ("src", "reg")],
+	LowLevelILOperation.LLIL_REG_SPLIT_SSA: LowLevelILReg_split_ssa,                    #  [("hi", "reg_ssa"), ("lo", "reg_ssa")],
+	LowLevelILOperation.LLIL_REG_STACK_REL_SSA: LowLevelILReg_stack_rel_ssa,            #  [("stack", "reg_stack_ssa"), ("src", "expr"), ("top", "expr")],
+	LowLevelILOperation.LLIL_REG_STACK_ABS_SSA: LowLevelILReg_stack_abs_ssa,            #  [("stack", "reg_stack_ssa"), ("src", "reg")],
+	LowLevelILOperation.LLIL_REG_STACK_FREE_REL_SSA: LowLevelILReg_stack_free_rel_ssa,  #  [("stack", "expr"), ("dest", "expr"), ("top", "expr")],
+	LowLevelILOperation.LLIL_REG_STACK_FREE_ABS_SSA: LowLevelILReg_stack_free_abs_ssa,  #  [("stack", "expr"), ("dest", "reg")],
+	LowLevelILOperation.LLIL_SET_FLAG_SSA: LowLevelILSet_flag_ssa,                      #  [("dest", "flag_ssa"), ("src", "expr")],
+	LowLevelILOperation.LLIL_FLAG_SSA: LowLevelILFlag_ssa,                              #  [("src", "flag_ssa")],
+	LowLevelILOperation.LLIL_FLAG_BIT_SSA: LowLevelILFlag_bit_ssa,                      #  [("src", "flag_ssa"), ("bit", "int")],
+	LowLevelILOperation.LLIL_CALL_SSA: LowLevelILCall_ssa,                              #  [("output", "expr"), ("dest", "expr"), ("stack", "expr"), ("param", "expr")],
+	LowLevelILOperation.LLIL_SYSCALL_SSA: LowLevelILSyscall_ssa,                        #  [("output", "expr"), ("stack", "expr"), ("param", "expr")],
+	LowLevelILOperation.LLIL_TAILCALL_SSA: LowLevelILTailcall_ssa,                      #  [("output", "expr"), ("dest", "expr"), ("stack", "expr"), ("param", "expr")],
+	LowLevelILOperation.LLIL_CALL_OUTPUT_SSA: LowLevelILCall_output_ssa,                #  [("dest_memory", "int"), ("dest", "reg_ssa_list")],
+	LowLevelILOperation.LLIL_CALL_STACK_SSA: LowLevelILCall_stack_ssa,                  #  [("src", "reg_ssa"), ("src_memory", "int")],
+	LowLevelILOperation.LLIL_CALL_PARAM: LowLevelILCall_param,                          #  [("src", "expr_list")],
+	LowLevelILOperation.LLIL_LOAD_SSA: LowLevelILLoad_ssa,                              #  [("src", "expr"), ("src_memory", "int")],
+	LowLevelILOperation.LLIL_STORE_SSA: LowLevelILStore_ssa,                            #  [("dest", "expr"), ("dest_memory", "int"), ("src_memory", "int"), ("src", "expr")],
+	LowLevelILOperation.LLIL_REG_PHI: LowLevelILReg_phi,                                #  [("dest", "reg_ssa"), ("src", "reg_ssa_list")],
+	LowLevelILOperation.LLIL_REG_STACK_PHI: LowLevelILReg_stack_phi,                    #  [("dest", "reg_stack_ssa"), ("src", "reg_stack_ssa_list")],
+	LowLevelILOperation.LLIL_FLAG_PHI: LowLevelILFlag_phi,                              #  [("dest", "flag_ssa"), ("src", "flag_ssa_list")],
+	LowLevelILOperation.LLIL_MEM_PHI: LowLevelILMem_phi,                                #  [("dest_memory", "int"), ("src_memory", "int_list")]
+}
 
 
 class LowLevelILFunction:
 	"""
-	``class LowLevelILFunction`` contains the list of LowLevelILExpr objects that make up a function. LowLevelILExpr
+	``class LowLevelILFunction`` contains the list of ExpressionIndex objects that make up a function. ExpressionIndex
 	objects can be added to the LowLevelILFunction by calling :func:`append` and passing the result of the various class
-	methods which return LowLevelILExpr objects.
+	methods which return ExpressionIndex objects.
 
 
 	LowLevelILFlagCondition values used as parameters in the :func:`flag_condition` method.
@@ -1011,12 +2449,10 @@ class LowLevelILFunction:
 			core.BNFreeLowLevelILFunction(self.handle)
 
 	def __repr__(self):
-		source_function = getattr(self, "source_function", None)
-		arch = getattr(source_function, "arch", None)
-		if arch and source_function:
-			return "<llil func: %s@%#x>" % (arch.name, self.__dict__['source_function'].start)
-		elif source_function:
-			return "<llil func: %#x>" % self.__dict__['source_function'].start
+		if self.source_function is not None and self.source_function.arch is not None:
+			return f"<llil func: {self.source_function.arch.name}@{self.source_function.start:#x}>"
+		elif self.source_function is not None:
+			return f"<llil func: {self.source_function.start:#x}>"
 		else:
 			return "<llil func: anonymous>"
 
@@ -1042,16 +2478,11 @@ class LowLevelILFunction:
 	def __getitem__(self, i):
 		if isinstance(i, slice) or isinstance(i, tuple):
 			raise IndexError("expected integer instruction index")
-		if isinstance(i, LowLevelILExpr):
-			return LowLevelILInstruction(self, i.index)
-		# for backwards compatibility
-		if isinstance(i, LowLevelILInstruction):
-			return i
 		if i < -len(self) or i >= len(self):
 			raise IndexError("index out of range")
 		if i < 0:
 			i = len(self) + i
-		return LowLevelILInstruction(self, core.BNGetLowLevelILIndexForInstruction(self.handle, i), i)
+		return LowLevelILInstruction.create(self, core.BNGetLowLevelILIndexForInstruction(self.handle, i), i)
 
 	def __setitem__(self, i, j):
 		raise IndexError("instruction modification not implemented")
@@ -1341,68 +2772,68 @@ class LowLevelILFunction:
 			_flags = architecture.FlagIndex(0)
 		else:
 			assert False, "flags type unsupported"
-		return LowLevelILExpr(core.BNLowLevelILAddExpr(self.handle, operation, size, _flags, a, b, c, d))
+		return ExpressionIndex(core.BNLowLevelILAddExpr(self.handle, operation, size, _flags, a, b, c, d))
 
 	def replace_expr(self, original:InstructionOrExpression, new:InstructionOrExpression) -> None:
 		"""
-		``replace_expr`` allows modification of LowLevelILExpressions but ONLY during lifting.
+		``replace_expr`` allows modification of ExpressionIndexessions but ONLY during lifting.
 
 		.. warning:: This function should ONLY be called as a part of a lifter. It will otherwise not do anything useful as there's no way to trigger re-analysis of IL levels at this time.
 
-		:param LowLevelILExpr original: the LowLevelILExpr to replace (may also be an expression index)
-		:param LowLevelILExpr new: the LowLevelILExpr to add to the current LowLevelILFunction (may also be an expression index)
+		:param ExpressionIndex original: the ExpressionIndex to replace (may also be an expression index)
+		:param ExpressionIndex new: the ExpressionIndex to add to the current LowLevelILFunction (may also be an expression index)
 		:rtype: None
 		"""
 		if isinstance(original, LowLevelILInstruction):
 			original = original.expr_index
-		elif isinstance(original, LowLevelILExpr):
-			original = original.index
+		elif isinstance(original, ExpressionIndex):
+			original = original
 
 		if isinstance(new, LowLevelILInstruction):
 			new = new.expr_index
-		elif isinstance(new, LowLevelILExpr):
-			new = new.index
+		elif isinstance(new, ExpressionIndex):
+			new = new
 
 		core.BNReplaceLowLevelILExpr(self.handle, original, new)
 
-	def append(self, expr:LowLevelILExpr) -> int:
+	def append(self, expr:ExpressionIndex) -> int:
 		"""
-		``append`` adds the LowLevelILExpr ``expr`` to the current LowLevelILFunction.
+		``append`` adds the ExpressionIndex ``expr`` to the current LowLevelILFunction.
 
-		:param LowLevelILExpr expr: the LowLevelILExpr to add to the current LowLevelILFunction
-		:return: number of LowLevelILExpr in the current function
+		:param ExpressionIndex expr: the ExpressionIndex to add to the current LowLevelILFunction
+		:return: number of ExpressionIndex in the current function
 		:rtype: int
 		"""
-		return core.BNLowLevelILAddInstruction(self.handle, expr.index)
+		return core.BNLowLevelILAddInstruction(self.handle, expr)
 
-	def nop(self) -> LowLevelILExpr:
+	def nop(self) -> ExpressionIndex:
 		"""
 		``nop`` no operation, this instruction does nothing
 
 		:return: The no operation expression
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_NOP)
 
-	def set_reg(self, size:int, reg:'architecture.RegisterType', value:LowLevelILExpr,
-		flags:Optional['architecture.FlagType']=None) -> LowLevelILExpr:
+	def set_reg(self, size:int, reg:'architecture.RegisterType', value:ExpressionIndex,
+		flags:Optional['architecture.FlagType']=None) -> ExpressionIndex:
 		"""
 		``set_reg`` sets the register ``reg`` of size ``size`` to the expression ``value``
 
 		:param int size: size of the register parameter in bytes
 		:param str reg: the register name
-		:param LowLevelILExpr value: an expression to set the register to
+		:param ExpressionIndex value: an expression to set the register to
 		:param str flags: which flags are set by this operation
 		:return: The expression ``reg = value``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_reg = ExpressionIndex(self.arch.get_reg_index(reg))
 		if flags is None:
 			flags = architecture.FlagIndex(0)
-		return self.expr(LowLevelILOperation.LLIL_SET_REG, _reg, value.index, size = size, flags = flags)
+		return self.expr(LowLevelILOperation.LLIL_SET_REG, _reg, value, size = size, flags = flags)
 
 	def set_reg_split(self, size:int, hi:'architecture.RegisterType', lo:'architecture.RegisterType',
-		value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+		value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``set_reg_split`` uses ``hi`` and ``lo`` as a single extended register setting ``hi:lo`` to the expression
 		``value``.
@@ -1410,125 +2841,125 @@ class LowLevelILFunction:
 		:param int size: size of the register parameter in bytes
 		:param str hi: the high register name
 		:param str lo: the low register name
-		:param LowLevelILExpr value: an expression to set the split registers to
+		:param ExpressionIndex value: an expression to set the split registers to
 		:param str flags: which flags are set by this operation
 		:return: The expression ``hi:lo = value``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_hi = ExpressionIndex(self.arch.get_reg_index(hi))
 		_lo = ExpressionIndex(self.arch.get_reg_index(lo))
 		if flags is None:
 			flags = architecture.FlagIndex(0)
-		return self.expr(LowLevelILOperation.LLIL_SET_REG_SPLIT, _hi, _lo, value.index, size = size, flags = flags)
+		return self.expr(LowLevelILOperation.LLIL_SET_REG_SPLIT, _hi, _lo, value, size = size, flags = flags)
 
-	def set_reg_stack_top_relative(self, size:int, reg_stack:'architecture.RegisterStackType', entry:LowLevelILExpr,
-		value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def set_reg_stack_top_relative(self, size:int, reg_stack:'architecture.RegisterStackType', entry:ExpressionIndex,
+		value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``set_reg_stack_top_relative`` sets the top-relative entry ``entry`` of size ``size`` in register
 		stack ``reg_stack`` to the expression ``value``
 
 		:param int size: size of the register parameter in bytes
 		:param str reg_stack: the register stack name
-		:param LowLevelILExpr entry: an expression for which stack entry to set
-		:param LowLevelILExpr value: an expression to set the entry to
+		:param ExpressionIndex entry: an expression for which stack entry to set
+		:param ExpressionIndex value: an expression to set the entry to
 		:param str flags: which flags are set by this operation
 		:return: The expression ``reg_stack[entry] = value``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_reg_stack = ExpressionIndex(self.arch.get_reg_stack_index(reg_stack))
 		if flags is None:
 			flags = architecture.FlagIndex(0)
-		return self.expr(LowLevelILOperation.LLIL_SET_REG_STACK_REL, _reg_stack, entry.index, value.index,
+		return self.expr(LowLevelILOperation.LLIL_SET_REG_STACK_REL, _reg_stack, entry, value,
 			size = size, flags = flags)
 
-	def reg_stack_push(self, size:int, reg_stack:'architecture.RegisterStackType', value:LowLevelILExpr,
-		flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def reg_stack_push(self, size:int, reg_stack:'architecture.RegisterStackType', value:ExpressionIndex,
+		flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``reg_stack_push`` pushes the expression ``value`` of size ``size`` onto the top of the register
 		stack ``reg_stack``
 
 		:param int size: size of the register parameter in bytes
 		:param str reg_stack: the register stack name
-		:param LowLevelILExpr value: an expression to push
+		:param ExpressionIndex value: an expression to push
 		:param str flags: which flags are set by this operation
 		:return: The expression ``reg_stack.push(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_reg_stack = ExpressionIndex(self.arch.get_reg_stack_index(reg_stack))
 		if flags is None:
 			flags = architecture.FlagIndex(0)
-		return self.expr(LowLevelILOperation.LLIL_REG_STACK_PUSH, _reg_stack, value.index, size = size, flags = flags)
+		return self.expr(LowLevelILOperation.LLIL_REG_STACK_PUSH, _reg_stack, value, size = size, flags = flags)
 
-	def set_flag(self, flag:'architecture.FlagName', value:LowLevelILExpr) -> LowLevelILExpr:
+	def set_flag(self, flag:'architecture.FlagName', value:ExpressionIndex) -> ExpressionIndex:
 		"""
-		``set_flag`` sets the flag ``flag`` to the LowLevelILExpr ``value``
+		``set_flag`` sets the flag ``flag`` to the ExpressionIndex ``value``
 
 		:param str flag: the low register name
-		:param LowLevelILExpr value: an expression to set the flag to
+		:param ExpressionIndex value: an expression to set the flag to
 		:return: The expression FLAG.flag = value
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_SET_FLAG, ExpressionIndex(self.arch.get_flag_by_name(flag)),
-			value.index)
+			value)
 
-	def load(self, size:int, addr:LowLevelILExpr) -> LowLevelILExpr:
+	def load(self, size:int, addr:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``load`` Reads ``size`` bytes from the expression ``addr``
 
 		:param int size: number of bytes to read
-		:param LowLevelILExpr addr: the expression to read memory from
+		:param ExpressionIndex addr: the expression to read memory from
 		:return: The expression ``[addr].size``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_LOAD, addr.index, size=size)
+		return self.expr(LowLevelILOperation.LLIL_LOAD, addr, size=size)
 
-	def store(self, size:int, addr:LowLevelILExpr, value:LowLevelILExpr, flags=None) -> LowLevelILExpr:
+	def store(self, size:int, addr:ExpressionIndex, value:ExpressionIndex, flags=None) -> ExpressionIndex:
 		"""
 		``store`` Writes ``size`` bytes to expression ``addr`` read from expression ``value``
 
 		:param int size: number of bytes to write
-		:param LowLevelILExpr addr: the expression to write to
-		:param LowLevelILExpr value: the expression to be written
+		:param ExpressionIndex addr: the expression to write to
+		:param ExpressionIndex value: the expression to be written
 		:param str flags: which flags are set by this operation
 		:return: The expression ``[addr].size = value``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_STORE, addr.index, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_STORE, addr, value, size=size, flags=flags)
 
-	def push(self, size:int, value:LowLevelILExpr) -> LowLevelILExpr:
+	def push(self, size:int, value:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``push`` writes ``size`` bytes from expression ``value`` to the stack, adjusting the stack by ``size``.
 
 		:param int size: number of bytes to write and adjust the stack by
-		:param LowLevelILExpr value: the expression to write
+		:param ExpressionIndex value: the expression to write
 		:return: The expression push(value)
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_PUSH, value.index, size=size)
+		return self.expr(LowLevelILOperation.LLIL_PUSH, value, size=size)
 
-	def pop(self, size:int) -> LowLevelILExpr:
+	def pop(self, size:int) -> ExpressionIndex:
 		"""
 		``pop`` reads ``size`` bytes from the stack, adjusting the stack by ``size``.
 
 		:param int size: number of bytes to read from the stack
 		:return: The expression ``pop``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_POP, size=size)
 
-	def reg(self, size:int, reg:'architecture.RegisterType') -> LowLevelILExpr:
+	def reg(self, size:int, reg:'architecture.RegisterType') -> ExpressionIndex:
 		"""
 		``reg`` returns a register of size ``size`` with name ``reg``
 
 		:param int size: the size of the register in bytes
 		:param str reg: the name of the register
 		:return: A register expression for the given string
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_reg = ExpressionIndex(self.arch.get_reg_index(reg))
 		return self.expr(LowLevelILOperation.LLIL_REG, _reg, size=size)
 
-	def reg_split(self, size:int, hi:'architecture.RegisterType', lo:'architecture.RegisterType') -> LowLevelILExpr:
+	def reg_split(self, size:int, hi:'architecture.RegisterType', lo:'architecture.RegisterType') -> ExpressionIndex:
 		"""
 		``reg_split`` combines registers of size ``size`` with names ``hi`` and ``lo``
 
@@ -1536,27 +2967,27 @@ class LowLevelILFunction:
 		:param str hi: register holding high part of value
 		:param str lo: register holding low part of value
 		:return: The expression ``hi:lo``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_hi = ExpressionIndex(self.arch.get_reg_index(hi))
 		_lo = ExpressionIndex(self.arch.get_reg_index(lo))
 		return self.expr(LowLevelILOperation.LLIL_REG_SPLIT, _hi, _lo, size=size)
 
-	def reg_stack_top_relative(self, size:int, reg_stack:'architecture.RegisterStackType', entry:LowLevelILExpr) -> LowLevelILExpr:
+	def reg_stack_top_relative(self, size:int, reg_stack:'architecture.RegisterStackType', entry:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``reg_stack_top_relative`` returns a register stack entry of size ``size`` at top-relative
 		location ``entry`` in register stack with name ``reg_stack``
 
 		:param int size: the size of the register in bytes
 		:param str reg_stack: the name of the register stack
-		:param LowLevelILExpr entry: an expression for which stack entry to fetch
+		:param ExpressionIndex entry: an expression for which stack entry to fetch
 		:return: The expression ``reg_stack[entry]``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_reg_stack = self.arch.get_reg_stack_index(reg_stack)
-		return self.expr(LowLevelILOperation.LLIL_REG_STACK_REL, _reg_stack, entry.index, size=size)
+		return self.expr(LowLevelILOperation.LLIL_REG_STACK_REL, _reg_stack, entry, size=size)
 
-	def reg_stack_pop(self, size:int, reg_stack:'architecture.RegisterStackType') -> LowLevelILExpr:
+	def reg_stack_pop(self, size:int, reg_stack:'architecture.RegisterStackType') -> ExpressionIndex:
 		"""
 		``reg_stack_pop`` returns the top entry of size ``size`` in register stack with name ``reg_stack``, and
 		removes the entry from the stack
@@ -1564,45 +2995,45 @@ class LowLevelILFunction:
 		:param int size: the size of the register in bytes
 		:param str reg_stack: the name of the register stack
 		:return: The expression ``reg_stack.pop``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		_reg_stack = ExpressionIndex(self.arch.get_reg_stack_index(reg_stack))
 		return self.expr(LowLevelILOperation.LLIL_REG_STACK_POP, _reg_stack, size=size)
 
-	def const(self, size:int, value:int) -> LowLevelILExpr:
+	def const(self, size:int, value:int) -> ExpressionIndex:
 		"""
 		``const`` returns an expression for the constant integer ``value`` with size ``size``
 
 		:param int size: the size of the constant in bytes
 		:param int value: integer value of the constant
 		:return: A constant expression of given value and size
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_CONST, ExpressionIndex(value), size=size)
 
-	def const_pointer(self, size:int, value:int) -> LowLevelILExpr:
+	def const_pointer(self, size:int, value:int) -> ExpressionIndex:
 		"""
 		``const_pointer`` returns an expression for the constant pointer ``value`` with size ``size``
 
 		:param int size: the size of the pointer in bytes
 		:param int value: address referenced by pointer
 		:return: A constant expression of given value and size
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_CONST_PTR, value, size=size)
 
-	def reloc_pointer(self, size:int, value:int) -> LowLevelILExpr:
+	def reloc_pointer(self, size:int, value:int) -> ExpressionIndex:
 		"""
 		``reloc_pointer`` returns an expression for the constant relocated pointer ``value`` with size ``size``
 
 		:param int size: the size of the pointer in bytes
 		:param int value: address referenced by pointer
 		:return: A constant expression of given value and size
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_EXTERN_PTR, value, size=size)
 
-	def float_const_raw(self, size:int, value:int) -> LowLevelILExpr:
+	def float_const_raw(self, size:int, value:int) -> ExpressionIndex:
 		"""
 		``float_const_raw`` returns an expression for the constant raw binary floating point
 		value ``value`` with size ``size``
@@ -1610,41 +3041,41 @@ class LowLevelILFunction:
 		:param int size: the size of the constant in bytes
 		:param int value: integer value for the raw binary representation of the constant
 		:return: A constant expression of given value and size
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_FLOAT_CONST, value, size=size)
 
-	def float_const_single(self, value:float) -> LowLevelILExpr:
+	def float_const_single(self, value:float) -> ExpressionIndex:
 		"""
 		``float_const_single`` returns an expression for the single precision floating point value ``value``
 
 		:param float value: float value for the constant
 		:return: A constant expression of given value and size
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_FLOAT_CONST, struct.unpack("I", struct.pack("f", value))[0], size=4)
 
-	def float_const_double(self, value:float) -> LowLevelILExpr:
+	def float_const_double(self, value:float) -> ExpressionIndex:
 		"""
 		``float_const_double`` returns an expression for the double precision floating point value ``value``
 
 		:param float value: float value for the constant
 		:return: A constant expression of given value and size
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_FLOAT_CONST, struct.unpack("Q", struct.pack("d", value))[0], size=8)
 
-	def flag(self, reg:'architecture.FlagName') -> LowLevelILExpr:
+	def flag(self, reg:'architecture.FlagName') -> ExpressionIndex:
 		"""
 		``flag`` returns a flag expression for the given flag name.
 
 		:param architecture.FlagName reg: name of the flag expression to retrieve
 		:return: A flag expression of given flag name
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_FLAG, self.arch.get_flag_by_name(reg))
 
-	def flag_bit(self, size:int, reg:'architecture.FlagName', bit:int) -> LowLevelILExpr:
+	def flag_bit(self, size:int, reg:'architecture.FlagName', bit:int) -> ExpressionIndex:
 		"""
 		``flag_bit`` sets the flag named ``reg`` and size ``size`` to the constant integer value ``bit``
 
@@ -1652,502 +3083,502 @@ class LowLevelILFunction:
 		:param str reg: flag value
 		:param int bit: integer value to set the bit to
 		:return: A constant expression of given value and size ``FLAG.reg = bit``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_FLAG_BIT, self.arch.get_flag_by_name(reg), bit, size=size)
 
-	def add(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def add(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``add`` adds expression ``a`` to expression ``b`` potentially setting flags ``flags`` and returning
 		an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``add.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ADD, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ADD, a, b, size=size, flags=flags)
 
-	def add_carry(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, carry:LowLevelILExpr,
-		flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def add_carry(self, size:int, a:ExpressionIndex, b:ExpressionIndex, carry:ExpressionIndex,
+		flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``add_carry`` adds with carry expression ``a`` to expression ``b`` potentially setting flags ``flags`` and
 		returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
-		:param LowLevelILExpr carry: Carry flag expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
+		:param ExpressionIndex carry: Carry flag expression
 		:param str flags: flags to set
 		:return: The expression ``adc.<size>{<flags>}(a, b, carry)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ADC, a.index, b.index, carry.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ADC, a, b, carry, size=size, flags=flags)
 
-	def sub(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def sub(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``sub`` subtracts expression ``b`` from expression ``a`` potentially setting flags ``flags`` and returning
 		an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``sub.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_SUB, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_SUB, a, b, size=size, flags=flags)
 
-	def sub_borrow(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, carry:LowLevelILExpr,
-		flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def sub_borrow(self, size:int, a:ExpressionIndex, b:ExpressionIndex, carry:ExpressionIndex,
+		flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``sub_borrow`` subtracts with borrow expression ``b`` from expression ``a`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
-		:param LowLevelILExpr carry: Carry flag expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
+		:param ExpressionIndex carry: Carry flag expression
 		:param str flags: flags to set
 		:return: The expression ``sbb.<size>{<flags>}(a, b, carry)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_SBB, a.index, b.index, carry.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_SBB, a, b, carry, size=size, flags=flags)
 
-	def and_expr(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def and_expr(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``and_expr`` bitwise and's expression ``a`` and expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``and.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_AND, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_AND, a, b, size=size, flags=flags)
 
-	def or_expr(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def or_expr(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``or_expr`` bitwise or's expression ``a`` and expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``or.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_OR, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_OR, a, b, size=size, flags=flags)
 
-	def xor_expr(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def xor_expr(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``xor_expr`` xor's expression ``a`` with expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``xor.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_XOR, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_XOR, a, b, size=size, flags=flags)
 
-	def shift_left(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def shift_left(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``shift_left`` shifts left expression ``a`` by expression ``b`` from expression ``a`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``lsl.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_LSL, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_LSL, a, b, size=size, flags=flags)
 
-	def logical_shift_right(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def logical_shift_right(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``logical_shift_right`` shifts logically right expression ``a`` by expression ``b`` potentially setting flags
 		``flags`` and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``lsr.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_LSR, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_LSR, a, b, size=size, flags=flags)
 
-	def arith_shift_right(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def arith_shift_right(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``arith_shift_right`` shifts arithmetic right expression ``a`` by expression ``b``  potentially setting flags
 		``flags`` and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``asr.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ASR, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ASR, a, b, size=size, flags=flags)
 
-	def rotate_left(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def rotate_left(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``rotate_left`` bitwise rotates left expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``rol.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ROL, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ROL, a, b, size=size, flags=flags)
 
-	def rotate_left_carry(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, carry:LowLevelILExpr,
-		flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def rotate_left_carry(self, size:int, a:ExpressionIndex, b:ExpressionIndex, carry:ExpressionIndex,
+		flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``rotate_left_carry`` bitwise rotates left with carry expression ``a`` by expression ``b`` potentially setting
 		flags ``flags`` and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
-		:param LowLevelILExpr carry: Carry flag expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
+		:param ExpressionIndex carry: Carry flag expression
 		:param str flags: optional, flags to set
 		:return: The expression ``rlc.<size>{<flags>}(a, b, carry)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_RLC, a.index, b.index, carry.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_RLC, a, b, carry, size=size, flags=flags)
 
-	def rotate_right(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def rotate_right(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``rotate_right`` bitwise rotates right expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``ror.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ROR, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ROR, a, b, size=size, flags=flags)
 
-	def rotate_right_carry(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, carry:LowLevelILExpr,
-		flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def rotate_right_carry(self, size:int, a:ExpressionIndex, b:ExpressionIndex, carry:ExpressionIndex,
+		flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``rotate_right_carry`` bitwise rotates right with carry expression ``a`` by expression ``b`` potentially setting
 		flags ``flags`` and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
-		:param LowLevelILExpr carry: Carry flag expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
+		:param ExpressionIndex carry: Carry flag expression
 		:param str flags: optional, flags to set
 		:return: The expression ``rrc.<size>{<flags>}(a, b, carry)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_RRC, a.index, b.index, carry.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_RRC, a, b, carry, size=size, flags=flags)
 
-	def mult(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mult(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mult`` multiplies expression ``a`` by expression ``b`` potentially setting flags ``flags`` and returning an
 		expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``sbc.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MUL, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MUL, a, b, size=size, flags=flags)
 
-	def mult_double_prec_signed(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mult_double_prec_signed(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mult_double_prec_signed`` multiplies signed with double precision expression ``a`` by expression ``b``
 		potentially setting flags ``flags`` and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``muls.dp.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MULS_DP, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MULS_DP, a, b, size=size, flags=flags)
 
-	def mult_double_prec_unsigned(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mult_double_prec_unsigned(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mult_double_prec_unsigned`` multiplies unsigned with double precision expression ``a`` by expression ``b``
 		potentially setting flags ``flags`` and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``mulu.dp.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MULU_DP, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MULU_DP, a, b, size=size, flags=flags)
 
-	def div_signed(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def div_signed(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``div_signed`` signed divide expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``divs.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_DIVS, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_DIVS, a, b, size=size, flags=flags)
 
-	def div_double_prec_signed(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def div_double_prec_signed(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``div_double_prec_signed`` signed double precision divide using expression ``a`` as a
 		single double precision register by expression ``b`` potentially  setting flags ``flags`` and returning an
 		expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``divs.dp.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_DIVS_DP, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_DIVS_DP, a, b, size=size, flags=flags)
 
-	def div_unsigned(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def div_unsigned(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``div_unsigned`` unsigned divide expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``divu.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_DIVU, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_DIVU, a, b, size=size, flags=flags)
 
-	def div_double_prec_unsigned(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def div_double_prec_unsigned(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``div_double_prec_unsigned`` unsigned double precision divide using expression ``a`` as
 		a single double precision register by expression ``b`` potentially  setting flags ``flags`` and returning an
 		expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``divu.dp.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_DIVU_DP, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_DIVU_DP, a, b, size=size, flags=flags)
 
-	def mod_signed(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mod_signed(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mod_signed`` signed modulus expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``mods.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MODS, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MODS, a, b, size=size, flags=flags)
 
-	def mod_double_prec_signed(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mod_double_prec_signed(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mod_double_prec_signed`` signed double precision modulus using expression ``a`` as a single
 		double precision register by expression ``b`` potentially  setting flags ``flags`` and returning an expression
 		of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``mods.dp.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MODS_DP, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MODS_DP, a, b, size=size, flags=flags)
 
-	def mod_unsigned(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mod_unsigned(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mod_unsigned`` unsigned modulus expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``modu.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MODU, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MODU, a, b, size=size, flags=flags)
 
-	def mod_double_prec_unsigned(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def mod_double_prec_unsigned(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``mod_double_prec_unsigned`` unsigned double precision modulus using expression ``a`` as
 		a single double precision register by expression ``b`` potentially  setting flags ``flags`` and returning an
 		expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: optional, flags to set
 		:return: The expression ``modu.dp.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_MODU_DP, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_MODU_DP, a, b, size=size, flags=flags)
 
-	def neg_expr(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def neg_expr(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``neg_expr`` two's complement sign negation of expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``neg.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_NEG, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_NEG, value, size=size, flags=flags)
 
-	def not_expr(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def not_expr(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``not_expr`` bitwise inverse of expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to bitwise invert
+		:param ExpressionIndex value: the expression to bitwise invert
 		:param str flags: optional, flags to set
 		:return: The expression ``not.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_NOT, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_NOT, value, size=size, flags=flags)
 
-	def sign_extend(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def sign_extend(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``sign_extend`` two's complement sign-extends the expression in ``value`` to ``size`` bytes
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to sign extend
+		:param ExpressionIndex value: the expression to sign extend
 		:param str flags: optional, flags to set
 		:return: The expression ``sx.<size>(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_SX, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_SX, value, size=size, flags=flags)
 
-	def zero_extend(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def zero_extend(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``zero_extend`` zero-extends the expression in ``value`` to ``size`` bytes
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to zero extend
+		:param ExpressionIndex value: the expression to zero extend
 		:return: The expression ``zx.<size>(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ZX, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ZX, value, size=size, flags=flags)
 
-	def low_part(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def low_part(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``low_part`` truncates ``value`` to ``size`` bytes
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to zero extend
+		:param ExpressionIndex value: the expression to zero extend
 		:return: The expression ``(value).<size>``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_LOW_PART, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_LOW_PART, value, size=size, flags=flags)
 
-	def jump(self, dest:LowLevelILExpr) -> LowLevelILExpr:
+	def jump(self, dest:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``jump`` returns an expression which jumps (branches) to the expression ``dest``
 
-		:param LowLevelILExpr dest: the expression to jump to
+		:param ExpressionIndex dest: the expression to jump to
 		:return: The expression ``jump(dest)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_JUMP, dest.index)
+		return self.expr(LowLevelILOperation.LLIL_JUMP, dest)
 
-	def call(self, dest:LowLevelILExpr) -> LowLevelILExpr:
+	def call(self, dest:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``call`` returns an expression which first pushes the address of the next instruction onto the stack then jumps
 		(branches) to the expression ``dest``
 
-		:param LowLevelILExpr dest: the expression to call
+		:param ExpressionIndex dest: the expression to call
 		:return: The expression ``call(dest)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CALL, dest.index)
+		return self.expr(LowLevelILOperation.LLIL_CALL, dest)
 
-	def call_stack_adjust(self, dest:LowLevelILExpr, stack_adjust:int) -> LowLevelILExpr:
+	def call_stack_adjust(self, dest:ExpressionIndex, stack_adjust:int) -> ExpressionIndex:
 		"""
 		``call_stack_adjust`` returns an expression which first pushes the address of the next instruction onto the stack
 		then jumps (branches) to the expression ``dest``. After the function exits, ``stack_adjust`` is added to the
 		stack pointer register.
 
-		:param LowLevelILExpr dest: the expression to call
+		:param ExpressionIndex dest: the expression to call
 		:return: The expression ``call(dest), stack += stack_adjust``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CALL_STACK_ADJUST, dest.index, stack_adjust)
+		return self.expr(LowLevelILOperation.LLIL_CALL_STACK_ADJUST, dest, stack_adjust)
 
-	def tailcall(self, dest:LowLevelILExpr) -> LowLevelILExpr:
+	def tailcall(self, dest:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``tailcall`` returns an expression which jumps (branches) to the expression ``dest``
 
-		:param LowLevelILExpr dest: the expression to jump to
+		:param ExpressionIndex dest: the expression to jump to
 		:return: The expression ``tailcall(dest)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_TAILCALL, dest.index)
+		return self.expr(LowLevelILOperation.LLIL_TAILCALL, dest)
 
-	def ret(self, dest:LowLevelILExpr) -> LowLevelILExpr:
+	def ret(self, dest:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``ret`` returns an expression which jumps (branches) to the expression ``dest``. ``ret`` is a special alias for
 		jump that makes the disassembler stop disassembling.
 
-		:param LowLevelILExpr dest: the expression to jump to
+		:param ExpressionIndex dest: the expression to jump to
 		:return: The expression ``jump(dest)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_RET, dest.index)
+		return self.expr(LowLevelILOperation.LLIL_RET, dest)
 
-	def no_ret(self) -> LowLevelILExpr:
+	def no_ret(self) -> ExpressionIndex:
 		"""
 		``no_ret`` returns an expression halts disassembly
 
 		:return: The expression ``noreturn``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_NORET)
 
 	def flag_condition(self, cond:Union[str, LowLevelILFlagCondition, int],
-		sem_class:Optional['architecture.SemanticClassType']=None) -> LowLevelILExpr:
+		sem_class:Optional['architecture.SemanticClassType']=None) -> ExpressionIndex:
 		"""
 		``flag_condition`` returns a flag_condition expression for the given LowLevelILFlagCondition
 
 		:param LowLevelILFlagCondition cond: Flag condition expression to retrieve
 		:param str sem_class: Optional semantic flag class
 		:return: A flag_condition expression
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		if isinstance(cond, str):
 			cond = LowLevelILFlagCondition[cond]
@@ -2165,520 +3596,520 @@ class LowLevelILFunction:
 
 		:param str sem_group: Semantic flag group to access
 		:return: A flag_group expression
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		group = self.arch.get_semantic_flag_group_index(sem_group)
 		return self.expr(LowLevelILOperation.LLIL_FLAG_GROUP, group)
 
-	def compare_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is equal to
 		expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_E, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_E, a, b, size = size)
 
-	def compare_not_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_not_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_not_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is not equal to
 		expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_NE, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_NE, a, b, size = size)
 
-	def compare_signed_less_than(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_signed_less_than(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_signed_less_than`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		signed less than expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_SLT, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_SLT, a, b, size = size)
 
-	def compare_unsigned_less_than(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_unsigned_less_than(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_unsigned_less_than`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		unsigned less than expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_ULT, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_ULT, a, b, size = size)
 
-	def compare_signed_less_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_signed_less_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_signed_less_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		signed less than or equal to expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_SLE, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_SLE, a, b, size = size)
 
-	def compare_unsigned_less_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_unsigned_less_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_unsigned_less_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		unsigned less than or equal to expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_ULE, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_ULE, a, b, size = size)
 
-	def compare_signed_greater_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_signed_greater_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_signed_greater_equal`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		signed greater than or equal to expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_SGE, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_SGE, a, b, size = size)
 
-	def compare_unsigned_greater_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_unsigned_greater_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_unsigned_greater_equal`` returns comparison expression of size ``size`` checking if expression ``a``
 		is unsigned greater than or equal to expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_UGE, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_UGE, a, b, size = size)
 
-	def compare_signed_greater_than(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_signed_greater_than(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_signed_greater_than`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		signed greater than or equal to expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_SGT, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_SGT, a, b, size = size)
 
-	def compare_unsigned_greater_than(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def compare_unsigned_greater_than(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``compare_unsigned_greater_than`` returns comparison expression of size ``size`` checking if expression ``a`` is
 		unsigned greater than or equal to expression ``b``
 
 		:param int size: size in bytes
-		:param LowLevelILExpr a: LHS of comparison
-		:param LowLevelILExpr b: RHS of comparison
+		:param ExpressionIndex a: LHS of comparison
+		:param ExpressionIndex b: RHS of comparison
 		:return: a comparison expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CMP_UGT, a.index, b.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_CMP_UGT, a, b, size = size)
 
-	def test_bit(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
-		return self.expr(LowLevelILOperation.LLIL_TEST_BIT, a.index, b.index, size = size)
+	def test_bit(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
+		return self.expr(LowLevelILOperation.LLIL_TEST_BIT, a, b, size = size)
 
-	def system_call(self) -> LowLevelILExpr:
+	def system_call(self) -> ExpressionIndex:
 		"""
 		``system_call`` return a system call expression.
 
 		:return: a system call expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_SYSCALL)
 
-	def intrinsic(self, outputs:List[Union[ILFlag, LowLevelILExpr]], intrinsic:'architecture.IntrinsicType',
-		params:List[LowLevelILExpr], flags:'architecture.FlagType'=None):
+	def intrinsic(self, outputs:List[Union[ILFlag, ExpressionIndex]], intrinsic:'architecture.IntrinsicType',
+		params:List[ExpressionIndex], flags:'architecture.FlagType'=None):
 		"""
 		``intrinsic`` return an intrinsic expression.
 
 		:return: an intrinsic expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		output_list = []
 		for output in outputs:
 			if isinstance(output, ILFlag):
-				output_list.append((1 << 32) | output.index)
+				output_list.append((1 << 32) | int(output))
 			else:
-				output_list.append(output.index)
+				output_list.append(output)
 		param_list = []
 		for param in params:
-			param_list.append(param.index)
-		call_param = self.expr(LowLevelILOperation.LLIL_CALL_PARAM, len(params), self.add_operand_list(param_list).index)
-		return self.expr(LowLevelILOperation.LLIL_INTRINSIC, len(outputs), self.add_operand_list(output_list).index,
-			self.arch.get_intrinsic_index(intrinsic), call_param.index, flags = flags)
+			param_list.append(param)
+		call_param = self.expr(LowLevelILOperation.LLIL_CALL_PARAM, len(params), self.add_operand_list(param_list))
+		return self.expr(LowLevelILOperation.LLIL_INTRINSIC, len(outputs), self.add_operand_list(output_list),
+			self.arch.get_intrinsic_index(intrinsic), call_param, flags = flags)
 
-	def breakpoint(self) -> LowLevelILExpr:
+	def breakpoint(self) -> ExpressionIndex:
 		"""
 		``breakpoint`` returns a processor breakpoint expression.
 
 		:return: a breakpoint expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_BP)
 
-	def trap(self, value:int) -> LowLevelILExpr:
+	def trap(self, value:int) -> ExpressionIndex:
 		"""
 		``trap`` returns a processor trap (interrupt) expression of the given integer ``value``.
 
 		:param int value: trap (interrupt) number
 		:return: a trap expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_TRAP, value)
 
-	def undefined(self) -> LowLevelILExpr:
+	def undefined(self) -> ExpressionIndex:
 		"""
 		``undefined`` returns the undefined expression. This should be used for instructions which perform functions but
 		aren't important for dataflow or partial emulation purposes.
 
 		:return: the unimplemented expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_UNDEF)
 
-	def unimplemented(self) -> LowLevelILExpr:
+	def unimplemented(self) -> ExpressionIndex:
 		"""
 		``unimplemented`` returns the unimplemented expression. This should be used for all instructions which aren't
 		implemented.
 
 		:return: the unimplemented expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		return self.expr(LowLevelILOperation.LLIL_UNIMPL)
 
-	def unimplemented_memory_ref(self, size:int, addr:LowLevelILExpr) -> LowLevelILExpr:
+	def unimplemented_memory_ref(self, size:int, addr:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``unimplemented_memory_ref`` a memory reference to expression ``addr`` of size ``size`` with unimplemented operation.
 
 		:param int size: size in bytes of the memory reference
-		:param LowLevelILExpr addr: expression to reference memory
+		:param ExpressionIndex addr: expression to reference memory
 		:return: the unimplemented memory reference expression.
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_UNIMPL_MEM, addr.index, size = size)
+		return self.expr(LowLevelILOperation.LLIL_UNIMPL_MEM, addr, size = size)
 
-	def float_add(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_add(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_add`` adds floating point expression ``a`` to expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``fadd.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FADD, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FADD, a, b, size=size, flags=flags)
 
-	def float_sub(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_sub(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_sub`` subtracts floating point expression ``b`` from expression ``a`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``fsub.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FSUB, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FSUB, a, b, size=size, flags=flags)
 
-	def float_mult(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_mult(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_mult`` multiplies floating point expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``fmul.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FMUL, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FMUL, a, b, size=size, flags=flags)
 
-	def float_div(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_div(self, size:int, a:ExpressionIndex, b:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_div`` divides floating point expression ``a`` by expression ``b`` potentially setting flags ``flags``
 		and returning an expression of ``size`` bytes.
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``fdiv.<size>{<flags>}(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FDIV, a.index, b.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FDIV, a, b, size=size, flags=flags)
 
-	def float_sqrt(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_sqrt(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_sqrt`` returns square root of floating point expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``sqrt.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FSQRT, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FSQRT, value, size=size, flags=flags)
 
-	def float_neg(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_neg(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_neg`` returns sign negation of floating point expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``fneg.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FNEG, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FNEG, value, size=size, flags=flags)
 
-	def float_abs(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_abs(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_abs`` returns absolute value of floating point expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``fabs.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FABS, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FABS, value, size=size, flags=flags)
 
-	def float_to_int(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_to_int(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_to_int`` returns integer value of floating point expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``int.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FLOAT_TO_INT, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FLOAT_TO_INT, value, size=size, flags=flags)
 
-	def int_to_float(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def int_to_float(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``int_to_float`` returns floating point value of integer expression ``value`` of size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``float.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_INT_TO_FLOAT, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_INT_TO_FLOAT, value, size=size, flags=flags)
 
-	def float_convert(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_convert(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``int_to_float`` converts floating point value of expression ``value`` to size ``size`` potentially setting flags
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``fconvert.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FLOAT_CONV, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FLOAT_CONV, value, size=size, flags=flags)
 
-	def round_to_int(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def round_to_int(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``round_to_int`` rounds a floating point value to the nearest integer
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``roundint.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_ROUND_TO_INT, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_ROUND_TO_INT, value, size=size, flags=flags)
 
-	def floor(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def floor(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``floor`` rounds a floating point value to an integer towards negative infinity
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``roundint.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FLOOR, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FLOOR, value, size=size, flags=flags)
 
-	def ceil(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def ceil(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``ceil`` rounds a floating point value to an integer towards positive infinity
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``roundint.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_CEIL, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_CEIL, value, size=size, flags=flags)
 
-	def float_trunc(self, size:int, value:LowLevelILExpr, flags:'architecture.FlagType'=None) -> LowLevelILExpr:
+	def float_trunc(self, size:int, value:ExpressionIndex, flags:'architecture.FlagType'=None) -> ExpressionIndex:
 		"""
 		``float_trunc`` rounds a floating point value to an integer towards zero
 
 		:param int size: the size of the result in bytes
-		:param LowLevelILExpr value: the expression to negate
+		:param ExpressionIndex value: the expression to negate
 		:param str flags: optional, flags to set
 		:return: The expression ``roundint.<size>{<flags>}(value)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FTRUNC, value.index, size=size, flags=flags)
+		return self.expr(LowLevelILOperation.LLIL_FTRUNC, value, size=size, flags=flags)
 
-	def float_compare_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_equal`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is equal to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``a f== b``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_E, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_E, a, b)
 
-	def float_compare_not_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_not_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_not_equal`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is not equal to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``a f!= b``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_NE, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_NE, a, b)
 
-	def float_compare_less_than(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_less_than(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_less_than`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is less than to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``a f< b``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_LT, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_LT, a, b)
 
-	def float_compare_less_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_less_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_less_equal`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is less than or equal to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``a f<= b``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_LE, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_LE, a, b)
 
-	def float_compare_greater_equal(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_greater_equal(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_greater_equal`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is greater than or equal to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``a f>= b``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_GE, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_GE, a, b)
 
-	def float_compare_greater_than(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_greater_than(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_greater_than`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is greater than or equal to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``a f> b``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_GT, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_GT, a, b)
 
-	def float_compare_unordered(self, size:int, a:LowLevelILExpr, b:LowLevelILExpr) -> LowLevelILExpr:
+	def float_compare_unordered(self, size:int, a:ExpressionIndex, b:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``float_compare_unordered`` returns floating point comparison expression of size ``size`` checking if
 		expression ``a`` is unordered relative to expression ``b``
 
 		:param int size: the size of the operands in bytes
-		:param LowLevelILExpr a: LHS expression
-		:param LowLevelILExpr b: RHS expression
+		:param ExpressionIndex a: LHS expression
+		:param ExpressionIndex b: RHS expression
 		:param str flags: flags to set
 		:return: The expression ``is_unordered(a, b)``
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		return self.expr(LowLevelILOperation.LLIL_FCMP_UO, a.index, b.index)
+		return self.expr(LowLevelILOperation.LLIL_FCMP_UO, a, b)
 
-	def goto(self, label:LowLevelILLabel) -> LowLevelILExpr:
+	def goto(self, label:LowLevelILLabel) -> ExpressionIndex:
 		"""
 		``goto`` returns a goto expression which jumps to the provided LowLevelILLabel.
 
 		:param LowLevelILLabel label: Label to jump to
-		:return: the LowLevelILExpr that jumps to the provided label
-		:rtype: LowLevelILExpr
+		:return: the ExpressionIndex that jumps to the provided label
+		:rtype: ExpressionIndex
 		"""
-		return LowLevelILExpr(core.BNLowLevelILGoto(self.handle, label.handle))
+		return ExpressionIndex(core.BNLowLevelILGoto(self.handle, label.handle))
 
-	def if_expr(self, operand:LowLevelILExpr, t:LowLevelILLabel, f:LowLevelILLabel) -> LowLevelILExpr:
+	def if_expr(self, operand:ExpressionIndex, t:LowLevelILLabel, f:LowLevelILLabel) -> ExpressionIndex:
 		"""
 		``if_expr`` returns the ``if`` expression which depending on condition ``operand`` jumps to the LowLevelILLabel
 		``t`` when the condition expression ``operand`` is non-zero and ``f`` when it's zero.
 
-		:param LowLevelILExpr operand: comparison expression to evaluate.
+		:param ExpressionIndex operand: comparison expression to evaluate.
 		:param LowLevelILLabel t: Label for the true branch
 		:param LowLevelILLabel f: Label for the false branch
-		:return: the LowLevelILExpr for the if expression
-		:rtype: LowLevelILExpr
+		:return: the ExpressionIndex for the if expression
+		:rtype: ExpressionIndex
 		"""
-		return LowLevelILExpr(core.BNLowLevelILIf(self.handle, operand.index, t.handle, f.handle))
+		return ExpressionIndex(core.BNLowLevelILIf(self.handle, operand, t.handle, f.handle))
 
 	def mark_label(self, label:LowLevelILLabel) -> None:
 		"""
@@ -2689,14 +4120,14 @@ class LowLevelILFunction:
 		"""
 		core.BNLowLevelILMarkLabel(self.handle, label.handle)
 
-	def add_label_map(self, labels:Mapping[int, LowLevelILLabel]) -> LowLevelILExpr:
+	def add_label_map(self, labels:Mapping[int, LowLevelILLabel]) -> ExpressionIndex:
 		"""
 		``add_label_map`` returns a label list expression for the given list of LowLevelILLabel objects.
 
 		:param labels: the list of LowLevelILLabel to get a label list expression from
 		:type labels: dict(int, LowLevelILLabel)
 		:return: the label list expression
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		label_list = (ctypes.POINTER(core.BNLowLevelILLabel) * len(labels))()  # type: ignore
 		value_list = (ctypes.POINTER(ctypes.c_ulonglong) * len(labels))()  # type: ignore
@@ -2704,38 +4135,38 @@ class LowLevelILFunction:
 			value_list[i] = key
 			label_list[i] = value.handle
 
-		return LowLevelILExpr(core.BNLowLevelILAddLabelMap(self.handle, value_list, label_list, len(labels)))
+		return ExpressionIndex(core.BNLowLevelILAddLabelMap(self.handle, value_list, label_list, len(labels)))
 
-	def add_operand_list(self, operands:List[Union[ExpressionIndex, LowLevelILExpr]]) -> LowLevelILExpr:
+	def add_operand_list(self, operands:List[Union[ExpressionIndex, ExpressionIndex]]) -> ExpressionIndex:
 		"""
 		``add_operand_list`` returns an operand list expression for the given list of integer operands.
 
 		:param operands: list of operand numbers
-		:type operands: List(Union[ExpressionIndex, LowLevelILExpr])
+		:type operands: List(Union[ExpressionIndex, ExpressionIndex])
 		:return: an operand list expression
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
 		operand_list = (ctypes.c_ulonglong * len(operands))()
 		for i in range(len(operands)):
 			op = operands[i]
-			if isinstance(op, LowLevelILExpr):
-				operand_list[i] = op.index
+			if isinstance(op, ExpressionIndex):
+				operand_list[i] = op
 			elif isinstance(op, int):
 				operand_list[i] = op
 			else:
 				raise Exception("Invalid operand type")
-		return LowLevelILExpr(core.BNLowLevelILAddOperandList(self.handle, operand_list, len(operands)))
+		return ExpressionIndex(core.BNLowLevelILAddOperandList(self.handle, operand_list, len(operands)))
 
-	def operand(self, n:int, expr:LowLevelILExpr) -> LowLevelILExpr:
+	def operand(self, n:int, expr:ExpressionIndex) -> ExpressionIndex:
 		"""
 		``operand`` sets the operand number of the expression ``expr`` and passes back ``expr`` without modification.
 
 		:param int n:
-		:param LowLevelILExpr expr:
+		:param ExpressionIndex expr:
 		:return: returns the expression ``expr`` unmodified
-		:rtype: LowLevelILExpr
+		:rtype: ExpressionIndex
 		"""
-		core.BNLowLevelILSetExprSourceOperand(self.handle, expr.index, n)
+		core.BNLowLevelILSetExprSourceOperand(self.handle, expr, n)
 		return expr
 
 	def finalize(self) -> None:
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")