Rust API : Add HLIL Bindings

1 files changed, 1176 insertions, 617 deletions

diff --git a/rust/src/mlil/operation.rs b/rust/src/mlil/operation.rs
index 880155e3..876337dd 100644
--- a/rust/src/mlil/operation.rs
+++ b/rust/src/mlil/operation.rs
@@ -6,15 +6,17 @@ use binaryninjacore_sys::BNMediumLevelILInstruction;
 use binaryninjacore_sys::BNMediumLevelILOperation;
 
 use crate::rc::Ref;
+use crate::types;
+use crate::types::ILIntrinsic;
+use crate::types::RegisterValue;
+use crate::types::RegisterValueType;
 use crate::types::{SSAVariable, Variable};
 
 use super::{MediumLevelILFunction, MediumLevelILInstruction, MediumLevelILLiftedInstruction};
 
 pub enum MediumLevelILOperand {
-    //TODO
-    //ConstantData(!),
-    //TODO
-    //Intrinsic(!),
+    ConstantData(types::ConstantData),
+    Intrinsic(ILIntrinsic),
     Expr(MediumLevelILInstruction),
     ExprList(OperandExprList),
     Float(f64),
@@ -209,19 +211,25 @@ fn get_float(value: u64, size: usize) -> f64 {
     }
 }
 
-// TODO implement ConstantData
 fn get_constant_data(
-    _function: &MediumLevelILFunction,
-    _value: u64,
-    _state: u64,
-    _size: usize,
-) -> ! {
-    todo!()
+    function: &MediumLevelILFunction,
+    state: u64,
+    value: u64,
+    size: usize,
+) -> types::ConstantData {
+    types::ConstantData::new(
+        function.get_function(),
+        RegisterValue::new(
+            RegisterValueType::from_raw_value(state as u32).unwrap(),
+            value as i64,
+            0,
+            size,
+        ),
+    )
 }
 
