Execute the initial LOAD and create the initial_register

The main goal is to avoid repetitive opcodes execution that are only there to
set the initial state.

Any computation that wasn't optimized will be executed, as expected, but not
the LOAD that only serves the purpose of setting the initial state

utxo/src/filter_expr/filter.rs

@@ -22,6 +22,8 @@ pub struct Filter {
     opcodes: Vec<OpCode>,
     /// The list of opcodes that make up the program, the labels has been converted into addresses
     opcodes_to_execute: Vec<OpCode>,
+    /// The address of the initial opcode
+    initial_opcode_addr: Addr,
     /// The state of the register
     pub(crate) initial_register: HashMap<Register, ValueOrRef>,
 }
@@ -43,6 +45,7 @@ impl Filter {
             expr,
             dbg_opcodes: opcodes.clone(),
             opcodes: opcodes.clone(),
+            initial_opcode_addr: 0.into(),
             variables: opcodes
                 .iter()
                 .filter_map(|x| match x {
@@ -70,6 +73,22 @@ impl Filter {
         self.opcodes = new_opcodes;
         self.initial_register.clear();
         self.opcodes_to_execute = Compiler::resolve_label_to_addr(self.opcodes.clone()).unwrap();
+
+        for (pos, opcode) in self.opcodes.iter().enumerate() {
+            // Execute all the LOAD opcodes until we find a non-LOAD opcode
+            // and store the initial state of the registers
+            match opcode {
+                OpCode::LOAD(r, v) => {
+                    self.initial_register
+                        .insert(*r, ValueOrRef::WeakRef(Rc::downgrade(v)));
+                }
+                _ => {
+                    self.initial_opcode_addr = pos.into();
+                    break;
+                }
+            }
+        }
+
         self
     }
 
@@ -101,6 +120,7 @@ impl Filter {
         execute(
             external_variables,
             &self.opcodes_to_execute,
+            self.initial_opcode_addr,
             self.initial_register.clone(),
         )
     }

utxo/src/filter_expr/runtime.rs

@@ -48,9 +48,10 @@ macro_rules! set {
 pub fn execute(
     external_variables: &HashMap<Variable, ValueOrRef>,
     code: &[OpCode],
+    start_at: Addr,
     initial_registers: HashMap<Register, ValueOrRef>,
 ) -> Result<Value, Error> {
-    let mut execution: Addr = 0.into();
+    let mut execution: Addr = start_at;
     let mut registers = initial_registers;
 
     loop {