-// TODO implement Intrinsic
-fn get_intrinsic(_function: &MediumLevelILFunction, _idx: usize) -> ! {
-    todo!()
+fn get_intrinsic(function: &MediumLevelILFunction, idx: u32) -> ILIntrinsic {
+    ILIntrinsic::new(function.get_function().arch(), idx)
 }
 
 fn get_operation(function: &MediumLevelILFunction, idx: usize) -> MediumLevelILInstruction {
@@ -303,32 +311,58 @@ fn get_call_params_ssa(function: &MediumLevelILFunction, idx: usize) -> OperandE
 }
 
 // NOP, NORET, BP, UNDEF, UNIMPL
-#[derive(Default, Copy, Clone, Debug, Hash, PartialEq, Eq)]
-pub struct NoArgs {}
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct NoArgs {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
+}
+
+impl NoArgs {
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64) -> Self {
+        Self { function, address }
+    }
+    // NOTE self is not required, it's present just in case data is added to
+    // the struct in the future
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
+        [].into_iter()
+    }
+}
 
 // IF
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct MediumLevelILOperationIf {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     condition: usize,
     dest_true: u64,
     dest_false: u64,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedIf {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub condition: Box<MediumLevelILLiftedInstruction>,
     pub dest_true: u64,
     pub dest_false: u64,
 }
 impl MediumLevelILOperationIf {
-    pub fn new(condition: usize, dest_true: u64, dest_false: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        condition: usize,
+        dest_true: u64,
+        dest_false: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             condition,
             dest_true,
             dest_false,
         }
     }
-    pub fn condition(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.condition)
+    pub fn condition(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.condition)
     }
     pub fn dest_true(&self) -> u64 {
         self.dest_true
@@ -336,20 +370,19 @@ impl MediumLevelILOperationIf {
     pub fn dest_false(&self) -> u64 {
         self.dest_false
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedIf {
+    pub fn lift(&self) -> LiftedIf {
         LiftedIf {
-            condition: Box::new(self.condition(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            condition: Box::new(self.condition().lift()),
             dest_true: self.dest_true(),
             dest_false: self.dest_false(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("condition", Expr(self.condition(function))),
+            ("condition", Expr(self.condition())),
             ("dest_true", Int(self.dest_true())),
             ("dest_false", Int(self.dest_false())),
         ]
@@ -358,50 +391,77 @@ impl MediumLevelILOperationIf {
 }
 
 // FLOAT_CONST
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct FloatConst {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub constant: f64,
 }
 impl FloatConst {
-    pub fn new(constant: u64, size: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        constant: u64,
+        size: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             constant: get_float(constant, size),
         }
     }
     pub fn constant(&self) -> f64 {
         self.constant
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("constant", MediumLevelILOperand::Float(self.constant()))].into_iter()
     }
 }
 
 // CONST, CONST_PTR, IMPORT
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Constant {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub constant: u64,
 }
 impl Constant {
-    pub fn new(constant: u64) -> Self {
-        Self { constant }
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, constant: u64) -> Self {
+        Self {
+            function,
+            address,
+            constant,
+        }
     }
     pub fn constant(&self) -> u64 {
         self.constant
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("constant", MediumLevelILOperand::Int(self.constant()))].into_iter()
     }
 }
 
 // EXTERN_PTR
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct ExternPtr {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub constant: u64,
     pub offset: u64,
 }
 impl ExternPtr {
-    pub fn new(constant: u64, offset: u64) -> Self {
-        Self { constant, offset }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        constant: u64,
+        offset: u64,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            constant,
+            offset,
+        }
     }
     pub fn constant(&self) -> u64 {
         self.constant
@@ -409,10 +469,7 @@ impl ExternPtr {
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn operands(
-        &self,
-        _function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("constant", MediumLevelILOperand::Int(self.constant())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
@@ -422,70 +479,99 @@ impl ExternPtr {
 }
 
 // CONST_DATA
-#[derive(Copy, Clone)]
-pub struct ConstData {
+#[derive(Clone)]
+pub struct ConstantData {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     constant_data: (u64, u64),
+    size: usize,
 }
-#[derive(Clone, Debug, Hash, PartialEq, Eq)]
-pub struct ConstantData {
-    //pub constant_data: !,
+#[derive(Clone, Debug, Hash, PartialEq)]
+pub struct LiftedConstantData {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
+    pub constant_data: types::ConstantData,
 }
-impl ConstData {
-    pub fn new(constant_data: (u64, u64)) -> Self {
-        Self { constant_data }
+impl ConstantData {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        constant_data: (u64, u64),
+        size: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            constant_data,
+            size,
+        }
     }
-    pub fn constant_data(&self, function: &MediumLevelILFunction, size: usize) -> ! {
-        get_constant_data(function, self.constant_data.0, self.constant_data.1, size)
+    pub fn constant_data(&self) -> types::ConstantData {
+        get_constant_data(
+            &self.function,
+            self.constant_data.0,
+            self.constant_data.1,
+            self.size,
+        )
     }
-    pub fn lift(&self, _function: &MediumLevelILFunction) -> ConstantData {
-        ConstantData {
-            // TODO
+
+    pub fn lift(&self) -> LiftedConstantData {
+        LiftedConstantData {
+            function: self.function.clone(),
+            address: self.address,
+            constant_data: self.constant_data(),
         }
     }
-    pub fn operands(
-        &self,
-        _function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
-        // TODO
-        [
-            //("contant_data", MediumLevelILOperand::ConstData(_self.constant_data(function, self.size)))
-        ]
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
+        [(
+            "contant_data",
+            MediumLevelILOperand::ConstantData(self.constant_data()),
+        )]
         .into_iter()
     }
 }
 
 // JUMP, RET_HINT
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct Jump {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedJump {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Box<MediumLevelILLiftedInstruction>,
 }
 impl Jump {
-    pub fn new(dest: usize) -> Self {
-        Self { dest }
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, dest: usize) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+        }
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedJump {
+    pub fn lift(&self) -> LiftedJump {
         LiftedJump {
-            dest: Box::new(self.dest(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            dest: Box::new(self.dest().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
-        [("dest", MediumLevelILOperand::Expr(self.dest(function)))].into_iter()
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
+        [("dest", MediumLevelILOperand::Expr(self.dest()))].into_iter()
     }
 }
 
 // STORE_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct StoreSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: usize,
     dest_memory: u64,
     src_memory: u64,
@@ -493,22 +579,33 @@ pub struct StoreSsa {
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStoreSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub dest_memory: u64,
     pub src_memory: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl StoreSsa {
-    pub fn new(dest: usize, dest_memory: u64, src_memory: u64, src: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: usize,
+        dest_memory: u64,
+        src_memory: u64,
+        src: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             dest,
             dest_memory,
             src_memory,
             src,
         }
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
     pub fn dest_memory(&self) -> u64 {
         self.dest_memory
@@ -516,34 +613,35 @@ impl StoreSsa {
     pub fn src_memory(&self) -> u64 {
         self.src_memory
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedStoreSsa {
+    pub fn lift(&self) -> LiftedStoreSsa {
         LiftedStoreSsa {
-            dest: Box::new(self.dest(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            dest: Box::new(self.dest().lift()),
             dest_memory: self.dest_memory(),
             src_memory: self.src_memory(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("dest", MediumLevelILOperand::Expr(self.dest(function))),
+            ("dest", MediumLevelILOperand::Expr(self.dest())),
             ("dest_memory", MediumLevelILOperand::Int(self.dest_memory())),
             ("src_memory", MediumLevelILOperand::Int(self.src_memory())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // STORE_STRUCT_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct StoreStructSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: usize,
     offset: u64,
     dest_memory: u64,
@@ -552,6 +650,8 @@ pub struct StoreStructSsa {
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStoreStructSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub offset: u64,
     pub dest_memory: u64,
@@ -559,8 +659,18 @@ pub struct LiftedStoreStructSsa {
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl StoreStructSsa {
-    pub fn new(dest: usize, offset: u64, dest_memory: u64, src_memory: u64, src: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: usize,
+        offset: u64,
+        dest_memory: u64,
+        src_memory: u64,
+        src: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             dest,
             offset,
             dest_memory,
@@ -568,8 +678,8 @@ impl StoreStructSsa {
             src,
         }
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
     pub fn offset(&self) -> u64 {
         self.offset
@@ -580,210 +690,276 @@ impl StoreStructSsa {
     pub fn src_memory(&self) -> u64 {
         self.src_memory
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedStoreStructSsa {
+    pub fn lift(&self) -> LiftedStoreStructSsa {
         LiftedStoreStructSsa {
-            dest: Box::new(self.dest(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            dest: Box::new(self.dest().lift()),
             offset: self.offset(),
             dest_memory: self.dest_memory(),
             src_memory: self.src_memory(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("dest", MediumLevelILOperand::Expr(self.dest(function))),
+            ("dest", MediumLevelILOperand::Expr(self.dest())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
             ("dest_memory", MediumLevelILOperand::Int(self.dest_memory())),
             ("src_memory", MediumLevelILOperand::Int(self.src_memory())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // STORE_STRUCT
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct StoreStruct {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: usize,
     offset: u64,
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStoreStruct {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub offset: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl StoreStruct {
-    pub fn new(dest: usize, offset: u64, src: usize) -> Self {
-        Self { dest, offset, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: usize,
+        offset: u64,
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            offset,
+            src,
+        }
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedStoreStruct {
+    pub fn lift(&self) -> LiftedStoreStruct {
         LiftedStoreStruct {
-            dest: Box::new(self.dest(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            dest: Box::new(self.dest().lift()),
             offset: self.offset(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("dest", MediumLevelILOperand::Expr(self.dest(function))),
+            ("dest", MediumLevelILOperand::Expr(self.dest())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // STORE
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct Store {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: usize,
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedStore {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl Store {
-    pub fn new(dest: usize, src: usize) -> Self {
-        Self { dest, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: usize,
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            src,
+        }
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedStore {
+    pub fn lift(&self) -> LiftedStore {
         LiftedStore {
-            dest: Box::new(self.dest(function).lift()),
-            src: Box::new(self.src(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            dest: Box::new(self.dest().lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("dest", MediumLevelILOperand::Expr(self.dest(function))),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("dest", MediumLevelILOperand::Expr(self.dest())),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // JUMP_TO
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct JumpTo {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: usize,
     targets: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedJumpTo {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub targets: HashMap<u64, u64>,
 }
 impl JumpTo {
-    pub fn new(dest: usize, targets: (usize, usize)) -> Self {
-        Self { dest, targets }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: usize,
+        targets: (usize, usize),
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            targets,
+        }
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn targets(&self, function: &MediumLevelILFunction) -> OperandDubleList {
-        OperandList::new(function, self.targets.1, self.targets.0).duble()
+    pub fn targets(&self) -> OperandDubleList {
+        OperandList::new(&self.function, self.targets.1, self.targets.0).duble()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedJumpTo {
+    pub fn lift(&self) -> LiftedJumpTo {
         LiftedJumpTo {
-            dest: Box::new(self.dest(function).lift()),
-            targets: self.targets(function).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            dest: Box::new(self.dest().lift()),
+            targets: self.targets().collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("dest", Expr(self.dest(function))),
-            ("targets", TargetMap(self.targets(function))),
+            ("dest", Expr(self.dest())),
+            ("targets", TargetMap(self.targets())),
         ]
         .into_iter()
     }
 }
 
 // GOTO
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Goto {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: u64,
 }
 impl Goto {
-    pub fn new(dest: u64) -> Self {
-        Self { dest }
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, dest: u64) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+        }
     }
     pub fn dest(&self) -> u64 {
         self.dest
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("dest", MediumLevelILOperand::Int(self.dest()))].into_iter()
     }
 }
 
 // FREE_VAR_SLOT
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct FreeVarSlot {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Variable,
 }
 impl FreeVarSlot {
-    pub fn new(dest: u64) -> Self {
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, dest: u64) -> Self {
         Self {
+            function,
+            address,
             dest: get_var(dest),
         }
     }
     pub fn dest(&self) -> Variable {
         self.dest
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("dest", MediumLevelILOperand::Var(self.dest()))].into_iter()
     }
 }
 
 // SET_VAR_FIELD
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVarField {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: u64,
     offset: u64,
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarField {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Variable,
     pub offset: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVarField {
-    pub fn new(dest: u64, offset: u64, src: usize) -> Self {
-        Self { dest, offset, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: u64,
+        offset: u64,
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            offset,
+            src,
+        }
     }
     pub fn dest(&self) -> Variable {
         get_var(self.dest)
@@ -791,77 +967,98 @@ impl SetVarField {
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVarField {
+    pub fn lift(&self) -> LiftedSetVarField {
         LiftedSetVarField {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
             offset: self.offset(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::Var(self.dest())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // SET_VAR
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVar {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: u64,
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVar {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: Variable,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVar {
-    pub fn new(dest: u64, src: usize) -> Self {
-        Self { dest, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: u64,
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            src,
+        }
     }
     pub fn dest(&self) -> Variable {
         get_var(self.dest)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVar {
+    pub fn lift(&self) -> LiftedSetVar {
         LiftedSetVar {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::Var(self.dest())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // FREE_VAR_SLOT_SSA
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct FreeVarSlotSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: SSAVariable,
     pub prev: SSAVariable,
 }
 impl FreeVarSlotSsa {
-    pub fn new(dest: (u64, usize), prev: (u64, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: (u64, usize),
+        prev: (u64, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             dest: get_var_ssa(dest.0, dest.1),
             prev: get_var_ssa(prev.0, prev.1),
         }
@@ -872,13 +1069,15 @@ impl FreeVarSlotSsa {
     pub fn prev(&self) -> SSAVariable {
         self.prev
     }
-    pub fn lift(self) -> FreeVarSlotSsa {
+    pub fn lift(&self) -> FreeVarSlotSsa {
         FreeVarSlotSsa {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
             prev: self.prev(),
         }
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::VarSsa(self.dest())),
             ("prev", MediumLevelILOperand::VarSsa(self.prev())),
@@ -888,8 +1087,10 @@ impl FreeVarSlotSsa {
 }
 
 // SET_VAR_SSA_FIELD, SET_VAR_ALIASED_FIELD
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVarSsaField {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: (u64, usize),
     prev: (u64, usize),
     offset: u64,
@@ -897,14 +1098,25 @@ pub struct SetVarSsaField {
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSsaField {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: SSAVariable,
     pub prev: SSAVariable,
     pub offset: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVarSsaField {
-    pub fn new(dest: (u64, usize), prev: (u64, usize), offset: u64, src: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: (u64, usize),
+        prev: (u64, usize),
+        offset: u64,
+        src: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             dest,
             prev,
             offset,
@@ -920,47 +1132,62 @@ impl SetVarSsaField {
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVarSsaField {
+    pub fn lift(&self) -> LiftedSetVarSsaField {
         LiftedSetVarSsaField {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
             prev: self.prev(),
             offset: self.offset(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::VarSsa(self.dest())),
             ("prev", MediumLevelILOperand::VarSsa(self.prev())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // SET_VAR_ALIASED
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVarAliased {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: (u64, usize),
     prev: (u64, usize),
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarAliased {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: SSAVariable,
     pub prev: SSAVariable,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVarAliased {
-    pub fn new(dest: (u64, usize), prev: (u64, usize), src: usize) -> Self {
-        Self { dest, prev, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: (u64, usize),
+        prev: (u64, usize),
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            prev,
+            src,
+        }
     }
     pub fn dest(&self) -> SSAVariable {
         get_var_ssa(self.dest.0, self.dest.1)
@@ -968,121 +1195,157 @@ impl SetVarAliased {
     pub fn prev(&self) -> SSAVariable {
         get_var_ssa(self.prev.0, self.prev.1)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVarAliased {
+    pub fn lift(&self) -> LiftedSetVarAliased {
         LiftedSetVarAliased {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
             prev: self.prev(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::VarSsa(self.dest())),
             ("prev", MediumLevelILOperand::VarSsa(self.prev())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // SET_VAR_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVarSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: (u64, usize),
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: SSAVariable,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVarSsa {
-    pub fn new(dest: (u64, usize), src: usize) -> Self {
-        Self { dest, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: (u64, usize),
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            src,
+        }
     }
     pub fn dest(&self) -> SSAVariable {
         get_var_ssa(self.dest.0, self.dest.1)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVarSsa {
+    pub fn lift(&self) -> LiftedSetVarSsa {
         LiftedSetVarSsa {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::VarSsa(self.dest())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // VAR_PHI
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct VarPhi {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest: (u64, usize),
     src: (usize, usize),
 }
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct LiftedVarPhi {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest: SSAVariable,
     pub src: Vec<SSAVariable>,
 }
 impl VarPhi {
-    pub fn new(dest: (u64, usize), src: (usize, usize)) -> Self {
-        Self { dest, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest: (u64, usize),
+        src: (usize, usize),
+    ) -> Self {
+        Self {
+            function,
+            address,
+            dest,
+            src,
+        }
     }
     pub fn dest(&self) -> SSAVariable {
         get_var_ssa(self.dest.0, self.dest.1)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> OperandSSAVariableList {
-        OperandList::new(function, self.src.1, self.src.0).map_ssa_var()
+    pub fn src(&self) -> OperandSSAVariableList {
+        OperandList::new(&self.function, self.src.1, self.src.0).map_ssa_var()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedVarPhi {
+    pub fn lift(&self) -> LiftedVarPhi {
         LiftedVarPhi {
+            function: self.function.clone(),
+            address: self.address,
             dest: self.dest(),
-            src: self.src(function).collect(),
+            src: self.src().collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("dest", MediumLevelILOperand::VarSsa(self.dest())),
-            ("src", MediumLevelILOperand::VarSsaList(self.src(function))),
+            ("src", MediumLevelILOperand::VarSsaList(self.src())),
         ]
         .into_iter()
     }
 }
 
 // MEM_PHI
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct MemPhi {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     dest_memory: u64,
     src_memory: (usize, usize),
 }
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct LiftedMemPhi {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub dest_memory: u64,
     pub src_memory: Vec<u64>,
 }
 impl MemPhi {
-    pub fn new(dest_memory: u64, src_memory: (usize, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        dest_memory: u64,
+        src_memory: (usize, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             dest_memory,
             src_memory,
         }
@@ -1090,37 +1353,45 @@ impl MemPhi {
     pub fn dest_memory(&self) -> u64 {
         self.dest_memory
     }
-    pub fn src_memory(&self, function: &MediumLevelILFunction) -> OperandList {
-        OperandList::new(function, self.src_memory.1, self.src_memory.0)
+    pub fn src_memory(&self) -> OperandList {
+        OperandList::new(&self.function, self.src_memory.1, self.src_memory.0)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedMemPhi {
+    pub fn lift(&self) -> LiftedMemPhi {
         LiftedMemPhi {
+            function: self.function.clone(),
+            address: self.address,
             dest_memory: self.dest_memory(),
-            src_memory: self.src_memory(function).collect(),
+            src_memory: self.src_memory().collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
             ("dest_memory", Int(self.dest_memory())),
-            ("src_memory", IntList(self.src_memory(function))),
+            ("src_memory", IntList(self.src_memory())),
         ]
         .into_iter()
     }
 }
 
 // VAR_SPLIT
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct VarSplit {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub high: Variable,
     pub low: Variable,
 }
 impl VarSplit {
-    pub fn new(high: u64, low: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        high: u64,
+        low: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             high: get_var(high),
             low: get_var(low),
         }
@@ -1131,13 +1402,15 @@ impl VarSplit {
     pub fn low(&self) -> Variable {
         self.low
     }
-    pub fn lift(self) -> VarSplit {
+    pub fn lift(&self) -> VarSplit {
         VarSplit {
+            function: self.function.clone(),
+            address: self.address,
             high: self.high(),
             low: self.low(),
         }
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("high", MediumLevelILOperand::Var(self.high())),
             ("low", MediumLevelILOperand::Var(self.low())),
@@ -1147,21 +1420,37 @@ impl VarSplit {
 }
 
 // SET_VAR_SPLIT
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVarSplit {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     high: u64,
     low: u64,
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSplit {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub high: Variable,
     pub low: Variable,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVarSplit {
-    pub fn new(high: u64, low: u64, src: usize) -> Self {
-        Self { high, low, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        high: u64,
+        low: u64,
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            high,
+            low,
+            src,
+        }
     }
     pub fn high(&self) -> Variable {
         get_var(self.high)
@@ -1169,38 +1458,46 @@ impl SetVarSplit {
     pub fn low(&self) -> Variable {
         get_var(self.low)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVarSplit {
+    pub fn lift(&self) -> LiftedSetVarSplit {
         LiftedSetVarSplit {
+            function: self.function.clone(),
+            address: self.address,
             high: self.high(),
             low: self.low(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("high", MediumLevelILOperand::Var(self.high())),
             ("low", MediumLevelILOperand::Var(self.low())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // VAR_SPLIT_SSA
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct VarSplitSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub high: SSAVariable,
     pub low: SSAVariable,
 }
 impl VarSplitSsa {
-    pub fn new(high: (u64, usize), low: (u64, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        high: (u64, usize),
+        low: (u64, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             high: get_var_ssa(high.0, high.1),
             low: get_var_ssa(low.0, low.1),
         }
@@ -1211,13 +1508,15 @@ impl VarSplitSsa {
     pub fn low(&self) -> SSAVariable {
         self.low
     }
-    pub fn lift(self) -> VarSplitSsa {
+    pub fn lift(&self) -> VarSplitSsa {
         VarSplitSsa {
+            function: self.function.clone(),
+            address: self.address,
             high: self.high(),
             low: self.low(),
         }
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("high", MediumLevelILOperand::VarSsa(self.high())),
             ("low", MediumLevelILOperand::VarSsa(self.low())),
@@ -1227,21 +1526,37 @@ impl VarSplitSsa {
 }
 
 // SET_VAR_SPLIT_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SetVarSplitSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     high: (u64, usize),
     low: (u64, usize),
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSetVarSplitSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub high: SSAVariable,
     pub low: SSAVariable,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl SetVarSplitSsa {
-    pub fn new(high: (u64, usize), low: (u64, usize), src: usize) -> Self {
-        Self { high, low, src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        high: (u64, usize),
+        low: (u64, usize),
+        src: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            high,
+            low,
+            src,
+        }
     }
     pub fn high(&self) -> SSAVariable {
         get_var_ssa(self.high.0, self.high.1)
@@ -1249,314 +1564,384 @@ impl SetVarSplitSsa {
     pub fn low(&self) -> SSAVariable {
         get_var_ssa(self.low.0, self.low.1)
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSetVarSplitSsa {
+    pub fn lift(&self) -> LiftedSetVarSplitSsa {
         LiftedSetVarSplitSsa {
+            function: self.function.clone(),
+            address: self.address,
             high: self.high(),
             low: self.low(),
-            src: Box::new(self.src(function).lift()),
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("high", MediumLevelILOperand::VarSsa(self.high())),
             ("low", MediumLevelILOperand::VarSsa(self.low())),
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
         ]
         .into_iter()
     }
 }
 
 // ADD, SUB, AND, OR, XOR, LSL, LSR, ASR, ROL, ROR, MUL, MULU_DP, MULS_DP, DIVU, DIVU_DP, DIVS, DIVS_DP, MODU, MODU_DP, MODS, MODS_DP, CMP_E, CMP_NE, CMP_SLT, CMP_ULT, CMP_SLE, CMP_ULE, CMP_SGE, CMP_UGE, CMP_SGT, CMP_UGT, TEST_BIT, ADD_OVERFLOW, FCMP_E, FCMP_NE, FCMP_LT, FCMP_LE, FCMP_GE, FCMP_GT, FCMP_O, FCMP_UO, FADD, FSUB, FMUL, FDIV
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct BinaryOp {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     left: usize,
     right: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedBinaryOp {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub left: Box<MediumLevelILLiftedInstruction>,
     pub right: Box<MediumLevelILLiftedInstruction>,
 }
 impl BinaryOp {
-    pub fn new(left: usize, right: usize) -> Self {
-        Self { left, right }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        left: usize,
+        right: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            left,
+            right,
+        }
     }
-    pub fn left(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.left)
+    pub fn left(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.left)
     }
-    pub fn right(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.right)
+    pub fn right(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.right)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedBinaryOp {
+    pub fn lift(&self) -> LiftedBinaryOp {
         LiftedBinaryOp {
-            left: Box::new(self.left(function).lift()),
-            right: Box::new(self.right(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            left: Box::new(self.left().lift()),
+            right: Box::new(self.right().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("left", MediumLevelILOperand::Expr(self.left(function))),
-            ("right", MediumLevelILOperand::Expr(self.right(function))),
+            ("left", MediumLevelILOperand::Expr(self.left())),
+            ("right", MediumLevelILOperand::Expr(self.right())),
         ]
         .into_iter()
     }
 }
 
 // ADC, SBB, RLC, RRC
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct BinaryOpCarry {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     left: usize,
     right: usize,
     carry: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedBinaryOpCarry {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub left: Box<MediumLevelILLiftedInstruction>,
     pub right: Box<MediumLevelILLiftedInstruction>,
     pub carry: Box<MediumLevelILLiftedInstruction>,
 }
 impl BinaryOpCarry {
-    pub fn new(left: usize, right: usize, carry: usize) -> Self {
-        Self { left, right, carry }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        left: usize,
+        right: usize,
+        carry: usize,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            left,
+            right,
+            carry,
+        }
     }
-    pub fn left(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.left)
+    pub fn left(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.left)
     }
-    pub fn right(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.right)
+    pub fn right(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.right)
     }
-    pub fn carry(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.carry)
+    pub fn carry(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.carry)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedBinaryOpCarry {
+    pub fn lift(&self) -> LiftedBinaryOpCarry {
         LiftedBinaryOpCarry {
-            left: Box::new(self.left(function).lift()),
-            right: Box::new(self.right(function).lift()),
-            carry: Box::new(self.carry(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            left: Box::new(self.left().lift()),
+            right: Box::new(self.right().lift()),
+            carry: Box::new(self.carry().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("left", MediumLevelILOperand::Expr(self.left(function))),
-            ("right", MediumLevelILOperand::Expr(self.right(function))),
-            ("carry", MediumLevelILOperand::Expr(self.carry(function))),
+            ("left", MediumLevelILOperand::Expr(self.left())),
+            ("right", MediumLevelILOperand::Expr(self.right())),
+            ("carry", MediumLevelILOperand::Expr(self.carry())),
         ]
         .into_iter()
     }
 }
 
 // CALL, TAILCALL
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct Call {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: (usize, usize),
     dest: usize,
     params: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedCall {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<Variable>,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
 }
 impl Call {
-    pub fn new(output: (usize, usize), dest: usize, params: (usize, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: (usize, usize),
+        dest: usize,
+        params: (usize, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             dest,
             params,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandVariableList {
-        OperandList::new(function, self.output.1, self.output.0).map_var()
+    pub fn output(&self) -> OperandVariableList {
+        OperandList::new(&self.function, self.output.1, self.output.0).map_var()
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedCall {
+    pub fn lift(&self) -> LiftedCall {
         LiftedCall {
-            output: self.output(function).collect(),
-            dest: Box::new(self.dest(function).lift()),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            dest: Box::new(self.dest().lift()),
+            params: self.params().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            (
-                "output",
-                MediumLevelILOperand::VarList(self.output(function)),
-            ),
-            ("dest", MediumLevelILOperand::Expr(self.dest(function))),
-            (
-                "params",
-                MediumLevelILOperand::ExprList(self.params(function)),
-            ),
+            ("output", MediumLevelILOperand::VarList(self.output())),
+            ("dest", MediumLevelILOperand::Expr(self.dest())),
+            ("params", MediumLevelILOperand::ExprList(self.params())),
         ]
         .into_iter()
     }
 }
 
 // SYSCALL
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct Syscall {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: (usize, usize),
     params: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
-pub struct LiftedInnerCall {
+pub struct LiftedSyscallCall {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<Variable>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
 }
 impl Syscall {
-    pub fn new(output: (usize, usize), params: (usize, usize)) -> Self {
-        Self { output, params }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: (usize, usize),
+        params: (usize, usize),
+    ) -> Self {
+        Self {
+            function,
+            address,
+            output,
+            params,
+        }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandVariableList {
-        OperandList::new(function, self.output.1, self.output.0).map_var()
+    pub fn output(&self) -> OperandVariableList {
+        OperandList::new(&self.function, self.output.1, self.output.0).map_var()
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedInnerCall {
-        LiftedInnerCall {
-            output: self.output(function).collect(),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+    pub fn lift(&self) -> LiftedSyscallCall {
+        LiftedSyscallCall {
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            params: self.params().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarList(self.output(function))),
-            ("params", ExprList(self.params(function))),
+            ("output", VarList(self.output())),
+            ("params", ExprList(self.params())),
         ]
         .into_iter()
     }
 }
 
 // INTRINSIC
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct Intrinsic {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: (usize, usize),
-    intrinsic: usize,
+    intrinsic: u32,
     params: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
-pub struct MediumLevelILLiftedIntrinsic {
+pub struct LiftedIntrinsic {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<Variable>,
-    //pub intrinsic: !,
+    pub intrinsic: ILIntrinsic,
     pub params: Vec<MediumLevelILLiftedInstruction>,
 }
 impl Intrinsic {
-    pub fn new(output: (usize, usize), intrinsic: usize, params: (usize, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: (usize, usize),
+        intrinsic: u32,
+        params: (usize, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             intrinsic,
             params,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandVariableList {
-        OperandList::new(function, self.output.1, self.output.0).map_var()
+    pub fn output(&self) -> OperandVariableList {
+        OperandList::new(&self.function, self.output.1, self.output.0).map_var()
     }
-    pub fn intrinsic(&self, function: &MediumLevelILFunction) -> ! {
-        get_intrinsic(function, self.intrinsic)
+    pub fn intrinsic(&self) -> ILIntrinsic {
+        get_intrinsic(&self.function, self.intrinsic)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedInnerCall {
-        LiftedInnerCall {
-            output: self.output(function).collect(),
-            //intrinsic: get_intrinsic(function, self.intrinsic),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+    pub fn lift(&self) -> LiftedIntrinsic {
+        LiftedIntrinsic {
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            intrinsic: self.intrinsic(),
+            params: self.params().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarList(self.output(function))),
-            //("intrinsic", VarList(self.output(function))),
-            ("params", ExprList(self.params(function))),
+            ("output", VarList(self.output())),
+            ("intrinsic", Intrinsic(self.intrinsic())),
+            ("params", ExprList(self.params())),
         ]
         .into_iter()
     }
 }
 
 // INTRINSIC_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct IntrinsicSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: (usize, usize),
-    intrinsic: usize,
+    intrinsic: u32,
     params: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedIntrinsicSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<SSAVariable>,
-    //pub intrinsic: !,
+    pub intrinsic: ILIntrinsic,
     pub params: Vec<MediumLevelILLiftedInstruction>,
 }
 impl IntrinsicSsa {
-    pub fn new(output: (usize, usize), intrinsic: usize, params: (usize, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: (usize, usize),
+        intrinsic: u32,
+        params: (usize, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             intrinsic,
             params,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandSSAVariableList {
-        OperandList::new(function, self.output.1, self.output.0).map_ssa_var()
+    pub fn output(&self) -> OperandSSAVariableList {
+        OperandList::new(&self.function, self.output.1, self.output.0).map_ssa_var()
     }
-    pub fn intrinsic(&self, function: &MediumLevelILFunction) -> ! {
-        get_intrinsic(function, self.intrinsic)
+    pub fn intrinsic(&self) -> ILIntrinsic {
+        get_intrinsic(&self.function, self.intrinsic)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedIntrinsicSsa {
+    pub fn lift(&self) -> LiftedIntrinsicSsa {
         LiftedIntrinsicSsa {
-            output: self.output(function).collect(),
-            //intrinsic: get_intrinsic(function, self.intrinsic),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            intrinsic: get_intrinsic(&self.function, self.intrinsic),
+            params: self.params().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarSsaList(self.output(function))),
-            ("params", ExprList(self.params(function))),
+            ("output", VarSsaList(self.output())),
+            ("intrinsic", Intrinsic(self.intrinsic())),
+            ("params", ExprList(self.params())),
         ]
         .into_iter()
     }
 }
 
 // CALL_SSA, TAILCALL_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct CallSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: usize,
     dest: usize,
     params: (usize, usize),
@@ -1564,49 +1949,59 @@ pub struct CallSsa {
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedCallSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<SSAVariable>,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
     pub src_memory: u64,
 }
 impl CallSsa {
-    pub fn new(output: usize, dest: usize, params: (usize, usize), src_memory: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: usize,
+        dest: usize,
+        params: (usize, usize),
+        src_memory: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             dest,
             params,
             src_memory,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandSSAVariableList {
-        get_call_output_ssa(function, self.output)
+    pub fn output(&self) -> OperandSSAVariableList {
+        get_call_output_ssa(&self.function, self.output)
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
     pub fn src_memory(&self) -> u64 {
         self.src_memory
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedCallSsa {
+    pub fn lift(&self) -> LiftedCallSsa {
         LiftedCallSsa {
-            output: self.output(function).collect(),
-            dest: Box::new(self.dest(function).lift()),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            dest: Box::new(self.dest().lift()),
+            params: self.params().map(|instr| instr.lift()).collect(),
             src_memory: self.src_memory(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarSsaList(self.output(function))),
-            ("dest", Expr(self.dest(function))),
-            ("params", ExprList(self.params(function))),
+            ("output", VarSsaList(self.output())),
+            ("dest", Expr(self.dest())),
+            ("params", ExprList(self.params())),
             ("src_memory", Int(self.src_memory())),
         ]
         .into_iter()
@@ -1614,8 +2009,10 @@ impl CallSsa {
 }
 
 // CALL_UNTYPED_SSA, TAILCALL_UNTYPED_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct CallUntypedSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: usize,
     dest: usize,
     params: usize,
@@ -1623,100 +2020,121 @@ pub struct CallUntypedSsa {
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedCallUntypedSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<SSAVariable>,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
     pub stack: Box<MediumLevelILLiftedInstruction>,
 }
 impl CallUntypedSsa {
-    pub fn new(output: usize, dest: usize, params: usize, stack: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: usize,
+        dest: usize,
+        params: usize,
+        stack: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             dest,
             params,
             stack,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandSSAVariableList {
-        get_call_output_ssa(function, self.output)
+    pub fn output(&self) -> OperandSSAVariableList {
+        get_call_output_ssa(&self.function, self.output)
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        get_call_params_ssa(function, self.params)
+    pub fn params(&self) -> OperandExprList {
+        get_call_params_ssa(&self.function, self.params)
     }
-    pub fn stack(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.stack)
+    pub fn stack(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.stack)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedCallUntypedSsa {
+    pub fn lift(&self) -> LiftedCallUntypedSsa {
         LiftedCallUntypedSsa {
-            output: self.output(function).collect(),
-            dest: Box::new(self.dest(function).lift()),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
-            stack: Box::new(self.stack(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            dest: Box::new(self.dest().lift()),
+            params: self.params().map(|instr| instr.lift()).collect(),
+            stack: Box::new(self.stack().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarSsaList(self.output(function))),
-            ("dest", Expr(self.dest(function))),
-            ("params", ExprList(self.params(function))),
-            ("stack", Expr(self.stack(function))),
+            ("output", VarSsaList(self.output())),
+            ("dest", Expr(self.dest())),
+            ("params", ExprList(self.params())),
+            ("stack", Expr(self.stack())),
         ]
         .into_iter()
     }
 }
 
 // SYSCALL_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SyscallSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: usize,
     params: (usize, usize),
     src_memory: u64,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSyscallSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<SSAVariable>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
     pub src_memory: u64,
 }
 impl SyscallSsa {
-    pub fn new(output: usize, params: (usize, usize), src_memory: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: usize,
+        params: (usize, usize),
+        src_memory: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             params,
             src_memory,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandSSAVariableList {
-        get_call_output_ssa(function, self.output)
+    pub fn output(&self) -> OperandSSAVariableList {
+        get_call_output_ssa(&self.function, self.output)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
     pub fn src_memory(&self) -> u64 {
         self.src_memory
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSyscallSsa {
+    pub fn lift(&self) -> LiftedSyscallSsa {
         LiftedSyscallSsa {
-            output: self.output(function).collect(),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            params: self.params().map(|instr| instr.lift()).collect(),
             src_memory: self.src_memory(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarSsaList(self.output(function))),
-            ("params", ExprList(self.params(function))),
+            ("output", VarSsaList(self.output())),
+            ("params", ExprList(self.params())),
             ("src_memory", MediumLevelILOperand::Int(self.src_memory())),
         ]
         .into_iter()
@@ -1724,59 +2142,72 @@ impl SyscallSsa {
 }
 
 // SYSCALL_UNTYPED_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SyscallUntypedSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: usize,
     params: usize,
     stack: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSyscallUntypedSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<SSAVariable>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
     pub stack: Box<MediumLevelILLiftedInstruction>,
 }
 impl SyscallUntypedSsa {
-    pub fn new(output: usize, params: usize, stack: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: usize,
+        params: usize,
+        stack: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             params,
             stack,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandSSAVariableList {
-        get_call_output_ssa(function, self.output)
+    pub fn output(&self) -> OperandSSAVariableList {
+        get_call_output_ssa(&self.function, self.output)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        get_call_params_ssa(function, self.params)
+    pub fn params(&self) -> OperandExprList {
+        get_call_params_ssa(&self.function, self.params)
     }
-    pub fn stack(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.stack)
+    pub fn stack(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.stack)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSyscallUntypedSsa {
+    pub fn lift(&self) -> LiftedSyscallUntypedSsa {
         LiftedSyscallUntypedSsa {
-            output: self.output(function).collect(),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
-            stack: Box::new(self.stack(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            params: self.params().map(|instr| instr.lift()).collect(),
+            stack: Box::new(self.stack().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarSsaList(self.output(function))),
-            ("params", ExprList(self.params(function))),
-            ("stack", Expr(self.stack(function))),
+            ("output", VarSsaList(self.output())),
+            ("params", ExprList(self.params())),
+            ("stack", Expr(self.stack())),
         ]
         .into_iter()
     }
 }
 
 // CALL_UNTYPED, TAILCALL_UNTYPED
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct CallUntyped {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: usize,
     dest: usize,
     params: usize,
@@ -1784,168 +2215,209 @@ pub struct CallUntyped {
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedCallUntyped {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<Variable>,
     pub dest: Box<MediumLevelILLiftedInstruction>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
     pub stack: Box<MediumLevelILLiftedInstruction>,
 }
 impl CallUntyped {
-    pub fn new(output: usize, dest: usize, params: usize, stack: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: usize,
+        dest: usize,
+        params: usize,
+        stack: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             dest,
             params,
             stack,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandVariableList {
-        get_call_output(function, self.output)
+    pub fn output(&self) -> OperandVariableList {
+        get_call_output(&self.function, self.output)
     }
-    pub fn dest(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.dest)
+    pub fn dest(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.dest)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        get_call_params(function, self.params)
+    pub fn params(&self) -> OperandExprList {
+        get_call_params(&self.function, self.params)
     }
-    pub fn stack(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.stack)
+    pub fn stack(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.stack)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedCallUntyped {
+    pub fn lift(&self) -> LiftedCallUntyped {
         LiftedCallUntyped {
-            output: self.output(function).collect(),
-            dest: Box::new(self.dest(function).lift()),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
-            stack: Box::new(self.stack(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            dest: Box::new(self.dest().lift()),
+            params: self.params().map(|instr| instr.lift()).collect(),
+            stack: Box::new(self.stack().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarList(self.output(function))),
-            ("dest", Expr(self.dest(function))),
-            ("params", ExprList(self.params(function))),
-            ("stack", Expr(self.stack(function))),
+            ("output", VarList(self.output())),
+            ("dest", Expr(self.dest())),
+            ("params", ExprList(self.params())),
+            ("stack", Expr(self.stack())),
         ]
         .into_iter()
     }
 }
 
 // SYSCALL_UNTYPED
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SyscallUntyped {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     output: usize,
     params: usize,
     stack: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSyscallUntyped {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub output: Vec<Variable>,
     pub params: Vec<MediumLevelILLiftedInstruction>,
     pub stack: Box<MediumLevelILLiftedInstruction>,
 }
 impl SyscallUntyped {
-    pub fn new(output: usize, params: usize, stack: usize) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        output: usize,
+        params: usize,
+        stack: usize,
+    ) -> Self {
         Self {
+            function,
+            address,
             output,
             params,
             stack,
         }
     }
-    pub fn output(&self, function: &MediumLevelILFunction) -> OperandVariableList {
-        get_call_output(function, self.output)
+    pub fn output(&self) -> OperandVariableList {
+        get_call_output(&self.function, self.output)
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        get_call_params(function, self.params)
+    pub fn params(&self) -> OperandExprList {
+        get_call_params(&self.function, self.params)
     }
-    pub fn stack(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.stack)
+    pub fn stack(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.stack)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSyscallUntyped {
+    pub fn lift(&self) -> LiftedSyscallUntyped {
         LiftedSyscallUntyped {
-            output: self.output(function).collect(),
-            params: self.params(function).map(|instr| instr.lift()).collect(),
-            stack: Box::new(self.stack(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            output: self.output().collect(),
+            params: self.params().map(|instr| instr.lift()).collect(),
+            stack: Box::new(self.stack().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         use MediumLevelILOperand::*;
         [
-            ("output", VarList(self.output(function))),
-            ("params", ExprList(self.params(function))),
-            ("stack", Expr(self.stack(function))),
+            ("output", VarList(self.output())),
+            ("params", ExprList(self.params())),
+            ("stack", Expr(self.stack())),
         ]
         .into_iter()
     }
 }
 
 // NEG, NOT, SX, ZX, LOW_PART, BOOL_TO_INT, UNIMPL_MEM, FSQRT, FNEG, FABS, FLOAT_TO_INT, INT_TO_FLOAT, FLOAT_CONV, ROUND_TO_INT, FLOOR, CEIL, FTRUNC, LOAD
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct UnaryOp {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     src: usize,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedUnaryOp {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
 }
 impl UnaryOp {
-    pub fn new(src: usize) -> Self {
-        Self { src }
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, src: usize) -> Self {
+        Self {
+            function,
+            address,
+            src,
+        }
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedUnaryOp {
+    pub fn lift(&self) -> LiftedUnaryOp {
         LiftedUnaryOp {
-            src: Box::new(self.src(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            src: Box::new(self.src().lift()),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
-        [("src", MediumLevelILOperand::Expr(self.src(function)))].into_iter()
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
+        [("src", MediumLevelILOperand::Expr(self.src()))].into_iter()
     }
 }
 
 // LOAD_STRUCT
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct LoadStruct {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     src: usize,
     offset: u64,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedLoadStruct {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
     pub offset: u64,
 }
 impl LoadStruct {
-    pub fn new(src: usize, offset: u64) -> Self {
-        Self { src, offset }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: usize,
+        offset: u64,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            src,
+            offset,
+        }
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedLoadStruct {
+    pub fn lift(&self) -> LiftedLoadStruct {
         LiftedLoadStruct {
-            src: Box::new(self.src(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            src: Box::new(self.src().lift()),
             offset: self.offset(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
         ]
         .into_iter()
@@ -1953,28 +2425,40 @@ impl LoadStruct {
 }
 
 // LOAD_STRUCT_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct LoadStructSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     src: usize,
     offset: u64,
     src_memory: u64,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedLoadStructSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
     pub offset: u64,
     pub src_memory: u64,
 }
 impl LoadStructSsa {
-    pub fn new(src: usize, offset: u64, src_memory: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: usize,
+        offset: u64,
+        src_memory: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             src,
             offset,
             src_memory,
         }
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
     pub fn offset(&self) -> u64 {
         self.offset
@@ -1982,19 +2466,18 @@ impl LoadStructSsa {
     pub fn src_memory(&self) -> u64 {
         self.src_memory
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedLoadStructSsa {
+    pub fn lift(&self) -> LiftedLoadStructSsa {
         LiftedLoadStructSsa {
-            src: Box::new(self.src(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            src: Box::new(self.src().lift()),
             offset: self.offset(),
             src_memory: self.src_memory(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
             ("src_memory", MediumLevelILOperand::Int(self.src_memory())),
         ]
@@ -2003,38 +2486,51 @@ impl LoadStructSsa {
 }
 
 // LOAD_SSA
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct LoadSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     src: usize,
     src_memory: u64,
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedLoadSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Box<MediumLevelILLiftedInstruction>,
     pub src_memory: u64,
 }
 impl LoadSsa {
-    pub fn new(src: usize, src_memory: u64) -> Self {
-        Self { src, src_memory }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: usize,
+        src_memory: u64,
+    ) -> Self {
+        Self {
+            function,
+            address,
+            src,
+            src_memory,
+        }
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> MediumLevelILInstruction {
-        get_operation(function, self.src)
+    pub fn src(&self) -> MediumLevelILInstruction {
+        get_operation(&self.function, self.src)
     }
     pub fn src_memory(&self) -> u64 {
         self.src_memory
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedLoadSsa {
+    pub fn lift(&self) -> LiftedLoadSsa {
         LiftedLoadSsa {
-            src: Box::new(self.src(function).lift()),
+            function: self.function.clone(),
+            address: self.address,
+            src: Box::new(self.src().lift()),
             src_memory: self.src_memory(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
-            ("src", MediumLevelILOperand::Expr(self.src(function))),
+            ("src", MediumLevelILOperand::Expr(self.src())),
             ("src_memory", MediumLevelILOperand::Int(self.src_memory())),
         ]
         .into_iter()
@@ -2042,118 +2538,158 @@ impl LoadSsa {
 }
 
 // RET
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct Ret {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     src: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedRet {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Vec<MediumLevelILLiftedInstruction>,
 }
 impl Ret {
-    pub fn new(src: (usize, usize)) -> Self {
-        Self { src }
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: (usize, usize),
+    ) -> Self {
+        Self {
+            function,
+            address,
+            src,
+        }
     }
-    pub fn src(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.src.1, self.src.0).map_expr()
+    pub fn src(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.src.1, self.src.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedRet {
+    pub fn lift(&self) -> LiftedRet {
         LiftedRet {
-            src: self.src(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            src: self.src().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
-        [("src", MediumLevelILOperand::ExprList(self.src(function)))].into_iter()
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
+        [("src", MediumLevelILOperand::ExprList(self.src()))].into_iter()
     }
 }
 
 // SEPARATE_PARAM_LIST
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SeparateParamList {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     params: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSeparateParamList {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub params: Vec<MediumLevelILLiftedInstruction>,
 }
 impl SeparateParamList {
-    pub fn new(params: (usize, usize)) -> Self {
-        Self { params }
+    pub fn new(function: Ref<MediumLevelILFunction>, address: u64, params: (usize, usize)) -> Self {
+        Self {
+            function,
+            address,
+            params,
+        }
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSeparateParamList {
+    pub fn lift(&self) -> LiftedSeparateParamList {
         LiftedSeparateParamList {
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            params: self.params().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
-        [("params", MediumLevelILOperand::ExprList(self.params(function)))].into_iter()
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+        [("params", MediumLevelILOperand::ExprList(self.params()))].into_iter()
     }
 }
 
 // SHARED_PARAM_SLOT
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct SharedParamSlot {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     params: (usize, usize),
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct LiftedSharedParamSlot {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub params: Vec<MediumLevelILLiftedInstruction>,
 }
 impl SharedParamSlot {
-    pub fn new(params: (usize, usize)) -> Self {
-        Self { params }
+    pub fn new(function: Ref<MediumLevelILFunction>, address: u64, params: (usize, usize)) -> Self {
+        Self {
+            function,
+            address,
+            params,
+        }
     }
-    pub fn params(&self, function: &MediumLevelILFunction) -> OperandExprList {
-        OperandList::new(function, self.params.1, self.params.0).map_expr()
+    pub fn params(&self) -> OperandExprList {
+        OperandList::new(&self.function, self.params.1, self.params.0).map_expr()
     }
-    pub fn lift(&self, function: &MediumLevelILFunction) -> LiftedSharedParamSlot {
+    pub fn lift(&self) -> LiftedSharedParamSlot {
         LiftedSharedParamSlot {
-            params: self.params(function).map(|instr| instr.lift()).collect(),
+            function: self.function.clone(),
+            address: self.address,
+            params: self.params().map(|instr| instr.lift()).collect(),
         }
     }
-    pub fn operands(
-        &self,
-        function: &MediumLevelILFunction,
-    ) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
-        [("params", MediumLevelILOperand::ExprList(self.params(function)))].into_iter()
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+        [("params", MediumLevelILOperand::ExprList(self.params()))].into_iter()
     }
 }
 
 // VAR, ADDRESS_OF
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Var {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Variable,
 }
 impl Var {
-    pub fn new(src: u64) -> Self {
-        Self { src: get_var(src) }
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, src: u64) -> Self {
+        Self {
+            function,
+            address,
+            src: get_var(src),
+        }
     }
     pub fn src(&self) -> Variable {
         self.src
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("src", MediumLevelILOperand::Var(self.src()))].into_iter()
     }
 }
 
 // VAR_FIELD, ADDRESS_OF_FIELD
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Field {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: Variable,
     pub offset: u64,
 }
 impl Field {
-    pub fn new(src: u64, offset: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: u64,
+        offset: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             src: get_var(src),
             offset,
         }
@@ -2164,7 +2700,7 @@ impl Field {
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("src", MediumLevelILOperand::Var(self.src())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
@@ -2174,33 +2710,50 @@ impl Field {
 }
 
 // VAR_SSA, VAR_ALIASED
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct VarSsa {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: SSAVariable,
 }
 impl VarSsa {
-    pub fn new(src: (u64, usize)) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: (u64, usize),
+    ) -> Self {
         Self {
+            function,
+            address,
             src: get_var_ssa(src.0, src.1),
         }
     }
     pub fn src(&self) -> SSAVariable {
         self.src
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("src", MediumLevelILOperand::VarSsa(self.src()))].into_iter()
     }
 }
 
 // VAR_SSA_FIELD, VAR_ALIASED_FIELD
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct VarSsaField {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub src: SSAVariable,
     pub offset: u64,
 }
 impl VarSsaField {
-    pub fn new(src: (u64, usize), offset: u64) -> Self {
+    pub(crate) fn new(
+        function: Ref<MediumLevelILFunction>,
+        address: u64,
+        src: (u64, usize),
+        offset: u64,
+    ) -> Self {
         Self {
+            function,
+            address,
             src: get_var_ssa(src.0, src.1),
             offset,
         }
@@ -2211,7 +2764,7 @@ impl VarSsaField {
     pub fn offset(&self) -> u64 {
         self.offset
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [
             ("src", MediumLevelILOperand::VarSsa(self.src())),
             ("offset", MediumLevelILOperand::Int(self.offset())),
@@ -2221,18 +2774,24 @@ impl VarSsaField {
 }
 
 // TRAP
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Trap {
+    pub function: Ref<MediumLevelILFunction>,
+    pub address: u64,
     pub vector: u64,
 }
 impl Trap {
-    pub fn new(vector: u64) -> Self {
-        Self { vector }
+    pub(crate) fn new(function: Ref<MediumLevelILFunction>, address: u64, vector: u64) -> Self {
+        Self {
+            function,
+            address,
+            vector,
+        }
     }
     pub fn vector(&self) -> u64 {
         self.vector
     }
-    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> {
+    pub fn operands(&self) -> impl Iterator<Item = (&'static str, MediumLevelILOperand)> + '_ {
         [("vector", MediumLevelILOperand::Int(self.vector()))].into_iter()
     }
 }