diff --git a/.gitattributes b/.gitattributes
index 2168b7bfd2..0c6d0b0e83 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,4 +1,5 @@
 # Force certain files to be LF
 *.leo text eol=lf
 *.out text eol=lf  
-*.rs text eol=lf 
+*.rs text eol=lf
+*.in text eol=lf
diff --git a/Cargo.lock b/Cargo.lock
index aeb5aa0f6f..671f1bb82a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1220,26 +1220,18 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "leo-ast-passes"
-version = "1.5.3"
-dependencies = [
- "indexmap",
- "leo-ast",
- "leo-errors",
- "leo-parser",
- "leo-span",
-]
-
 [[package]]
 name = "leo-compiler"
 version = "1.5.3"
 dependencies = [
  "leo-ast",
- "leo-ast-passes",
  "leo-errors",
  "leo-parser",
+ "leo-passes",
  "leo-span",
+ "leo-test-framework",
+ "serde",
+ "serde_yaml",
  "sha2",
 ]
 
@@ -1273,6 +1265,7 @@ dependencies = [
  "leo-compiler",
  "leo-errors",
  "leo-package",
+ "leo-span",
  "notify",
  "rand",
  "rand_core",
@@ -1325,6 +1318,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "leo-passes"
+version = "1.5.3"
+dependencies = [
+ "indexmap",
+ "leo-ast",
+ "leo-errors",
+ "leo-parser",
+ "leo-span",
+]
+
 [[package]]
 name = "leo-span"
 version = "1.5.3"
diff --git a/Cargo.toml b/Cargo.toml
index d725ffdf29..6852ee9452 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,10 +46,17 @@ version = "1.5.3"
 path = "./leo/package"
 version = "1.5.3"
 
+[dependencies.leo-span]
+path = "./leo/span"
+version = "1.5.3"
+
 [dependencies.snarkvm-utilities]
 git = "https://github.com/AleoHQ/snarkVM.git"
 rev = "51633e2"
 
+[dependencies.backtrace]
+version = "0.3.65"
+
 [dependencies.clap]
 version = "3.1"
 
@@ -59,18 +66,12 @@ version = "0.5.1"
 [dependencies.colored]
 version = "2.0"
 
-[dependencies.backtrace]
-version = "0.3.65"
-
-[dependencies.sys-info]
-version = "0.9.1"
+[dependencies.console]
+version = "0.15.0"
 
 [dependencies.dirs]
 version = "4.0.0"
 
-[dependencies.console]
-version = "0.15.0"
-
 [dependencies.indexmap]
 version = "1.8"
 features = ["serde"]
@@ -105,6 +106,9 @@ version = "1.0"
 [dependencies.structopt]
 version = "0.3"
 
+[dependencies.sys-info]
+version = "0.9.1"
+
 [dependencies.toml]
 version = "0.5"
 
diff --git a/compiler/ast/Cargo.toml b/compiler/ast/Cargo.toml
index d4193ad5f0..fcfe9e4632 100644
--- a/compiler/ast/Cargo.toml
+++ b/compiler/ast/Cargo.toml
@@ -18,9 +18,6 @@ license = "GPL-3.0"
 edition = "2021"
 rust-version = "1.56"
 
-[dependencies]
-smallvec = { version = "1.8.0", features = ["serde"] }
-
 [dependencies.leo-errors]
 path = "../../leo/errors"
 version = "1.5.3"
@@ -41,6 +38,10 @@ features = [ "derive", "rc" ]
 version = "1.0"
 features = [ "preserve_order" ]
 
+[dependencies.smallvec]
+version = "1.8.0"
+features = ["serde"]
+
 [dev-dependencies.criterion]
 version = "0.3"
 
diff --git a/compiler/ast/src/input/input_ast.rs b/compiler/ast/src/input/input_ast.rs
index f5c6d9658f..4373305540 100644
--- a/compiler/ast/src/input/input_ast.rs
+++ b/compiler/ast/src/input/input_ast.rs
@@ -14,8 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
+use crate::{normalize_json_value, remove_key_from_json};
+
 use super::*;
-use leo_errors::AstError;
+use leo_errors::{AstError, Result};
 
 /// Input data which includes [`ProgramInput`] and [`ProgramState`].
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -24,16 +26,44 @@ pub struct Input {
     pub program_state: ProgramState,
 }
 
-/// A raw unprocessed input or state file data. Used for future conversion
-/// into [`ProgramInput`] or [`ProgramState`].
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ParsedInputFile {
-    pub sections: Vec<Section>,
-}
-
 impl Input {
     /// Serializes the ast into a JSON string.
     pub fn to_json_string(&self) -> Result<String> {
         Ok(serde_json::to_string_pretty(&self).map_err(|e| AstError::failed_to_convert_ast_to_json_string(&e))?)
     }
 }
+
+/// A raw unprocessed input or state file data. Used for future conversion
+/// into [`ProgramInput`] or [`ProgramState`].
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct InputAst {
+    pub sections: Vec<Section>,
+}
+
+impl InputAst {
+    /// Serializes the `Input` into a JSON Value.
+    pub fn to_json_value(&self) -> Result<serde_json::Value> {
+        Ok(serde_json::to_value(&self).map_err(|e| AstError::failed_to_convert_ast_to_json_value(&e))?)
+    }
+
+    /// Serializes the `Input` into a JSON value and removes keys from object mappings before writing to a file.
+    pub fn to_json_file_without_keys(
+        &self,
+        mut path: std::path::PathBuf,
+        file_name: &str,
+        excluded_keys: &[&str],
+    ) -> Result<()> {
+        path.push(file_name);
+        let file = std::fs::File::create(&path).map_err(|e| AstError::failed_to_create_ast_json_file(&path, &e))?;
+        let writer = std::io::BufWriter::new(file);
+
+        let mut value = self.to_json_value().unwrap();
+        for key in excluded_keys {
+            value = remove_key_from_json(value, key);
+        }
+        value = normalize_json_value(value);
+
+        Ok(serde_json::to_writer_pretty(writer, &value)
+            .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?)
+    }
+}
diff --git a/compiler/ast/src/input/input_value.rs b/compiler/ast/src/input/input_value.rs
index e31121079d..bb46164825 100644
--- a/compiler/ast/src/input/input_value.rs
+++ b/compiler/ast/src/input/input_value.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{CharValue, Expression, GroupValue, IntegerType, Node, Type, ValueExpression};
+use crate::{CharValue, Expression, GroupValue, IntegerType, Node, Type, UnaryOperation, ValueExpression};
 use leo_errors::{InputError, LeoError, ParserError, Result};
 
 use serde::{Deserialize, Serialize};
@@ -59,6 +59,9 @@ impl TryFrom<(Type, Expression)> for InputValue {
                     }
                 }
             }
+            (type_, Expression::Unary(unary)) if unary.op == UnaryOperation::Negate => {
+                InputValue::try_from((type_, *unary.inner))?
+            }
             (_type_, expr) => return Err(InputError::illegal_expression(&expr, expr.span()).into()),
         })
     }
diff --git a/compiler/ast/src/input/program_input.rs b/compiler/ast/src/input/program_input.rs
index 162ef8a3ea..858bdb2a03 100644
--- a/compiler/ast/src/input/program_input.rs
+++ b/compiler/ast/src/input/program_input.rs
@@ -23,9 +23,9 @@ pub struct ProgramInput {
     pub registers: Definitions,
 }
 
-impl TryFrom<ParsedInputFile> for ProgramInput {
+impl TryFrom<InputAst> for ProgramInput {
     type Error = LeoError;
-    fn try_from(input: ParsedInputFile) -> Result<Self> {
+    fn try_from(input: InputAst) -> Result<Self> {
         let mut main = IndexMap::new();
         let mut registers = IndexMap::new();
 
diff --git a/compiler/ast/src/input/program_state.rs b/compiler/ast/src/input/program_state.rs
index 7dbfc5caf8..6d12aa2bae 100644
--- a/compiler/ast/src/input/program_state.rs
+++ b/compiler/ast/src/input/program_state.rs
@@ -22,9 +22,9 @@ pub struct ProgramState {
     pub state: Definitions,
 }
 
-impl TryFrom<ParsedInputFile> for ProgramState {
+impl TryFrom<InputAst> for ProgramState {
     type Error = LeoError;
-    fn try_from(input: ParsedInputFile) -> Result<Self> {
+    fn try_from(input: InputAst) -> Result<Self> {
         let mut state = IndexMap::new();
 
         for section in input.sections {
diff --git a/compiler/ast/src/lib.rs b/compiler/ast/src/lib.rs
index 64b97b6bb4..64adaed260 100644
--- a/compiler/ast/src/lib.rs
+++ b/compiler/ast/src/lib.rs
@@ -40,9 +40,6 @@ pub use self::groups::*;
 pub mod input;
 pub use self::input::*;
 
-pub mod pass;
-pub use self::pass::*;
-
 pub mod passes;
 pub use self::passes::*;
 
@@ -147,7 +144,7 @@ impl AsRef<Program> for Ast {
 }
 
 /// Helper function to recursively filter keys from AST JSON
-fn remove_key_from_json(value: serde_json::Value, key: &str) -> serde_json::Value {
+pub(crate) fn remove_key_from_json(value: serde_json::Value, key: &str) -> serde_json::Value {
     match value {
         serde_json::Value::Object(map) => serde_json::Value::Object(
             map.into_iter()
@@ -168,7 +165,7 @@ fn remove_key_from_json(value: serde_json::Value, key: &str) -> serde_json::Valu
 /// 1. Remove empty object mappings from JSON arrays
 /// 2. If there are two elements in a JSON array and one is an empty object
 ///     mapping and the other is not, then lift up the one that isn't
-fn normalize_json_value(value: serde_json::Value) -> serde_json::Value {
+pub(crate) fn normalize_json_value(value: serde_json::Value) -> serde_json::Value {
     match value {
         serde_json::Value::Array(vec) => {
             let orig_length = vec.len();
diff --git a/compiler/ast/src/passes/visitor.rs b/compiler/ast/src/passes/visitor.rs
index c7b64f5bfa..e1585c7029 100644
--- a/compiler/ast/src/passes/visitor.rs
+++ b/compiler/ast/src/passes/visitor.rs
@@ -29,84 +29,84 @@ impl Default for VisitResult {
     }
 }
 
-pub trait ExpressionVisitor {
-    fn visit_expression(&mut self, _input: &Expression) -> VisitResult {
+pub trait ExpressionVisitor<'a> {
+    fn visit_expression(&mut self, _input: &'a Expression) -> VisitResult {
         Default::default()
     }
 
-    fn visit_identifer(&mut self, _input: &Identifier) -> VisitResult {
+    fn visit_identifier(&mut self, _input: &'a Identifier) -> VisitResult {
         Default::default()
     }
 
-    fn visit_value(&mut self, _input: &ValueExpression) -> VisitResult {
+    fn visit_value(&mut self, _input: &'a ValueExpression) -> VisitResult {
         Default::default()
     }
 
-    fn visit_binary(&mut self, _input: &BinaryExpression) -> VisitResult {
+    fn visit_binary(&mut self, _input: &'a BinaryExpression) -> VisitResult {
         Default::default()
     }
 
-    fn visit_unary(&mut self, _input: &UnaryExpression) -> VisitResult {
+    fn visit_unary(&mut self, _input: &'a UnaryExpression) -> VisitResult {
         Default::default()
     }
 
-    fn visit_ternary(&mut self, _input: &TernaryExpression) -> VisitResult {
+    fn visit_ternary(&mut self, _input: &'a TernaryExpression) -> VisitResult {
         Default::default()
     }
 
-    fn visit_call(&mut self, _input: &CallExpression) -> VisitResult {
+    fn visit_call(&mut self, _input: &'a CallExpression) -> VisitResult {
         Default::default()
     }
 
-    fn visit_err(&mut self, _input: &ErrExpression) -> VisitResult {
+    fn visit_err(&mut self, _input: &'a ErrExpression) -> VisitResult {
         Default::default()
     }
 }
 
-pub trait StatementVisitor {
-    fn visit_statement(&mut self, _input: &Statement) -> VisitResult {
+pub trait StatementVisitor<'a> {
+    fn visit_statement(&mut self, _input: &'a Statement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_return(&mut self, _input: &ReturnStatement) -> VisitResult {
+    fn visit_return(&mut self, _input: &'a ReturnStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_definition(&mut self, _input: &DefinitionStatement) -> VisitResult {
+    fn visit_definition(&mut self, _input: &'a DefinitionStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_assign(&mut self, _input: &AssignStatement) -> VisitResult {
+    fn visit_assign(&mut self, _input: &'a AssignStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_conditional(&mut self, _input: &ConditionalStatement) -> VisitResult {
+    fn visit_conditional(&mut self, _input: &'a ConditionalStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_iteration(&mut self, _input: &IterationStatement) -> VisitResult {
+    fn visit_iteration(&mut self, _input: &'a IterationStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_console(&mut self, _input: &ConsoleStatement) -> VisitResult {
+    fn visit_console(&mut self, _input: &'a ConsoleStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_expression_statement(&mut self, _input: &ExpressionStatement) -> VisitResult {
+    fn visit_expression_statement(&mut self, _input: &'a ExpressionStatement) -> VisitResult {
         Default::default()
     }
 
-    fn visit_block(&mut self, _input: &Block) -> VisitResult {
+    fn visit_block(&mut self, _input: &'a Block) -> VisitResult {
         Default::default()
     }
 }
 
-pub trait ProgramVisitor {
-    fn visit_program(&mut self, _input: &Program) -> VisitResult {
+pub trait ProgramVisitor<'a> {
+    fn visit_program(&mut self, _input: &'a Program) -> VisitResult {
         Default::default()
     }
 
-    fn visit_function(&mut self, _input: &Function) -> VisitResult {
+    fn visit_function(&mut self, _input: &'a Function) -> VisitResult {
         Default::default()
     }
 }
diff --git a/compiler/ast/src/passes/visitor_director.rs b/compiler/ast/src/passes/visitor_director.rs
index 45e7188d22..f1cb373a21 100644
--- a/compiler/ast/src/passes/visitor_director.rs
+++ b/compiler/ast/src/passes/visitor_director.rs
@@ -18,25 +18,28 @@
 //! It implements default methods for each node to be made
 //! given the type of node its visiting.
 
-// temporary till we use in another pr.
-#![allow(dead_code)]
+use std::marker::PhantomData;
 
 use crate::*;
 
-pub struct VisitorDirector<V: ExpressionVisitor> {
+pub struct VisitorDirector<'a, V: ExpressionVisitor<'a>> {
     visitor: V,
+    lifetime: PhantomData<&'a ()>,
 }
 
-impl<V: ExpressionVisitor> VisitorDirector<V> {
+impl<'a, V: ExpressionVisitor<'a>> VisitorDirector<'a, V> {
     pub fn new(visitor: V) -> Self {
-        Self { visitor }
+        Self {
+            visitor,
+            lifetime: PhantomData,
+        }
     }
 
     pub fn visitor(self) -> V {
         self.visitor
     }
 
-    pub fn visit_expression(&mut self, input: &Expression) {
+    pub fn visit_expression(&mut self, input: &'a Expression) {
         if let VisitResult::VisitChildren = self.visitor.visit_expression(input) {
             match input {
                 Expression::Identifier(_) => {}
@@ -50,20 +53,20 @@ impl<V: ExpressionVisitor> VisitorDirector<V> {
         }
     }
 
-    pub fn visit_binary(&mut self, input: &BinaryExpression) {
+    pub fn visit_binary(&mut self, input: &'a BinaryExpression) {
         if let VisitResult::VisitChildren = self.visitor.visit_binary(input) {
             self.visit_expression(&input.left);
             self.visit_expression(&input.right);
         }
     }
 
-    pub fn visit_unary(&mut self, input: &UnaryExpression) {
+    pub fn visit_unary(&mut self, input: &'a UnaryExpression) {
         if let VisitResult::VisitChildren = self.visitor.visit_unary(input) {
             self.visit_expression(&input.inner);
         }
     }
 
-    pub fn visit_ternary(&mut self, input: &TernaryExpression) {
+    pub fn visit_ternary(&mut self, input: &'a TernaryExpression) {
         if let VisitResult::VisitChildren = self.visitor.visit_ternary(input) {
             self.visit_expression(&input.condition);
             self.visit_expression(&input.if_true);
@@ -71,16 +74,18 @@ impl<V: ExpressionVisitor> VisitorDirector<V> {
         }
     }
 
-    pub fn visit_call(&mut self, input: &CallExpression) {
+    pub fn visit_call(&mut self, input: &'a CallExpression) {
         if let VisitResult::VisitChildren = self.visitor.visit_call(input) {
             self.visit_expression(&input.function);
-            input.arguments.iter().for_each(|expr| self.visit_expression(expr));
+            for expr in input.arguments.iter() {
+                self.visit_expression(expr);
+            }
         }
     }
 }
 
-impl<V: ExpressionVisitor + StatementVisitor> VisitorDirector<V> {
-    fn visit_statement(&mut self, input: &Statement) {
+impl<'a, V: ExpressionVisitor<'a> + StatementVisitor<'a>> VisitorDirector<'a, V> {
+    pub fn visit_statement(&mut self, input: &'a Statement) {
         if let VisitResult::VisitChildren = self.visitor.visit_statement(input) {
             match input {
                 Statement::Return(stmt) => self.visit_return(stmt),
@@ -95,25 +100,25 @@ impl<V: ExpressionVisitor + StatementVisitor> VisitorDirector<V> {
         }
     }
 
-    fn visit_return(&mut self, input: &ReturnStatement) {
+    pub fn visit_return(&mut self, input: &'a ReturnStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_return(input) {
             self.visit_expression(&input.expression);
         }
     }
 
-    fn visit_definition(&mut self, input: &DefinitionStatement) {
+    pub fn visit_definition(&mut self, input: &'a DefinitionStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_definition(input) {
             self.visit_expression(&input.value);
         }
     }
 
-    fn visit_assign(&mut self, input: &AssignStatement) {
+    pub fn visit_assign(&mut self, input: &'a AssignStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_assign(input) {
             self.visit_expression(&input.value);
         }
     }
 
-    fn visit_conditional(&mut self, input: &ConditionalStatement) {
+    pub fn visit_conditional(&mut self, input: &'a ConditionalStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_conditional(input) {
             self.visit_expression(&input.condition);
             self.visit_block(&input.block);
@@ -123,7 +128,7 @@ impl<V: ExpressionVisitor + StatementVisitor> VisitorDirector<V> {
         }
     }
 
-    fn visit_iteration(&mut self, input: &IterationStatement) {
+    pub fn visit_iteration(&mut self, input: &'a IterationStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_iteration(input) {
             self.visit_expression(&input.start);
             self.visit_expression(&input.stop);
@@ -131,7 +136,7 @@ impl<V: ExpressionVisitor + StatementVisitor> VisitorDirector<V> {
         }
     }
 
-    fn visit_console(&mut self, input: &ConsoleStatement) {
+    pub fn visit_console(&mut self, input: &'a ConsoleStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_console(input) {
             if let ConsoleFunction::Assert(expr) = &input.function {
                 self.visit_expression(expr);
@@ -139,30 +144,31 @@ impl<V: ExpressionVisitor + StatementVisitor> VisitorDirector<V> {
         }
     }
 
-    fn visit_expression_statement(&mut self, input: &ExpressionStatement) {
+    pub fn visit_expression_statement(&mut self, input: &'a ExpressionStatement) {
         if let VisitResult::VisitChildren = self.visitor.visit_expression_statement(input) {
             self.visit_expression(&input.expression);
         }
     }
 
-    fn visit_block(&mut self, input: &Block) {
+    pub fn visit_block(&mut self, input: &'a Block) {
         if let VisitResult::VisitChildren = self.visitor.visit_block(input) {
-            input.statements.iter().for_each(|stmt| self.visit_statement(stmt));
+            for stmt in input.statements.iter() {
+                self.visit_statement(stmt);
+            }
         }
     }
 }
 
-impl<V: ExpressionVisitor + ProgramVisitor + StatementVisitor> VisitorDirector<V> {
-    fn visit_program(&mut self, input: &Program) {
+impl<'a, V: ExpressionVisitor<'a> + ProgramVisitor<'a> + StatementVisitor<'a>> VisitorDirector<'a, V> {
+    pub fn visit_program(&mut self, input: &'a Program) {
         if let VisitResult::VisitChildren = self.visitor.visit_program(input) {
-            input
-                .functions
-                .values()
-                .for_each(|function| self.visit_function(function));
+            for function in input.functions.values() {
+                self.visit_function(function);
+            }
         }
     }
 
-    fn visit_function(&mut self, input: &Function) {
+    pub fn visit_function(&mut self, input: &'a Function) {
         if let VisitResult::VisitChildren = self.visitor.visit_function(input) {
             self.visit_block(&input.block);
         }
diff --git a/compiler/compiler/Cargo.toml b/compiler/compiler/Cargo.toml
index a8cfc91982..744bb05c25 100644
--- a/compiler/compiler/Cargo.toml
+++ b/compiler/compiler/Cargo.toml
@@ -22,24 +22,36 @@ rust-version = "1.56.1"
 path = "../ast"
 version = "1.5.3"
 
-[dependencies.leo-ast-passes]
-path = "../ast-passes"
-version = "1.5.3"
-
 [dependencies.leo-errors]
 path = "../../leo/errors"
 version = "1.5.3"
 
+[dependencies.leo-passes]
+path = "../passes"
+version = "1.5.3"
+
 [dependencies.leo-parser]
 path = "../parser"
 version = "1.5.3"
 
-[dependencies.leo-span]
+[dependencies.sha2]
+version = "0.10"
+
+[dev-dependencies.leo-span]
 path = "../../leo/span"
 version = "1.5.3"
 
-[dependencies.sha2]
-version = "0.10"
+[dev-dependencies.leo-test-framework]
+path = "../../tests/test-framework"
+version = "1.4.0"
+
+[dev-dependencies.serde]
+version = "1.0.136"
+features = ["derive"]
+
+[dev-dependencies.serde_yaml]
+version = "0.8.23"
+
 
 [features]
 default = [ ]
diff --git a/compiler/compiler/src/lib.rs b/compiler/compiler/src/lib.rs
index e42267e7cc..e063b577e9 100644
--- a/compiler/compiler/src/lib.rs
+++ b/compiler/compiler/src/lib.rs
@@ -22,38 +22,41 @@
 #![allow(clippy::upper_case_acronyms)]
 #![doc = include_str!("../README.md")]
 
-pub use leo_ast::Ast;
+#[cfg(test)]
+mod test;
+
+use leo_ast::Program;
+pub use leo_ast::{Ast, InputAst};
 use leo_errors::emitter::Handler;
 use leo_errors::{CompilerError, Result};
-use leo_span::symbol::create_session_if_not_set_then;
+pub use leo_passes::SymbolTable;
+use leo_passes::*;
 
 use sha2::{Digest, Sha256};
 use std::fs;
 use std::path::PathBuf;
 
+#[derive(Clone)]
 /// The primary entry point of the Leo compiler.
 pub struct Compiler<'a> {
     handler: &'a Handler,
     main_file_path: PathBuf,
     output_directory: PathBuf,
-    input_file_path: PathBuf,
+    pub ast: Ast,
+    pub input_ast: Option<InputAst>,
 }
 
 impl<'a> Compiler<'a> {
     ///
     /// Returns a new Leo compiler.
     ///
-    pub fn new(
-        handler: &'a Handler,
-        main_file_path: PathBuf,
-        output_directory: PathBuf,
-        input_file_path: PathBuf,
-    ) -> Self {
+    pub fn new(handler: &'a Handler, main_file_path: PathBuf, output_directory: PathBuf) -> Self {
         Self {
             handler,
             main_file_path,
             output_directory,
-            input_file_path,
+            ast: Ast::new(Program::new("Initial".to_string())),
+            input_ast: None,
         }
     }
 
@@ -73,28 +76,8 @@ impl<'a> Compiler<'a> {
         Ok(format!("{:x}", hash))
     }
 
-    ///
-    /// Runs the compiler stages.
-    ///
-    fn compiler_stages(self) -> Result<leo_ast::Ast> {
-        //load the input file if it exists.
-        let _input_ast = if self.input_file_path.exists() {
-            let input_string = fs::read_to_string(&self.input_file_path)
-                .map_err(|e| CompilerError::file_read_error(self.main_file_path.clone(), e))?;
-
-            Some(leo_parser::parse_input(
-                self.handler,
-                self.input_file_path.to_str().unwrap_or_default(),
-                input_string,
-            )?)
-        } else {
-            None
-        };
-
-        // Load the program file.
-        let program_string = fs::read_to_string(&self.main_file_path)
-            .map_err(|e| CompilerError::file_read_error(self.main_file_path.clone(), e))?;
-
+    // Parses and stores a program file content from a string, constructs a syntax tree, and generates a program.
+    pub fn parse_program_from_string(&mut self, program_string: &str) -> Result<()> {
         // Use the parser to construct the abstract syntax tree (ast).
         let ast: leo_ast::Ast = leo_parser::parse_ast(
             self.handler,
@@ -102,20 +85,58 @@ impl<'a> Compiler<'a> {
             program_string,
         )?;
         // Write the AST snapshot post parsing.
-        ast.to_json_file_without_keys(self.output_directory, "initial_ast.json", &["span"])?;
+        ast.to_json_file_without_keys(self.output_directory.clone(), "initial_ast.json", &["span"])?;
 
-        // Canonicalize the AST.
-        // ast = leo_ast_passes::Canonicalizer::do_pass(Default::default(), ast.into_repr())?;
-        // Write the AST snapshot post parsing
-        // ast.to_json_file_without_keys(self.output_directory, "canonicalization_ast.json", &["span"])?;
+        self.ast = ast;
 
-        Ok(ast)
+        Ok(())
+    }
+
+    /// Parses and stores the main program file, constructs a syntax tree, and generates a program.
+    pub fn parse_program(&mut self) -> Result<()> {
+        // Load the program file.
+        let program_string = fs::read_to_string(&self.main_file_path)
+            .map_err(|e| CompilerError::file_read_error(self.main_file_path.clone(), e))?;
+
+        self.parse_program_from_string(&program_string)
+    }
+
+    /// Parses and stores the input file, constructs a syntax tree, and generates a program input.
+    pub fn parse_input_from_string(&mut self, input_file_path: PathBuf, input_string: &str) -> Result<()> {
+        let input_ast =
+            leo_parser::parse_input(self.handler, input_file_path.to_str().unwrap_or_default(), input_string)?;
+        input_ast.to_json_file_without_keys(self.output_directory.clone(), "inital_input_ast.json", &["span"])?;
+
+        self.input_ast = Some(input_ast);
+        Ok(())
+    }
+
+    /// Parses and stores the input file, constructs a syntax tree, and generates a program input.
+    pub fn parse_input(&mut self, input_file_path: PathBuf) -> Result<()> {
+        // Load the input file if it exists.
+        if input_file_path.exists() {
+            let input_string = fs::read_to_string(&input_file_path)
+                .map_err(|e| CompilerError::file_read_error(input_file_path.clone(), e))?;
+
+            self.parse_input_from_string(input_file_path, &input_string)?;
+        }
+
+        Ok(())
+    }
+
+    ///
+    /// Runs the compiler stages.
+    ///
+    fn compiler_stages(&self) -> Result<SymbolTable<'_>> {
+        let symbol_table = CreateSymbolTable::do_pass((&self.ast, self.handler))?;
+
+        Ok(symbol_table)
     }
 
     ///
     /// Returns a compiled Leo program.
     ///
-    pub fn compile(self) -> Result<leo_ast::Ast> {
-        create_session_if_not_set_then(|_| self.compiler_stages())
+    pub fn compile(&self) -> Result<SymbolTable<'_>> {
+        self.compiler_stages()
     }
 }
diff --git a/compiler/compiler/src/test.rs b/compiler/compiler/src/test.rs
new file mode 100644
index 0000000000..e83fd80d42
--- /dev/null
+++ b/compiler/compiler/src/test.rs
@@ -0,0 +1,224 @@
+// Copyright (C) 2019-2022 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use std::{
+    cell::RefCell,
+    fmt, fs,
+    path::{Path, PathBuf},
+    rc::Rc,
+};
+
+use crate::Compiler;
+
+use leo_errors::{
+    emitter::{Buffer, Emitter, Handler},
+    LeoError, LeoWarning,
+};
+use leo_passes::SymbolTable;
+use leo_span::symbol::create_session_if_not_set_then;
+use leo_test_framework::{
+    runner::{Namespace, ParseType, Runner},
+    Test,
+};
+use serde::{Deserialize, Serialize};
+use serde_yaml::Value;
+
+fn new_compiler(handler: &Handler, main_file_path: PathBuf) -> Compiler<'_> {
+    let output_dir = PathBuf::from("/tmp/output/");
+    fs::create_dir_all(output_dir.clone()).unwrap();
+
+    Compiler::new(handler, main_file_path, output_dir)
+}
+
+fn parse_program<'a>(
+    handler: &'a Handler,
+    program_string: &str,
+    cwd: Option<PathBuf>,
+) -> Result<Compiler<'a>, LeoError> {
+    let mut compiler = new_compiler(handler, cwd.unwrap_or_else(|| "compiler-test".into()));
+    compiler.parse_program_from_string(program_string)?;
+
+    Ok(compiler)
+}
+
+fn hash_content(content: &str) -> String {
+    use sha2::{Digest, Sha256};
+    let mut hasher = Sha256::new();
+    hasher.update(content);
+    let hash = hasher.finalize();
+
+    format!("{:x}", hash)
+}
+
+fn hash_file(path: &str) -> String {
+    let file = fs::read_to_string(&Path::new(path)).unwrap();
+    hash_content(&file)
+}
+
+struct CompileNamespace;
+
+impl Namespace for CompileNamespace {
+    fn parse_type(&self) -> ParseType {
+        ParseType::Whole
+    }
+
+    fn run_test(&self, test: Test) -> Result<Value, String> {
+        let buf = BufferEmitter(Rc::default(), Rc::default());
+        let handler = Handler::new(Box::new(buf.clone()));
+
+        create_session_if_not_set_then(|_| run_test(test, &handler, &buf).map_err(|()| buf.0.take().to_string()))
+    }
+}
+
+#[derive(Deserialize, PartialEq, Serialize)]
+struct OutputItem {
+    pub initial_input_ast: String,
+    pub symbol_table: String,
+}
+
+#[derive(Deserialize, PartialEq, Serialize)]
+struct CompileOutput {
+    pub output: Vec<OutputItem>,
+    pub initial_ast: String,
+}
+
+/// Get the path of the `input_file` given in `input` into `list`.
+fn get_input_file_paths(list: &mut Vec<PathBuf>, test: &Test, input: &Value) {
+    let input_file: PathBuf = test.path.parent().expect("no test parent dir").into();
+    if input.as_str().is_some() {
+        let mut input_file = input_file;
+        input_file.push(input.as_str().expect("input_file was not a string or array"));
+        list.push(input_file.clone());
+    }
+}
+
+/// Collect and return all inputs, if possible.
+fn collect_all_inputs(test: &Test) -> Result<Vec<PathBuf>, String> {
+    let mut list = vec![];
+
+    if let Some(input) = test.config.get("input_file") {
+        get_input_file_paths(&mut list, test, input);
+    }
+
+    Ok(list)
+}
+
+fn compile_and_process<'a>(
+    parsed: &'a mut Compiler<'a>,
+    input_file_path: PathBuf,
+) -> Result<SymbolTable<'a>, LeoError> {
+    parsed.parse_input(input_file_path)?;
+    parsed.compiler_stages()
+}
+
+// Errors used in this module.
+enum LeoOrString {
+    Leo(LeoError),
+    String(String),
+}
+
+impl fmt::Display for LeoOrString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Leo(x) => x.fmt(f),
+            Self::String(x) => x.fmt(f),
+        }
+    }
+}
+
+/// A buffer used to emit errors into.
+#[derive(Clone)]
+struct BufferEmitter(Rc<RefCell<Buffer<LeoOrString>>>, Rc<RefCell<Buffer<LeoWarning>>>);
+
+impl Emitter for BufferEmitter {
+    fn emit_err(&mut self, err: LeoError) {
+        self.0.borrow_mut().push(LeoOrString::Leo(err));
+    }
+
+    fn last_emited_err(&self) -> Option<LeoError> {
+        let temp = &*self.0.borrow();
+        temp.last_entry().map(|entry| match entry {
+            LeoOrString::Leo(err) => err.clone(),
+            _ => unimplemented!(),
+        })
+    }
+
+    fn emit_warning(&mut self, warning: leo_errors::LeoWarning) {
+        self.1.borrow_mut().push(warning);
+    }
+}
+
+fn buffer_if_err<T>(buf: &BufferEmitter, res: Result<T, String>) -> Result<T, ()> {
+    res.map_err(|err| buf.0.borrow_mut().push(LeoOrString::String(err)))
+}
+
+fn run_test(test: Test, handler: &Handler, err_buf: &BufferEmitter) -> Result<Value, ()> {
+    // Check for CWD option:
+    // ``` cwd: import ```
+    // When set, uses different working directory for current file.
+    // If not, uses file path as current working directory.
+    let cwd = test.config.get("cwd").map(|val| {
+        let mut cwd = test.path.clone();
+        cwd.pop();
+        cwd.join(&val.as_str().unwrap())
+    });
+
+    let parsed = handler.extend_if_error(parse_program(handler, &test.content, cwd))?;
+
+    // (name, content)
+    let inputs = buffer_if_err(err_buf, collect_all_inputs(&test))?;
+
+    let mut output_items = Vec::with_capacity(inputs.len());
+
+    for input in inputs {
+        let mut parsed = parsed.clone();
+        let symbol_table = handler.extend_if_error(compile_and_process(&mut parsed, input))?;
+        let initial_input_ast = hash_file("/tmp/output/inital_input_ast.json");
+
+        output_items.push(OutputItem {
+            initial_input_ast,
+            symbol_table: hash_content(&symbol_table.to_string()),
+        });
+    }
+
+    let initial_ast = hash_file("/tmp/output/initial_ast.json");
+
+    if fs::read_dir("/tmp/output").is_ok() {
+        fs::remove_dir_all(Path::new("/tmp/output")).expect("Error failed to clean up output dir.");
+    }
+
+    let final_output = CompileOutput {
+        output: output_items,
+        initial_ast,
+    };
+    Ok(serde_yaml::to_value(&final_output).expect("serialization failed"))
+}
+
+struct TestRunner;
+
+impl Runner for TestRunner {
+    fn resolve_namespace(&self, name: &str) -> Option<Box<dyn Namespace>> {
+        Some(match name {
+            "Compile" => Box::new(CompileNamespace),
+            _ => return None,
+        })
+    }
+}
+
+#[test]
+pub fn compiler_tests() {
+    leo_test_framework::run_tests(&TestRunner, "compiler");
+}
diff --git a/compiler/parser/Cargo.toml b/compiler/parser/Cargo.toml
index 4d39d12ea9..1ffe50462a 100644
--- a/compiler/parser/Cargo.toml
+++ b/compiler/parser/Cargo.toml
@@ -23,9 +23,6 @@ name = "leo_ast"
 path = "benches/leo_ast.rs"
 harness = false
 
-[dependencies]
-smallvec = "1.8"
-
 [dependencies.leo-ast]
 path = "../ast"
 version = "1.5.3"
@@ -52,6 +49,9 @@ version = "1.3.0"
 version = "1.0"
 features = [ "derive" ]
 
+[dependencies.smallvec]
+version = "1.8"
+
 [dependencies.tracing]
 version = "0.1"
 
diff --git a/compiler/parser/src/parser/input.rs b/compiler/parser/src/parser/input.rs
index 05dba6eda1..aebdaaafce 100644
--- a/compiler/parser/src/parser/input.rs
+++ b/compiler/parser/src/parser/input.rs
@@ -20,7 +20,7 @@ use leo_errors::{ParserError, Result};
 
 impl ParserContext<'_> {
     /// Returns a [`ParsedInputFile`] struct filled with the data acquired in the file.
-    pub fn parse_input(&mut self) -> Result<ParsedInputFile> {
+    pub fn parse_input(&mut self) -> Result<InputAst> {
         let mut sections = Vec::new();
 
         while self.has_next() {
@@ -31,7 +31,7 @@ impl ParserContext<'_> {
             }
         }
 
-        Ok(ParsedInputFile { sections })
+        Ok(InputAst { sections })
     }
 
     /// Parses particular section in the Input or State file.
@@ -67,7 +67,7 @@ impl ParserContext<'_> {
         self.expect(&Token::Colon)?;
         let (type_, span) = self.parse_non_ident_types()?;
         self.expect(&Token::Assign)?;
-        let value = self.parse_primary_expression()?;
+        let value = self.parse_unary_expression()?;
         self.expect(&Token::Semicolon)?;
 
         Ok(Definition {
diff --git a/compiler/parser/src/parser/mod.rs b/compiler/parser/src/parser/mod.rs
index db828fda04..5868847406 100644
--- a/compiler/parser/src/parser/mod.rs
+++ b/compiler/parser/src/parser/mod.rs
@@ -57,7 +57,7 @@ pub fn parse(handler: &Handler, path: &str, source: &str) -> Result<Program> {
 }
 
 /// Parses an input file at the given file `path` and `source` code text.
-pub fn parse_input<T: AsRef<str>, Y: AsRef<str>>(handler: &Handler, path: T, source: Y) -> Result<ParsedInputFile> {
+pub fn parse_input<T: AsRef<str>, Y: AsRef<str>>(handler: &Handler, path: T, source: Y) -> Result<InputAst> {
     let mut tokens = ParserContext::new(handler, crate::tokenize(path.as_ref(), source.as_ref())?);
 
     tokens.parse_input()
diff --git a/compiler/ast-passes/Cargo.toml b/compiler/passes/Cargo.toml
similarity index 89%
rename from compiler/ast-passes/Cargo.toml
rename to compiler/passes/Cargo.toml
index bb1680fcb9..0c2a476353 100644
--- a/compiler/ast-passes/Cargo.toml
+++ b/compiler/passes/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "leo-ast-passes"
+name = "leo-passes"
 version = "1.5.3"
 authors = [ "The Aleo Team <hello@aleo.org>" ]
 description = "The Leo programming language"
@@ -39,7 +39,3 @@ version = "1.5.3"
 [dependencies.leo-span]
 path = "../../leo/span"
 version = "1.5.3"
-
-#[dependencies.leo-stdlib]
-#path = "../stdlib"
-#version = "1.5.3"
\ No newline at end of file
diff --git a/compiler/ast-passes/LICENSE.md b/compiler/passes/LICENSE.md
similarity index 100%
rename from compiler/ast-passes/LICENSE.md
rename to compiler/passes/LICENSE.md
diff --git a/compiler/ast-passes/README.md b/compiler/passes/README.md
similarity index 100%
rename from compiler/ast-passes/README.md
rename to compiler/passes/README.md
diff --git a/compiler/ast-passes/src/canonicalization/canonicalizer.rs b/compiler/passes/src/canonicalization/canonicalizer.rs
similarity index 100%
rename from compiler/ast-passes/src/canonicalization/canonicalizer.rs
rename to compiler/passes/src/canonicalization/canonicalizer.rs
diff --git a/compiler/ast-passes/src/canonicalization/mod.rs b/compiler/passes/src/canonicalization/mod.rs
similarity index 100%
rename from compiler/ast-passes/src/canonicalization/mod.rs
rename to compiler/passes/src/canonicalization/mod.rs
diff --git a/compiler/ast-passes/src/import_resolution/importer.rs b/compiler/passes/src/import_resolution/importer.rs
similarity index 100%
rename from compiler/ast-passes/src/import_resolution/importer.rs
rename to compiler/passes/src/import_resolution/importer.rs
diff --git a/compiler/ast-passes/src/import_resolution/mod.rs b/compiler/passes/src/import_resolution/mod.rs
similarity index 100%
rename from compiler/ast-passes/src/import_resolution/mod.rs
rename to compiler/passes/src/import_resolution/mod.rs
diff --git a/compiler/ast-passes/src/import_resolution/resolver.rs b/compiler/passes/src/import_resolution/resolver.rs
similarity index 100%
rename from compiler/ast-passes/src/import_resolution/resolver.rs
rename to compiler/passes/src/import_resolution/resolver.rs
diff --git a/compiler/ast-passes/src/lib.rs b/compiler/passes/src/lib.rs
similarity index 92%
rename from compiler/ast-passes/src/lib.rs
rename to compiler/passes/src/lib.rs
index 3264d2240a..efc2b74574 100644
--- a/compiler/ast-passes/src/lib.rs
+++ b/compiler/passes/src/lib.rs
@@ -25,3 +25,9 @@ pub use canonicalization::*;
 // until we migrate stdlib and then import resolution.
 /* pub mod import_resolution;
 pub use import_resolution::*; */
+
+pub mod pass;
+pub use self::pass::*;
+
+pub mod symbol_table;
+pub use symbol_table::*;
diff --git a/compiler/ast/src/pass.rs b/compiler/passes/src/pass.rs
similarity index 86%
rename from compiler/ast/src/pass.rs
rename to compiler/passes/src/pass.rs
index 2ac35621b9..fdbe851f45 100644
--- a/compiler/ast/src/pass.rs
+++ b/compiler/passes/src/pass.rs
@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Ast, Program};
-use leo_errors::Result;
-
 /// A pass consuming a `Program` and possibly returning an `Ast`.
-pub trait AstPass {
-    fn do_pass(self, ast: Program) -> Result<Ast>;
+pub trait Pass<'a> {
+    type Input;
+    type Output;
+
+    fn do_pass(input: Self::Input) -> Self::Output;
 }
diff --git a/compiler/passes/src/symbol_table/create.rs b/compiler/passes/src/symbol_table/create.rs
new file mode 100644
index 0000000000..4d2b414a48
--- /dev/null
+++ b/compiler/passes/src/symbol_table/create.rs
@@ -0,0 +1,50 @@
+// Copyright (C) 2019-2022 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use leo_ast::*;
+use leo_errors::emitter::Handler;
+
+use crate::SymbolTable;
+
+pub struct CreateSymbolTable<'a> {
+    symbol_table: SymbolTable<'a>,
+    handler: &'a Handler,
+}
+
+impl<'a> CreateSymbolTable<'a> {
+    pub fn new(handler: &'a Handler) -> Self {
+        Self {
+            symbol_table: SymbolTable::default(),
+            handler,
+        }
+    }
+    pub fn symbol_table(self) -> SymbolTable<'a> {
+        self.symbol_table
+    }
+}
+
+impl<'a> ExpressionVisitor<'a> for CreateSymbolTable<'a> {}
+
+impl<'a> StatementVisitor<'a> for CreateSymbolTable<'a> {}
+
+impl<'a> ProgramVisitor<'a> for CreateSymbolTable<'a> {
+    fn visit_function(&mut self, input: &'a Function) -> VisitResult {
+        if let Err(err) = self.symbol_table.insert_fn(input.name(), input) {
+            self.handler.emit_err(err);
+        }
+        VisitResult::SkipChildren
+    }
+}
diff --git a/compiler/passes/src/symbol_table/mod.rs b/compiler/passes/src/symbol_table/mod.rs
new file mode 100644
index 0000000000..77622607e3
--- /dev/null
+++ b/compiler/passes/src/symbol_table/mod.rs
@@ -0,0 +1,42 @@
+// Copyright (C) 2019-2022 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+pub mod create;
+pub use create::*;
+
+pub mod table;
+pub use table::*;
+
+pub mod variable_symbol;
+pub use variable_symbol::*;
+
+use crate::Pass;
+
+use leo_ast::{Ast, VisitorDirector};
+use leo_errors::{emitter::Handler, Result};
+
+impl<'a> Pass<'a> for CreateSymbolTable<'a> {
+    type Input = (&'a Ast, &'a Handler);
+    type Output = Result<SymbolTable<'a>>;
+
+    fn do_pass((ast, handler): Self::Input) -> Self::Output {
+        let mut visitor = VisitorDirector::new(CreateSymbolTable::new(handler));
+        visitor.visit_program(ast.as_repr());
+        handler.last_err()?;
+
+        Ok(visitor.visitor().symbol_table())
+    }
+}
diff --git a/compiler/passes/src/symbol_table/table.rs b/compiler/passes/src/symbol_table/table.rs
new file mode 100644
index 0000000000..ccc6a3f363
--- /dev/null
+++ b/compiler/passes/src/symbol_table/table.rs
@@ -0,0 +1,68 @@
+// Copyright (C) 2019-2022 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use std::fmt::Display;
+
+use leo_ast::Function;
+use leo_errors::{AstError, Result};
+use leo_span::Symbol;
+
+use indexmap::IndexMap;
+
+use crate::VariableSymbol;
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct SymbolTable<'a> {
+    /// Functions represents the name of each function mapped to the Ast's function definition.
+    /// This field is populated at a first pass.
+    functions: IndexMap<Symbol, &'a Function>,
+    /// Variables represents functions variable definitions and input variables.
+    /// This field is not populated till necessary.
+    variables: VariableSymbol<'a>,
+}
+
+impl<'a> SymbolTable<'a> {
+    pub fn check_shadowing(&self, symbol: &Symbol) -> Result<()> {
+        if let Some(function) = self.functions.get(symbol) {
+            Err(AstError::shadowed_function(symbol, &function.span).into())
+        } else {
+            self.variables.check_shadowing(symbol)?;
+            Ok(())
+        }
+    }
+
+    pub fn clear_variables(&mut self) {
+        self.variables.clear();
+    }
+
+    pub fn insert_fn(&mut self, symbol: Symbol, function: &'a Function) -> Result<()> {
+        self.check_shadowing(&symbol)?;
+        self.functions.insert(symbol, function);
+        Ok(())
+    }
+}
+
+impl<'a> Display for SymbolTable<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "SymbolTable")?;
+
+        for func in self.functions.values() {
+            write!(f, "{func}")?;
+        }
+
+        write!(f, "{}", self.variables)
+    }
+}
diff --git a/compiler/passes/src/symbol_table/variable_symbol.rs b/compiler/passes/src/symbol_table/variable_symbol.rs
new file mode 100644
index 0000000000..01d3bd4776
--- /dev/null
+++ b/compiler/passes/src/symbol_table/variable_symbol.rs
@@ -0,0 +1,91 @@
+// Copyright (C) 2019-2022 Aleo Systems Inc.
+// This file is part of the Leo library.
+
+// The Leo library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Leo library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
+
+use std::fmt::Display;
+
+use indexmap::IndexMap;
+use leo_ast::{DefinitionStatement, FunctionInput, FunctionInputVariable};
+use leo_errors::{AstError, Result};
+use leo_span::Symbol;
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct VariableSymbol<'a> {
+    /// The parent scope of variables if it exists.
+    /// For example if we are in a if block inside a function.
+    /// The parent would be the functions variables and inputs.
+    /// This field is populated as necessary.
+    parent: Option<Box<VariableSymbol<'a>>>,
+    /// The input variables defined in a scope.
+    /// This field is populated as necessary.
+    inputs: IndexMap<Symbol, &'a FunctionInputVariable>,
+    /// The variables defined in a scope.
+    /// This field is populated as necessary.
+    variables: IndexMap<Symbol, &'a DefinitionStatement>,
+}
+
+impl<'a> VariableSymbol<'a> {
+    pub fn new(parent: Option<Box<VariableSymbol<'a>>>, inputs: Vec<&'a FunctionInput>) -> Self {
+        Self {
+            parent,
+            inputs: inputs
+                .iter()
+                .map(|input| {
+                    let inner = input.get_variable();
+                    (inner.identifier.name, inner)
+                })
+                .collect(),
+            variables: IndexMap::new(),
+        }
+    }
+
+    pub fn check_shadowing(&self, symbol: &Symbol) -> Result<()> {
+        if let Some(input) = self.inputs.get(symbol) {
+            Err(AstError::shadowed_function_input(symbol, &input.span).into())
+        } else if let Some(var) = self.variables.get(symbol) {
+            Err(AstError::shadowed_variable(symbol, &var.span).into())
+        } else if let Some(parent) = &self.parent {
+            parent.check_shadowing(symbol)
+        } else {
+            Ok(())
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.parent = None;
+        self.inputs.clear();
+        self.variables.clear();
+    }
+}
+
+impl<'a> Display for VariableSymbol<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "VariableSymbol")?;
+        self.parent
+            .as_ref()
+            .map(|parent| write!(f, "parent {parent}"))
+            .transpose()?;
+
+        for input in self.inputs.values() {
+            write!(f, "{input}")?;
+        }
+
+        for var in self.variables.values() {
+            write!(f, "{var}")?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/tests/compiler/address/index.leo b/disabled_tests/compiler/address/index.leo
similarity index 100%
rename from tests/compiler/address/index.leo
rename to disabled_tests/compiler/address/index.leo
diff --git a/tests/compiler/aliases/alias_circuit_namespace_conflict_fail.leo b/disabled_tests/compiler/aliases/alias_circuit_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/aliases/alias_circuit_namespace_conflict_fail.leo
rename to disabled_tests/compiler/aliases/alias_circuit_namespace_conflict_fail.leo
diff --git a/tests/compiler/aliases/alias_function_namespace_conflict_fail.leo b/disabled_tests/compiler/aliases/alias_function_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/aliases/alias_function_namespace_conflict_fail.leo
rename to disabled_tests/compiler/aliases/alias_function_namespace_conflict_fail.leo
diff --git a/tests/compiler/aliases/alias_global_const_namespace_conflict_fail copy.leo b/disabled_tests/compiler/aliases/alias_global_const_namespace_conflict_fail copy.leo
similarity index 100%
rename from tests/compiler/aliases/alias_global_const_namespace_conflict_fail copy.leo
rename to disabled_tests/compiler/aliases/alias_global_const_namespace_conflict_fail copy.leo
diff --git a/tests/compiler/aliases/arith.leo b/disabled_tests/compiler/aliases/arith.leo
similarity index 100%
rename from tests/compiler/aliases/arith.leo
rename to disabled_tests/compiler/aliases/arith.leo
diff --git a/tests/compiler/aliases/basic.leo b/disabled_tests/compiler/aliases/basic.leo
similarity index 100%
rename from tests/compiler/aliases/basic.leo
rename to disabled_tests/compiler/aliases/basic.leo
diff --git a/tests/compiler/aliases/circuit.leo b/disabled_tests/compiler/aliases/circuit.leo
similarity index 100%
rename from tests/compiler/aliases/circuit.leo
rename to disabled_tests/compiler/aliases/circuit.leo
diff --git a/tests/compiler/aliases/duplicate_name_fail.leo b/disabled_tests/compiler/aliases/duplicate_name_fail.leo
similarity index 100%
rename from tests/compiler/aliases/duplicate_name_fail.leo
rename to disabled_tests/compiler/aliases/duplicate_name_fail.leo
diff --git a/tests/compiler/aliases/fn_return.leo b/disabled_tests/compiler/aliases/fn_return.leo
similarity index 100%
rename from tests/compiler/aliases/fn_return.leo
rename to disabled_tests/compiler/aliases/fn_return.leo
diff --git a/tests/compiler/aliases/inputs/basic.in b/disabled_tests/compiler/aliases/inputs/basic.in
similarity index 100%
rename from tests/compiler/aliases/inputs/basic.in
rename to disabled_tests/compiler/aliases/inputs/basic.in
diff --git a/tests/compiler/aliases/inputs/dummy.in b/disabled_tests/compiler/aliases/inputs/dummy.in
similarity index 100%
rename from tests/compiler/aliases/inputs/dummy.in
rename to disabled_tests/compiler/aliases/inputs/dummy.in
diff --git a/tests/compiler/aliases/inputs/wrong_type_assign_fail.in b/disabled_tests/compiler/aliases/inputs/wrong_type_assign_fail.in
similarity index 100%
rename from tests/compiler/aliases/inputs/wrong_type_assign_fail.in
rename to disabled_tests/compiler/aliases/inputs/wrong_type_assign_fail.in
diff --git a/tests/compiler/aliases/shadowing_arg.leo b/disabled_tests/compiler/aliases/shadowing_arg.leo
similarity index 100%
rename from tests/compiler/aliases/shadowing_arg.leo
rename to disabled_tests/compiler/aliases/shadowing_arg.leo
diff --git a/tests/compiler/aliases/shadowing_var_allowed.leo b/disabled_tests/compiler/aliases/shadowing_var_allowed.leo
similarity index 100%
rename from tests/compiler/aliases/shadowing_var_allowed.leo
rename to disabled_tests/compiler/aliases/shadowing_var_allowed.leo
diff --git a/tests/compiler/aliases/wrong_type_assign_fail.leo b/disabled_tests/compiler/aliases/wrong_type_assign_fail.leo
similarity index 100%
rename from tests/compiler/aliases/wrong_type_assign_fail.leo
rename to disabled_tests/compiler/aliases/wrong_type_assign_fail.leo
diff --git a/tests/compiler/array/array_range_access_fail.leo b/disabled_tests/compiler/array/array_range_access_fail.leo
similarity index 100%
rename from tests/compiler/array/array_range_access_fail.leo
rename to disabled_tests/compiler/array/array_range_access_fail.leo
diff --git a/tests/compiler/array/array_size_zero_fail.leo b/disabled_tests/compiler/array/array_size_zero_fail.leo
similarity index 100%
rename from tests/compiler/array/array_size_zero_fail.leo
rename to disabled_tests/compiler/array/array_size_zero_fail.leo
diff --git a/tests/compiler/array/complex_access.leo b/disabled_tests/compiler/array/complex_access.leo
similarity index 100%
rename from tests/compiler/array/complex_access.leo
rename to disabled_tests/compiler/array/complex_access.leo
diff --git a/tests/compiler/array/equal_initializer.leo b/disabled_tests/compiler/array/equal_initializer.leo
similarity index 100%
rename from tests/compiler/array/equal_initializer.leo
rename to disabled_tests/compiler/array/equal_initializer.leo
diff --git a/tests/compiler/array/equal_initializer_2.leo b/disabled_tests/compiler/array/equal_initializer_2.leo
similarity index 100%
rename from tests/compiler/array/equal_initializer_2.leo
rename to disabled_tests/compiler/array/equal_initializer_2.leo
diff --git a/tests/compiler/array/input/array_range_access_fail.in b/disabled_tests/compiler/array/input/array_range_access_fail.in
similarity index 100%
rename from tests/compiler/array/input/array_range_access_fail.in
rename to disabled_tests/compiler/array/input/array_range_access_fail.in
diff --git a/tests/compiler/array/input/complex_access.in b/disabled_tests/compiler/array/input/complex_access.in
similarity index 100%
rename from tests/compiler/array/input/complex_access.in
rename to disabled_tests/compiler/array/input/complex_access.in
diff --git a/tests/compiler/array/input/count_to_6.in b/disabled_tests/compiler/array/input/count_to_6.in
similarity index 100%
rename from tests/compiler/array/input/count_to_6.in
rename to disabled_tests/compiler/array/input/count_to_6.in
diff --git a/tests/compiler/array/input/dummy.in b/disabled_tests/compiler/array/input/dummy.in
similarity index 100%
rename from tests/compiler/array/input/dummy.in
rename to disabled_tests/compiler/array/input/dummy.in
diff --git a/tests/compiler/array/input/initializer_fail.in b/disabled_tests/compiler/array/input/initializer_fail.in
similarity index 100%
rename from tests/compiler/array/input/initializer_fail.in
rename to disabled_tests/compiler/array/input/initializer_fail.in
diff --git a/tests/compiler/array/input/input_nested_3x2.in b/disabled_tests/compiler/array/input/input_nested_3x2.in
similarity index 100%
rename from tests/compiler/array/input/input_nested_3x2.in
rename to disabled_tests/compiler/array/input/input_nested_3x2.in
diff --git a/tests/compiler/array/input/input_nested_3x2_fail.in b/disabled_tests/compiler/array/input/input_nested_3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/input_nested_3x2_fail.in
rename to disabled_tests/compiler/array/input/input_nested_3x2_fail.in
diff --git a/tests/compiler/array/input/input_tuple_3x2.in b/disabled_tests/compiler/array/input/input_tuple_3x2.in
similarity index 100%
rename from tests/compiler/array/input/input_tuple_3x2.in
rename to disabled_tests/compiler/array/input/input_tuple_3x2.in
diff --git a/tests/compiler/array/input/input_tuple_3x2_fail.in b/disabled_tests/compiler/array/input/input_tuple_3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/input_tuple_3x2_fail.in
rename to disabled_tests/compiler/array/input/input_tuple_3x2_fail.in
diff --git a/tests/compiler/array/input/registers_ones.in b/disabled_tests/compiler/array/input/registers_ones.in
similarity index 100%
rename from tests/compiler/array/input/registers_ones.in
rename to disabled_tests/compiler/array/input/registers_ones.in
diff --git a/tests/compiler/array/input/registers_zeros.in b/disabled_tests/compiler/array/input/registers_zeros.in
similarity index 100%
rename from tests/compiler/array/input/registers_zeros.in
rename to disabled_tests/compiler/array/input/registers_zeros.in
diff --git a/tests/compiler/array/input/six_zeros.in b/disabled_tests/compiler/array/input/six_zeros.in
similarity index 100%
rename from tests/compiler/array/input/six_zeros.in
rename to disabled_tests/compiler/array/input/six_zeros.in
diff --git a/tests/compiler/array/input/three_ones.in b/disabled_tests/compiler/array/input/three_ones.in
similarity index 100%
rename from tests/compiler/array/input/three_ones.in
rename to disabled_tests/compiler/array/input/three_ones.in
diff --git a/tests/compiler/array/input/type_nested_value_nested_3x2.in b/disabled_tests/compiler/array/input/type_nested_value_nested_3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_nested_3x2.in
rename to disabled_tests/compiler/array/input/type_nested_value_nested_3x2.in
diff --git a/tests/compiler/array/input/type_nested_value_nested_3x2_fail.in b/disabled_tests/compiler/array/input/type_nested_value_nested_3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_nested_3x2_fail.in
rename to disabled_tests/compiler/array/input/type_nested_value_nested_3x2_fail.in
diff --git a/tests/compiler/array/input/type_nested_value_nested_4x3x2.in b/disabled_tests/compiler/array/input/type_nested_value_nested_4x3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_nested_4x3x2.in
rename to disabled_tests/compiler/array/input/type_nested_value_nested_4x3x2.in
diff --git a/tests/compiler/array/input/type_nested_value_nested_4x3x2_fail.in b/disabled_tests/compiler/array/input/type_nested_value_nested_4x3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_nested_4x3x2_fail.in
rename to disabled_tests/compiler/array/input/type_nested_value_nested_4x3x2_fail.in
diff --git a/tests/compiler/array/input/type_nested_value_tuple_3x2.in b/disabled_tests/compiler/array/input/type_nested_value_tuple_3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_tuple_3x2.in
rename to disabled_tests/compiler/array/input/type_nested_value_tuple_3x2.in
diff --git a/tests/compiler/array/input/type_nested_value_tuple_3x2_fail.in b/disabled_tests/compiler/array/input/type_nested_value_tuple_3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_tuple_3x2_fail.in
rename to disabled_tests/compiler/array/input/type_nested_value_tuple_3x2_fail.in
diff --git a/tests/compiler/array/input/type_nested_value_tuple_4x3x2.in b/disabled_tests/compiler/array/input/type_nested_value_tuple_4x3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_tuple_4x3x2.in
rename to disabled_tests/compiler/array/input/type_nested_value_tuple_4x3x2.in
diff --git a/tests/compiler/array/input/type_nested_value_tuple_4x3x2_fail.in b/disabled_tests/compiler/array/input/type_nested_value_tuple_4x3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_nested_value_tuple_4x3x2_fail.in
rename to disabled_tests/compiler/array/input/type_nested_value_tuple_4x3x2_fail.in
diff --git a/tests/compiler/array/input/type_tuple_value_nested_3x2.in b/disabled_tests/compiler/array/input/type_tuple_value_nested_3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_nested_3x2.in
rename to disabled_tests/compiler/array/input/type_tuple_value_nested_3x2.in
diff --git a/tests/compiler/array/input/type_tuple_value_nested_3x2_fail.in b/disabled_tests/compiler/array/input/type_tuple_value_nested_3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_nested_3x2_fail.in
rename to disabled_tests/compiler/array/input/type_tuple_value_nested_3x2_fail.in
diff --git a/tests/compiler/array/input/type_tuple_value_nested_4x3x2.in b/disabled_tests/compiler/array/input/type_tuple_value_nested_4x3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_nested_4x3x2.in
rename to disabled_tests/compiler/array/input/type_tuple_value_nested_4x3x2.in
diff --git a/tests/compiler/array/input/type_tuple_value_nested_4x3x2_fail.in b/disabled_tests/compiler/array/input/type_tuple_value_nested_4x3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_nested_4x3x2_fail.in
rename to disabled_tests/compiler/array/input/type_tuple_value_nested_4x3x2_fail.in
diff --git a/tests/compiler/array/input/type_tuple_value_tuple_3x2.in b/disabled_tests/compiler/array/input/type_tuple_value_tuple_3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_tuple_3x2.in
rename to disabled_tests/compiler/array/input/type_tuple_value_tuple_3x2.in
diff --git a/tests/compiler/array/input/type_tuple_value_tuple_3x2_fail.in b/disabled_tests/compiler/array/input/type_tuple_value_tuple_3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_tuple_3x2_fail.in
rename to disabled_tests/compiler/array/input/type_tuple_value_tuple_3x2_fail.in
diff --git a/tests/compiler/array/input/type_tuple_value_tuple_4x3x2.in b/disabled_tests/compiler/array/input/type_tuple_value_tuple_4x3x2.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_tuple_4x3x2.in
rename to disabled_tests/compiler/array/input/type_tuple_value_tuple_4x3x2.in
diff --git a/tests/compiler/array/input/type_tuple_value_tuple_4x3x2_fail.in b/disabled_tests/compiler/array/input/type_tuple_value_tuple_4x3x2_fail.in
similarity index 100%
rename from tests/compiler/array/input/type_tuple_value_tuple_4x3x2_fail.in
rename to disabled_tests/compiler/array/input/type_tuple_value_tuple_4x3x2_fail.in
diff --git a/tests/compiler/array/input_nested_3x2.leo b/disabled_tests/compiler/array/input_nested_3x2.leo
similarity index 100%
rename from tests/compiler/array/input_nested_3x2.leo
rename to disabled_tests/compiler/array/input_nested_3x2.leo
diff --git a/tests/compiler/array/input_nested_3x2_fail.leo b/disabled_tests/compiler/array/input_nested_3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/input_nested_3x2_fail.leo
rename to disabled_tests/compiler/array/input_nested_3x2_fail.leo
diff --git a/tests/compiler/array/input_tuple_3x2.leo b/disabled_tests/compiler/array/input_tuple_3x2.leo
similarity index 100%
rename from tests/compiler/array/input_tuple_3x2.leo
rename to disabled_tests/compiler/array/input_tuple_3x2.leo
diff --git a/tests/compiler/array/input_tuple_3x2_fail.leo b/disabled_tests/compiler/array/input_tuple_3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/input_tuple_3x2_fail.leo
rename to disabled_tests/compiler/array/input_tuple_3x2_fail.leo
diff --git a/tests/compiler/array/multi_fail_initializer.leo b/disabled_tests/compiler/array/multi_fail_initializer.leo
similarity index 100%
rename from tests/compiler/array/multi_fail_initializer.leo
rename to disabled_tests/compiler/array/multi_fail_initializer.leo
diff --git a/tests/compiler/array/multi_fail_inline.leo b/disabled_tests/compiler/array/multi_fail_inline.leo
similarity index 100%
rename from tests/compiler/array/multi_fail_inline.leo
rename to disabled_tests/compiler/array/multi_fail_inline.leo
diff --git a/tests/compiler/array/multi_initializer.leo b/disabled_tests/compiler/array/multi_initializer.leo
similarity index 100%
rename from tests/compiler/array/multi_initializer.leo
rename to disabled_tests/compiler/array/multi_initializer.leo
diff --git a/tests/compiler/array/multi_initializer_fail.leo b/disabled_tests/compiler/array/multi_initializer_fail.leo
similarity index 100%
rename from tests/compiler/array/multi_initializer_fail.leo
rename to disabled_tests/compiler/array/multi_initializer_fail.leo
diff --git a/tests/compiler/array/nested.leo b/disabled_tests/compiler/array/nested.leo
similarity index 100%
rename from tests/compiler/array/nested.leo
rename to disabled_tests/compiler/array/nested.leo
diff --git a/tests/compiler/array/nested_3x2_value.leo b/disabled_tests/compiler/array/nested_3x2_value.leo
similarity index 100%
rename from tests/compiler/array/nested_3x2_value.leo
rename to disabled_tests/compiler/array/nested_3x2_value.leo
diff --git a/tests/compiler/array/nested_3x2_value_fail.leo b/disabled_tests/compiler/array/nested_3x2_value_fail.leo
similarity index 100%
rename from tests/compiler/array/nested_3x2_value_fail.leo
rename to disabled_tests/compiler/array/nested_3x2_value_fail.leo
diff --git a/tests/compiler/array/registers.leo b/disabled_tests/compiler/array/registers.leo
similarity index 100%
rename from tests/compiler/array/registers.leo
rename to disabled_tests/compiler/array/registers.leo
diff --git a/tests/compiler/array/slice.leo b/disabled_tests/compiler/array/slice.leo
similarity index 100%
rename from tests/compiler/array/slice.leo
rename to disabled_tests/compiler/array/slice.leo
diff --git a/tests/compiler/array/slice_lower.leo b/disabled_tests/compiler/array/slice_lower.leo
similarity index 100%
rename from tests/compiler/array/slice_lower.leo
rename to disabled_tests/compiler/array/slice_lower.leo
diff --git a/tests/compiler/array/spread.leo b/disabled_tests/compiler/array/spread.leo
similarity index 100%
rename from tests/compiler/array/spread.leo
rename to disabled_tests/compiler/array/spread.leo
diff --git a/tests/compiler/array/ternary_in_array.leo b/disabled_tests/compiler/array/ternary_in_array.leo
similarity index 100%
rename from tests/compiler/array/ternary_in_array.leo
rename to disabled_tests/compiler/array/ternary_in_array.leo
diff --git a/tests/compiler/array/tuple_3x2_value.leo b/disabled_tests/compiler/array/tuple_3x2_value.leo
similarity index 100%
rename from tests/compiler/array/tuple_3x2_value.leo
rename to disabled_tests/compiler/array/tuple_3x2_value.leo
diff --git a/tests/compiler/array/tuple_3x2_value_fail.leo b/disabled_tests/compiler/array/tuple_3x2_value_fail.leo
similarity index 100%
rename from tests/compiler/array/tuple_3x2_value_fail.leo
rename to disabled_tests/compiler/array/tuple_3x2_value_fail.leo
diff --git a/tests/compiler/array/type_fail.leo b/disabled_tests/compiler/array/type_fail.leo
similarity index 100%
rename from tests/compiler/array/type_fail.leo
rename to disabled_tests/compiler/array/type_fail.leo
diff --git a/tests/compiler/array/type_input_3x2.leo b/disabled_tests/compiler/array/type_input_3x2.leo
similarity index 100%
rename from tests/compiler/array/type_input_3x2.leo
rename to disabled_tests/compiler/array/type_input_3x2.leo
diff --git a/tests/compiler/array/type_input_4x3x2.leo b/disabled_tests/compiler/array/type_input_4x3x2.leo
similarity index 100%
rename from tests/compiler/array/type_input_4x3x2.leo
rename to disabled_tests/compiler/array/type_input_4x3x2.leo
diff --git a/tests/compiler/array/type_nested_value_nested_3x2.leo b/disabled_tests/compiler/array/type_nested_value_nested_3x2.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_nested_3x2.leo
rename to disabled_tests/compiler/array/type_nested_value_nested_3x2.leo
diff --git a/tests/compiler/array/type_nested_value_nested_3x2_fail.leo b/disabled_tests/compiler/array/type_nested_value_nested_3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_nested_3x2_fail.leo
rename to disabled_tests/compiler/array/type_nested_value_nested_3x2_fail.leo
diff --git a/tests/compiler/array/type_nested_value_nested_4x3x2.leo b/disabled_tests/compiler/array/type_nested_value_nested_4x3x2.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_nested_4x3x2.leo
rename to disabled_tests/compiler/array/type_nested_value_nested_4x3x2.leo
diff --git a/tests/compiler/array/type_nested_value_nested_4x3x2_fail.leo b/disabled_tests/compiler/array/type_nested_value_nested_4x3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_nested_4x3x2_fail.leo
rename to disabled_tests/compiler/array/type_nested_value_nested_4x3x2_fail.leo
diff --git a/tests/compiler/array/type_nested_value_tuple_3x2.leo b/disabled_tests/compiler/array/type_nested_value_tuple_3x2.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_tuple_3x2.leo
rename to disabled_tests/compiler/array/type_nested_value_tuple_3x2.leo
diff --git a/tests/compiler/array/type_nested_value_tuple_3x2_fail.leo b/disabled_tests/compiler/array/type_nested_value_tuple_3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_tuple_3x2_fail.leo
rename to disabled_tests/compiler/array/type_nested_value_tuple_3x2_fail.leo
diff --git a/tests/compiler/array/type_nested_value_tuple_4x3x2.leo b/disabled_tests/compiler/array/type_nested_value_tuple_4x3x2.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_tuple_4x3x2.leo
rename to disabled_tests/compiler/array/type_nested_value_tuple_4x3x2.leo
diff --git a/tests/compiler/array/type_nested_value_tuple_4x3x2_fail.leo b/disabled_tests/compiler/array/type_nested_value_tuple_4x3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_nested_value_tuple_4x3x2_fail.leo
rename to disabled_tests/compiler/array/type_nested_value_tuple_4x3x2_fail.leo
diff --git a/tests/compiler/array/type_tuple_value_nested_3x2.leo b/disabled_tests/compiler/array/type_tuple_value_nested_3x2.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_nested_3x2.leo
rename to disabled_tests/compiler/array/type_tuple_value_nested_3x2.leo
diff --git a/tests/compiler/array/type_tuple_value_nested_3x2_fail.leo b/disabled_tests/compiler/array/type_tuple_value_nested_3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_nested_3x2_fail.leo
rename to disabled_tests/compiler/array/type_tuple_value_nested_3x2_fail.leo
diff --git a/tests/compiler/array/type_tuple_value_nested_4x3x2.leo b/disabled_tests/compiler/array/type_tuple_value_nested_4x3x2.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_nested_4x3x2.leo
rename to disabled_tests/compiler/array/type_tuple_value_nested_4x3x2.leo
diff --git a/tests/compiler/array/type_tuple_value_nested_4x3x2_fail.leo b/disabled_tests/compiler/array/type_tuple_value_nested_4x3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_nested_4x3x2_fail.leo
rename to disabled_tests/compiler/array/type_tuple_value_nested_4x3x2_fail.leo
diff --git a/tests/compiler/array/type_tuple_value_tuple_3x2.leo b/disabled_tests/compiler/array/type_tuple_value_tuple_3x2.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_tuple_3x2.leo
rename to disabled_tests/compiler/array/type_tuple_value_tuple_3x2.leo
diff --git a/tests/compiler/array/type_tuple_value_tuple_3x2_fail.leo b/disabled_tests/compiler/array/type_tuple_value_tuple_3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_tuple_3x2_fail.leo
rename to disabled_tests/compiler/array/type_tuple_value_tuple_3x2_fail.leo
diff --git a/tests/compiler/array/type_tuple_value_tuple_4x3x2.leo b/disabled_tests/compiler/array/type_tuple_value_tuple_4x3x2.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_tuple_4x3x2.leo
rename to disabled_tests/compiler/array/type_tuple_value_tuple_4x3x2.leo
diff --git a/tests/compiler/array/type_tuple_value_tuple_4x3x2_fail.leo b/disabled_tests/compiler/array/type_tuple_value_tuple_4x3x2_fail.leo
similarity index 100%
rename from tests/compiler/array/type_tuple_value_tuple_4x3x2_fail.leo
rename to disabled_tests/compiler/array/type_tuple_value_tuple_4x3x2_fail.leo
diff --git a/tests/compiler/array/variable_slice_fail.leo b/disabled_tests/compiler/array/variable_slice_fail.leo
similarity index 100%
rename from tests/compiler/array/variable_slice_fail.leo
rename to disabled_tests/compiler/array/variable_slice_fail.leo
diff --git a/tests/compiler/char/circuit.leo b/disabled_tests/compiler/char/circuit.leo
similarity index 100%
rename from tests/compiler/char/circuit.leo
rename to disabled_tests/compiler/char/circuit.leo
diff --git a/tests/compiler/char/inputs/ascii.in b/disabled_tests/compiler/char/inputs/ascii.in
similarity index 100%
rename from tests/compiler/char/inputs/ascii.in
rename to disabled_tests/compiler/char/inputs/ascii.in
diff --git a/tests/compiler/char/inputs/escaped.in b/disabled_tests/compiler/char/inputs/escaped.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped.in
rename to disabled_tests/compiler/char/inputs/escaped.in
diff --git a/tests/compiler/char/inputs/escaped_unicode1.in b/disabled_tests/compiler/char/inputs/escaped_unicode1.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped_unicode1.in
rename to disabled_tests/compiler/char/inputs/escaped_unicode1.in
diff --git a/tests/compiler/char/inputs/escaped_unicode2.in b/disabled_tests/compiler/char/inputs/escaped_unicode2.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped_unicode2.in
rename to disabled_tests/compiler/char/inputs/escaped_unicode2.in
diff --git a/tests/compiler/char/inputs/escaped_unicode3.in b/disabled_tests/compiler/char/inputs/escaped_unicode3.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped_unicode3.in
rename to disabled_tests/compiler/char/inputs/escaped_unicode3.in
diff --git a/tests/compiler/char/inputs/escaped_unicode4.in b/disabled_tests/compiler/char/inputs/escaped_unicode4.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped_unicode4.in
rename to disabled_tests/compiler/char/inputs/escaped_unicode4.in
diff --git a/tests/compiler/char/inputs/escaped_unicode5.in b/disabled_tests/compiler/char/inputs/escaped_unicode5.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped_unicode5.in
rename to disabled_tests/compiler/char/inputs/escaped_unicode5.in
diff --git a/tests/compiler/char/inputs/escaped_unicode6.in b/disabled_tests/compiler/char/inputs/escaped_unicode6.in
similarity index 100%
rename from tests/compiler/char/inputs/escaped_unicode6.in
rename to disabled_tests/compiler/char/inputs/escaped_unicode6.in
diff --git a/tests/compiler/char/inputs/hex1.in b/disabled_tests/compiler/char/inputs/hex1.in
similarity index 100%
rename from tests/compiler/char/inputs/hex1.in
rename to disabled_tests/compiler/char/inputs/hex1.in
diff --git a/tests/compiler/char/inputs/hex2.in b/disabled_tests/compiler/char/inputs/hex2.in
similarity index 100%
rename from tests/compiler/char/inputs/hex2.in
rename to disabled_tests/compiler/char/inputs/hex2.in
diff --git a/tests/compiler/char/inputs/nonprinting.in b/disabled_tests/compiler/char/inputs/nonprinting.in
similarity index 100%
rename from tests/compiler/char/inputs/nonprinting.in
rename to disabled_tests/compiler/char/inputs/nonprinting.in
diff --git a/tests/compiler/char/inputs/unicode1.in b/disabled_tests/compiler/char/inputs/unicode1.in
similarity index 100%
rename from tests/compiler/char/inputs/unicode1.in
rename to disabled_tests/compiler/char/inputs/unicode1.in
diff --git a/tests/compiler/char/inputs/unicode2.in b/disabled_tests/compiler/char/inputs/unicode2.in
similarity index 100%
rename from tests/compiler/char/inputs/unicode2.in
rename to disabled_tests/compiler/char/inputs/unicode2.in
diff --git a/tests/compiler/char/inputs/unicode3.in b/disabled_tests/compiler/char/inputs/unicode3.in
similarity index 100%
rename from tests/compiler/char/inputs/unicode3.in
rename to disabled_tests/compiler/char/inputs/unicode3.in
diff --git a/tests/compiler/char/inputs/unicode4.in b/disabled_tests/compiler/char/inputs/unicode4.in
similarity index 100%
rename from tests/compiler/char/inputs/unicode4.in
rename to disabled_tests/compiler/char/inputs/unicode4.in
diff --git a/tests/compiler/char/inputs/unicode5.in b/disabled_tests/compiler/char/inputs/unicode5.in
similarity index 100%
rename from tests/compiler/char/inputs/unicode5.in
rename to disabled_tests/compiler/char/inputs/unicode5.in
diff --git a/tests/compiler/char/invalid_char.leo b/disabled_tests/compiler/char/invalid_char.leo
similarity index 100%
rename from tests/compiler/char/invalid_char.leo
rename to disabled_tests/compiler/char/invalid_char.leo
diff --git a/tests/compiler/char/neq.leo b/disabled_tests/compiler/char/neq.leo
similarity index 100%
rename from tests/compiler/char/neq.leo
rename to disabled_tests/compiler/char/neq.leo
diff --git a/tests/compiler/char/nonprinting.leo b/disabled_tests/compiler/char/nonprinting.leo
similarity index 100%
rename from tests/compiler/char/nonprinting.leo
rename to disabled_tests/compiler/char/nonprinting.leo
diff --git a/tests/compiler/char/out.leo b/disabled_tests/compiler/char/out.leo
similarity index 100%
rename from tests/compiler/char/out.leo
rename to disabled_tests/compiler/char/out.leo
diff --git a/tests/compiler/char/output/output_char.out b/disabled_tests/compiler/char/output/output_char.out
similarity index 100%
rename from tests/compiler/char/output/output_char.out
rename to disabled_tests/compiler/char/output/output_char.out
diff --git a/tests/compiler/circuits/big_self_in_circuit_replacement.leo b/disabled_tests/compiler/circuits/big_self_in_circuit_replacement.leo
similarity index 100%
rename from tests/compiler/circuits/big_self_in_circuit_replacement.leo
rename to disabled_tests/compiler/circuits/big_self_in_circuit_replacement.leo
diff --git a/tests/compiler/circuits/big_self_outside_circuit_fail.leo b/disabled_tests/compiler/circuits/big_self_outside_circuit_fail.leo
similarity index 100%
rename from tests/compiler/circuits/big_self_outside_circuit_fail.leo
rename to disabled_tests/compiler/circuits/big_self_outside_circuit_fail.leo
diff --git a/tests/compiler/circuits/circuit_alias_namespace_conflict_fail.leo b/disabled_tests/compiler/circuits/circuit_alias_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/circuits/circuit_alias_namespace_conflict_fail.leo
rename to disabled_tests/compiler/circuits/circuit_alias_namespace_conflict_fail.leo
diff --git a/tests/compiler/circuits/circuit_function_namespace_conflict_fail.leo b/disabled_tests/compiler/circuits/circuit_function_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/circuits/circuit_function_namespace_conflict_fail.leo
rename to disabled_tests/compiler/circuits/circuit_function_namespace_conflict_fail.leo
diff --git a/tests/compiler/circuits/circuit_global_const_namespace_conflict_fail copy.leo b/disabled_tests/compiler/circuits/circuit_global_const_namespace_conflict_fail copy.leo
similarity index 100%
rename from tests/compiler/circuits/circuit_global_const_namespace_conflict_fail copy.leo
rename to disabled_tests/compiler/circuits/circuit_global_const_namespace_conflict_fail copy.leo
diff --git a/tests/compiler/circuits/const_self_variable.leo b/disabled_tests/compiler/circuits/const_self_variable.leo
similarity index 100%
rename from tests/compiler/circuits/const_self_variable.leo
rename to disabled_tests/compiler/circuits/const_self_variable.leo
diff --git a/tests/compiler/circuits/const_self_variable_fail.leo b/disabled_tests/compiler/circuits/const_self_variable_fail.leo
similarity index 100%
rename from tests/compiler/circuits/const_self_variable_fail.leo
rename to disabled_tests/compiler/circuits/const_self_variable_fail.leo
diff --git a/tests/compiler/circuits/define_circuit_inside_circuit_function.leo b/disabled_tests/compiler/circuits/define_circuit_inside_circuit_function.leo
similarity index 100%
rename from tests/compiler/circuits/define_circuit_inside_circuit_function.leo
rename to disabled_tests/compiler/circuits/define_circuit_inside_circuit_function.leo
diff --git a/tests/compiler/circuits/duplicate_name_context.leo b/disabled_tests/compiler/circuits/duplicate_name_context.leo
similarity index 100%
rename from tests/compiler/circuits/duplicate_name_context.leo
rename to disabled_tests/compiler/circuits/duplicate_name_context.leo
diff --git a/tests/compiler/circuits/inline.leo b/disabled_tests/compiler/circuits/inline.leo
similarity index 100%
rename from tests/compiler/circuits/inline.leo
rename to disabled_tests/compiler/circuits/inline.leo
diff --git a/tests/compiler/circuits/inline_fail.leo b/disabled_tests/compiler/circuits/inline_fail.leo
similarity index 100%
rename from tests/compiler/circuits/inline_fail.leo
rename to disabled_tests/compiler/circuits/inline_fail.leo
diff --git a/tests/compiler/circuits/inline_member_fail.leo b/disabled_tests/compiler/circuits/inline_member_fail.leo
similarity index 100%
rename from tests/compiler/circuits/inline_member_fail.leo
rename to disabled_tests/compiler/circuits/inline_member_fail.leo
diff --git a/tests/compiler/circuits/inline_member_pass.leo b/disabled_tests/compiler/circuits/inline_member_pass.leo
similarity index 100%
rename from tests/compiler/circuits/inline_member_pass.leo
rename to disabled_tests/compiler/circuits/inline_member_pass.leo
diff --git a/tests/compiler/circuits/inline_undefined.leo b/disabled_tests/compiler/circuits/inline_undefined.leo
similarity index 100%
rename from tests/compiler/circuits/inline_undefined.leo
rename to disabled_tests/compiler/circuits/inline_undefined.leo
diff --git a/tests/compiler/circuits/input/dummy.in b/disabled_tests/compiler/circuits/input/dummy.in
similarity index 100%
rename from tests/compiler/circuits/input/dummy.in
rename to disabled_tests/compiler/circuits/input/dummy.in
diff --git a/tests/compiler/circuits/member_function.leo b/disabled_tests/compiler/circuits/member_function.leo
similarity index 100%
rename from tests/compiler/circuits/member_function.leo
rename to disabled_tests/compiler/circuits/member_function.leo
diff --git a/tests/compiler/circuits/member_function_fail.leo b/disabled_tests/compiler/circuits/member_function_fail.leo
similarity index 100%
rename from tests/compiler/circuits/member_function_fail.leo
rename to disabled_tests/compiler/circuits/member_function_fail.leo
diff --git a/tests/compiler/circuits/member_function_invalid.leo b/disabled_tests/compiler/circuits/member_function_invalid.leo
similarity index 100%
rename from tests/compiler/circuits/member_function_invalid.leo
rename to disabled_tests/compiler/circuits/member_function_invalid.leo
diff --git a/tests/compiler/circuits/member_function_nested.leo b/disabled_tests/compiler/circuits/member_function_nested.leo
similarity index 100%
rename from tests/compiler/circuits/member_function_nested.leo
rename to disabled_tests/compiler/circuits/member_function_nested.leo
diff --git a/tests/compiler/circuits/member_static_function.leo b/disabled_tests/compiler/circuits/member_static_function.leo
similarity index 100%
rename from tests/compiler/circuits/member_static_function.leo
rename to disabled_tests/compiler/circuits/member_static_function.leo
diff --git a/tests/compiler/circuits/member_static_function_invalid.leo b/disabled_tests/compiler/circuits/member_static_function_invalid.leo
similarity index 100%
rename from tests/compiler/circuits/member_static_function_invalid.leo
rename to disabled_tests/compiler/circuits/member_static_function_invalid.leo
diff --git a/tests/compiler/circuits/member_static_function_nested.leo b/disabled_tests/compiler/circuits/member_static_function_nested.leo
similarity index 100%
rename from tests/compiler/circuits/member_static_function_nested.leo
rename to disabled_tests/compiler/circuits/member_static_function_nested.leo
diff --git a/tests/compiler/circuits/member_static_function_undefined.leo b/disabled_tests/compiler/circuits/member_static_function_undefined.leo
similarity index 100%
rename from tests/compiler/circuits/member_static_function_undefined.leo
rename to disabled_tests/compiler/circuits/member_static_function_undefined.leo
diff --git a/tests/compiler/circuits/member_variable.leo b/disabled_tests/compiler/circuits/member_variable.leo
similarity index 100%
rename from tests/compiler/circuits/member_variable.leo
rename to disabled_tests/compiler/circuits/member_variable.leo
diff --git a/tests/compiler/circuits/member_variable_and_function.leo b/disabled_tests/compiler/circuits/member_variable_and_function.leo
similarity index 100%
rename from tests/compiler/circuits/member_variable_and_function.leo
rename to disabled_tests/compiler/circuits/member_variable_and_function.leo
diff --git a/tests/compiler/circuits/member_variable_fail.leo b/disabled_tests/compiler/circuits/member_variable_fail.leo
similarity index 100%
rename from tests/compiler/circuits/member_variable_fail.leo
rename to disabled_tests/compiler/circuits/member_variable_fail.leo
diff --git a/tests/compiler/circuits/mut_function_fail.leo b/disabled_tests/compiler/circuits/mut_function_fail.leo
similarity index 100%
rename from tests/compiler/circuits/mut_function_fail.leo
rename to disabled_tests/compiler/circuits/mut_function_fail.leo
diff --git a/tests/compiler/circuits/mut_self_function_fail.leo b/disabled_tests/compiler/circuits/mut_self_function_fail.leo
similarity index 100%
rename from tests/compiler/circuits/mut_self_function_fail.leo
rename to disabled_tests/compiler/circuits/mut_self_function_fail.leo
diff --git a/tests/compiler/circuits/mut_self_static_function_fail.leo b/disabled_tests/compiler/circuits/mut_self_static_function_fail.leo
similarity index 100%
rename from tests/compiler/circuits/mut_self_static_function_fail.leo
rename to disabled_tests/compiler/circuits/mut_self_static_function_fail.leo
diff --git a/tests/compiler/circuits/mut_self_variable.leo b/disabled_tests/compiler/circuits/mut_self_variable.leo
similarity index 100%
rename from tests/compiler/circuits/mut_self_variable.leo
rename to disabled_tests/compiler/circuits/mut_self_variable.leo
diff --git a/tests/compiler/circuits/mut_self_variable_branch.leo b/disabled_tests/compiler/circuits/mut_self_variable_branch.leo
similarity index 100%
rename from tests/compiler/circuits/mut_self_variable_branch.leo
rename to disabled_tests/compiler/circuits/mut_self_variable_branch.leo
diff --git a/tests/compiler/circuits/mut_self_variable_conditional.leo b/disabled_tests/compiler/circuits/mut_self_variable_conditional.leo
similarity index 100%
rename from tests/compiler/circuits/mut_self_variable_conditional.leo
rename to disabled_tests/compiler/circuits/mut_self_variable_conditional.leo
diff --git a/tests/compiler/circuits/mut_self_variable_fail.leo b/disabled_tests/compiler/circuits/mut_self_variable_fail.leo
similarity index 100%
rename from tests/compiler/circuits/mut_self_variable_fail.leo
rename to disabled_tests/compiler/circuits/mut_self_variable_fail.leo
diff --git a/tests/compiler/circuits/mut_static_function_fail.leo b/disabled_tests/compiler/circuits/mut_static_function_fail.leo
similarity index 100%
rename from tests/compiler/circuits/mut_static_function_fail.leo
rename to disabled_tests/compiler/circuits/mut_static_function_fail.leo
diff --git a/tests/compiler/circuits/mut_variable.leo b/disabled_tests/compiler/circuits/mut_variable.leo
similarity index 100%
rename from tests/compiler/circuits/mut_variable.leo
rename to disabled_tests/compiler/circuits/mut_variable.leo
diff --git a/tests/compiler/circuits/mut_variable_fail.leo b/disabled_tests/compiler/circuits/mut_variable_fail.leo
similarity index 100%
rename from tests/compiler/circuits/mut_variable_fail.leo
rename to disabled_tests/compiler/circuits/mut_variable_fail.leo
diff --git a/tests/compiler/circuits/mutable_call_immutable_context.leo b/disabled_tests/compiler/circuits/mutable_call_immutable_context.leo
similarity index 100%
rename from tests/compiler/circuits/mutable_call_immutable_context.leo
rename to disabled_tests/compiler/circuits/mutable_call_immutable_context.leo
diff --git a/tests/compiler/circuits/pedersen_mock.leo b/disabled_tests/compiler/circuits/pedersen_mock.leo
similarity index 100%
rename from tests/compiler/circuits/pedersen_mock.leo
rename to disabled_tests/compiler/circuits/pedersen_mock.leo
diff --git a/tests/compiler/circuits/return_self_type_array.leo b/disabled_tests/compiler/circuits/return_self_type_array.leo
similarity index 100%
rename from tests/compiler/circuits/return_self_type_array.leo
rename to disabled_tests/compiler/circuits/return_self_type_array.leo
diff --git a/tests/compiler/circuits/return_self_type_tuple.leo b/disabled_tests/compiler/circuits/return_self_type_tuple.leo
similarity index 100%
rename from tests/compiler/circuits/return_self_type_tuple.leo
rename to disabled_tests/compiler/circuits/return_self_type_tuple.leo
diff --git a/tests/compiler/circuits/self_circuit.leo b/disabled_tests/compiler/circuits/self_circuit.leo
similarity index 100%
rename from tests/compiler/circuits/self_circuit.leo
rename to disabled_tests/compiler/circuits/self_circuit.leo
diff --git a/tests/compiler/circuits/self_fail.leo b/disabled_tests/compiler/circuits/self_fail.leo
similarity index 100%
rename from tests/compiler/circuits/self_fail.leo
rename to disabled_tests/compiler/circuits/self_fail.leo
diff --git a/tests/compiler/circuits/self_member.leo b/disabled_tests/compiler/circuits/self_member.leo
similarity index 100%
rename from tests/compiler/circuits/self_member.leo
rename to disabled_tests/compiler/circuits/self_member.leo
diff --git a/tests/compiler/circuits/self_member_invalid.leo b/disabled_tests/compiler/circuits/self_member_invalid.leo
similarity index 100%
rename from tests/compiler/circuits/self_member_invalid.leo
rename to disabled_tests/compiler/circuits/self_member_invalid.leo
diff --git a/tests/compiler/circuits/self_member_undefined.leo b/disabled_tests/compiler/circuits/self_member_undefined.leo
similarity index 100%
rename from tests/compiler/circuits/self_member_undefined.leo
rename to disabled_tests/compiler/circuits/self_member_undefined.leo
diff --git a/tests/compiler/console/assert.leo b/disabled_tests/compiler/console/assert.leo
similarity index 100%
rename from tests/compiler/console/assert.leo
rename to disabled_tests/compiler/console/assert.leo
diff --git a/tests/compiler/console/conditional_assert.leo b/disabled_tests/compiler/console/conditional_assert.leo
similarity index 100%
rename from tests/compiler/console/conditional_assert.leo
rename to disabled_tests/compiler/console/conditional_assert.leo
diff --git a/tests/compiler/console/error.leo b/disabled_tests/compiler/console/error.leo
similarity index 100%
rename from tests/compiler/console/error.leo
rename to disabled_tests/compiler/console/error.leo
diff --git a/tests/compiler/console/input/dummy.in b/disabled_tests/compiler/console/input/dummy.in
similarity index 100%
rename from tests/compiler/console/input/dummy.in
rename to disabled_tests/compiler/console/input/dummy.in
diff --git a/tests/compiler/console/input/input_equal.in b/disabled_tests/compiler/console/input/input_equal.in
similarity index 100%
rename from tests/compiler/console/input/input_equal.in
rename to disabled_tests/compiler/console/input/input_equal.in
diff --git a/tests/compiler/console/input/input_unequal.in b/disabled_tests/compiler/console/input/input_unequal.in
similarity index 100%
rename from tests/compiler/console/input/input_unequal.in
rename to disabled_tests/compiler/console/input/input_unequal.in
diff --git a/tests/compiler/console/log.leo b/disabled_tests/compiler/console/log.leo
similarity index 100%
rename from tests/compiler/console/log.leo
rename to disabled_tests/compiler/console/log.leo
diff --git a/tests/compiler/console/log_conditional.leo b/disabled_tests/compiler/console/log_conditional.leo
similarity index 100%
rename from tests/compiler/console/log_conditional.leo
rename to disabled_tests/compiler/console/log_conditional.leo
diff --git a/tests/compiler/console/log_fail.leo b/disabled_tests/compiler/console/log_fail.leo
similarity index 100%
rename from tests/compiler/console/log_fail.leo
rename to disabled_tests/compiler/console/log_fail.leo
diff --git a/tests/compiler/console/log_input.leo b/disabled_tests/compiler/console/log_input.leo
similarity index 100%
rename from tests/compiler/console/log_input.leo
rename to disabled_tests/compiler/console/log_input.leo
diff --git a/tests/compiler/console/log_parameter.leo b/disabled_tests/compiler/console/log_parameter.leo
similarity index 100%
rename from tests/compiler/console/log_parameter.leo
rename to disabled_tests/compiler/console/log_parameter.leo
diff --git a/tests/compiler/console/log_parameter_fail_empty.leo b/disabled_tests/compiler/console/log_parameter_fail_empty.leo
similarity index 100%
rename from tests/compiler/console/log_parameter_fail_empty.leo
rename to disabled_tests/compiler/console/log_parameter_fail_empty.leo
diff --git a/tests/compiler/console/log_parameter_fail_none.leo b/disabled_tests/compiler/console/log_parameter_fail_none.leo
similarity index 100%
rename from tests/compiler/console/log_parameter_fail_none.leo
rename to disabled_tests/compiler/console/log_parameter_fail_none.leo
diff --git a/tests/compiler/console/log_parameter_fail_unknown.leo b/disabled_tests/compiler/console/log_parameter_fail_unknown.leo
similarity index 100%
rename from tests/compiler/console/log_parameter_fail_unknown.leo
rename to disabled_tests/compiler/console/log_parameter_fail_unknown.leo
diff --git a/tests/compiler/console/log_parameter_many.leo b/disabled_tests/compiler/console/log_parameter_many.leo
similarity index 100%
rename from tests/compiler/console/log_parameter_many.leo
rename to disabled_tests/compiler/console/log_parameter_many.leo
diff --git a/tests/compiler/function/array_input.leo b/disabled_tests/compiler/function/array_input.leo
similarity index 100%
rename from tests/compiler/function/array_input.leo
rename to disabled_tests/compiler/function/array_input.leo
diff --git a/tests/compiler/function/array_params_direct_call.leo b/disabled_tests/compiler/function/array_params_direct_call.leo
similarity index 100%
rename from tests/compiler/function/array_params_direct_call.leo
rename to disabled_tests/compiler/function/array_params_direct_call.leo
diff --git a/tests/compiler/function/duplicate_parameter_fail.leo b/disabled_tests/compiler/function/duplicate_parameter_fail.leo
similarity index 100%
rename from tests/compiler/function/duplicate_parameter_fail.leo
rename to disabled_tests/compiler/function/duplicate_parameter_fail.leo
diff --git a/tests/compiler/function/function_alias_namespace_conflict_fail.leo b/disabled_tests/compiler/function/function_alias_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/function/function_alias_namespace_conflict_fail.leo
rename to disabled_tests/compiler/function/function_alias_namespace_conflict_fail.leo
diff --git a/tests/compiler/function/function_circuit_namespace_conflict_fail.leo b/disabled_tests/compiler/function/function_circuit_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/function/function_circuit_namespace_conflict_fail.leo
rename to disabled_tests/compiler/function/function_circuit_namespace_conflict_fail.leo
diff --git a/tests/compiler/function/function_global_const_namespace_conflict_fail copy.leo b/disabled_tests/compiler/function/function_global_const_namespace_conflict_fail copy.leo
similarity index 100%
rename from tests/compiler/function/function_global_const_namespace_conflict_fail copy.leo
rename to disabled_tests/compiler/function/function_global_const_namespace_conflict_fail copy.leo
diff --git a/tests/compiler/function/multiple_returns.leo b/disabled_tests/compiler/function/multiple_returns.leo
similarity index 100%
rename from tests/compiler/function/multiple_returns.leo
rename to disabled_tests/compiler/function/multiple_returns.leo
diff --git a/tests/compiler/function/multiple_returns_fail.leo b/disabled_tests/compiler/function/multiple_returns_fail.leo
similarity index 100%
rename from tests/compiler/function/multiple_returns_fail.leo
rename to disabled_tests/compiler/function/multiple_returns_fail.leo
diff --git a/tests/compiler/function/multiple_returns_fail_conditional.leo b/disabled_tests/compiler/function/multiple_returns_fail_conditional.leo
similarity index 100%
rename from tests/compiler/function/multiple_returns_fail_conditional.leo
rename to disabled_tests/compiler/function/multiple_returns_fail_conditional.leo
diff --git a/tests/compiler/function/multiple_returns_main.leo b/disabled_tests/compiler/function/multiple_returns_main.leo
similarity index 100%
rename from tests/compiler/function/multiple_returns_main.leo
rename to disabled_tests/compiler/function/multiple_returns_main.leo
diff --git a/tests/compiler/function/newlines.leo b/disabled_tests/compiler/function/newlines.leo
similarity index 100%
rename from tests/compiler/function/newlines.leo
rename to disabled_tests/compiler/function/newlines.leo
diff --git a/tests/compiler/function/return_array_nested_fail.leo b/disabled_tests/compiler/function/return_array_nested_fail.leo
similarity index 100%
rename from tests/compiler/function/return_array_nested_fail.leo
rename to disabled_tests/compiler/function/return_array_nested_fail.leo
diff --git a/tests/compiler/function/return_array_nested_pass.leo b/disabled_tests/compiler/function/return_array_nested_pass.leo
similarity index 100%
rename from tests/compiler/function/return_array_nested_pass.leo
rename to disabled_tests/compiler/function/return_array_nested_pass.leo
diff --git a/tests/compiler/function/return_array_tuple_fail.leo b/disabled_tests/compiler/function/return_array_tuple_fail.leo
similarity index 100%
rename from tests/compiler/function/return_array_tuple_fail.leo
rename to disabled_tests/compiler/function/return_array_tuple_fail.leo
diff --git a/tests/compiler/function/return_array_tuple_pass.leo b/disabled_tests/compiler/function/return_array_tuple_pass.leo
similarity index 100%
rename from tests/compiler/function/return_array_tuple_pass.leo
rename to disabled_tests/compiler/function/return_array_tuple_pass.leo
diff --git a/tests/compiler/function/return_tuple.leo b/disabled_tests/compiler/function/return_tuple.leo
similarity index 100%
rename from tests/compiler/function/return_tuple.leo
rename to disabled_tests/compiler/function/return_tuple.leo
diff --git a/tests/compiler/function/return_tuple_conditional.leo b/disabled_tests/compiler/function/return_tuple_conditional.leo
similarity index 100%
rename from tests/compiler/function/return_tuple_conditional.leo
rename to disabled_tests/compiler/function/return_tuple_conditional.leo
diff --git a/tests/compiler/function/scope_fail.leo b/disabled_tests/compiler/function/scope_fail.leo
similarity index 100%
rename from tests/compiler/function/scope_fail.leo
rename to disabled_tests/compiler/function/scope_fail.leo
diff --git a/tests/compiler/function/shadow_global_const_input_fail copy.leo b/disabled_tests/compiler/function/shadow_global_const_input_fail copy.leo
similarity index 100%
rename from tests/compiler/function/shadow_global_const_input_fail copy.leo
rename to disabled_tests/compiler/function/shadow_global_const_input_fail copy.leo
diff --git a/tests/compiler/function/shadow_global_const_var_fail.leo b/disabled_tests/compiler/function/shadow_global_const_var_fail.leo
similarity index 100%
rename from tests/compiler/function/shadow_global_const_var_fail.leo
rename to disabled_tests/compiler/function/shadow_global_const_var_fail.leo
diff --git a/tests/compiler/function/shadow_parameter_fail.leo b/disabled_tests/compiler/function/shadow_parameter_fail.leo
similarity index 100%
rename from tests/compiler/function/shadow_parameter_fail.leo
rename to disabled_tests/compiler/function/shadow_parameter_fail.leo
diff --git a/tests/compiler/function/undefined.leo b/disabled_tests/compiler/function/undefined.leo
similarity index 100%
rename from tests/compiler/function/undefined.leo
rename to disabled_tests/compiler/function/undefined.leo
diff --git a/tests/compiler/function/value_unchanged.leo b/disabled_tests/compiler/function/value_unchanged.leo
similarity index 100%
rename from tests/compiler/function/value_unchanged.leo
rename to disabled_tests/compiler/function/value_unchanged.leo
diff --git a/tests/compiler/global_consts/global_const_alias_namespace_conflict_fail.leo b/disabled_tests/compiler/global_consts/global_const_alias_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/global_consts/global_const_alias_namespace_conflict_fail.leo
rename to disabled_tests/compiler/global_consts/global_const_alias_namespace_conflict_fail.leo
diff --git a/tests/compiler/global_consts/global_const_circuit_namespace_conflict_fail copy.leo b/disabled_tests/compiler/global_consts/global_const_circuit_namespace_conflict_fail copy.leo
similarity index 100%
rename from tests/compiler/global_consts/global_const_circuit_namespace_conflict_fail copy.leo
rename to disabled_tests/compiler/global_consts/global_const_circuit_namespace_conflict_fail copy.leo
diff --git a/tests/compiler/global_consts/global_const_function_namespace_conflict_fail.leo b/disabled_tests/compiler/global_consts/global_const_function_namespace_conflict_fail.leo
similarity index 100%
rename from tests/compiler/global_consts/global_const_function_namespace_conflict_fail.leo
rename to disabled_tests/compiler/global_consts/global_const_function_namespace_conflict_fail.leo
diff --git a/tests/compiler/global_consts/global_const_types.leo b/disabled_tests/compiler/global_consts/global_const_types.leo
similarity index 100%
rename from tests/compiler/global_consts/global_const_types.leo
rename to disabled_tests/compiler/global_consts/global_const_types.leo
diff --git a/tests/compiler/global_consts/inputs/dummy.in b/disabled_tests/compiler/global_consts/inputs/dummy.in
similarity index 100%
rename from tests/compiler/global_consts/inputs/dummy.in
rename to disabled_tests/compiler/global_consts/inputs/dummy.in
diff --git a/tests/compiler/global_consts/modify_global_const.leo b/disabled_tests/compiler/global_consts/modify_global_const.leo
similarity index 100%
rename from tests/compiler/global_consts/modify_global_const.leo
rename to disabled_tests/compiler/global_consts/modify_global_const.leo
diff --git a/tests/compiler/import_dependency/imports/dependency/inputs/dependency.in b/disabled_tests/compiler/import_dependency/imports/dependency/inputs/dependency.in
similarity index 100%
rename from tests/compiler/import_dependency/imports/dependency/inputs/dependency.in
rename to disabled_tests/compiler/import_dependency/imports/dependency/inputs/dependency.in
diff --git a/tests/compiler/import_dependency/imports/dependency/src/main.leo b/disabled_tests/compiler/import_dependency/imports/dependency/src/main.leo
similarity index 100%
rename from tests/compiler/import_dependency/imports/dependency/src/main.leo
rename to disabled_tests/compiler/import_dependency/imports/dependency/src/main.leo
diff --git a/tests/compiler/import_dependency/input/dummy.in b/disabled_tests/compiler/import_dependency/input/dummy.in
similarity index 100%
rename from tests/compiler/import_dependency/input/dummy.in
rename to disabled_tests/compiler/import_dependency/input/dummy.in
diff --git a/tests/compiler/import_dependency/readme.md b/disabled_tests/compiler/import_dependency/readme.md
similarity index 100%
rename from tests/compiler/import_dependency/readme.md
rename to disabled_tests/compiler/import_dependency/readme.md
diff --git a/tests/compiler/import_dependency/tests/import_dependency_folder.leo b/disabled_tests/compiler/import_dependency/tests/import_dependency_folder.leo
similarity index 100%
rename from tests/compiler/import_dependency/tests/import_dependency_folder.leo
rename to disabled_tests/compiler/import_dependency/tests/import_dependency_folder.leo
diff --git a/tests/compiler/import_local/import_all.leo b/disabled_tests/compiler/import_local/import_all.leo
similarity index 100%
rename from tests/compiler/import_local/import_all.leo
rename to disabled_tests/compiler/import_local/import_all.leo
diff --git a/tests/compiler/import_local/import_as.leo b/disabled_tests/compiler/import_local/import_as.leo
similarity index 100%
rename from tests/compiler/import_local/import_as.leo
rename to disabled_tests/compiler/import_local/import_as.leo
diff --git a/tests/compiler/import_local/import_dir.leo b/disabled_tests/compiler/import_local/import_dir.leo
similarity index 100%
rename from tests/compiler/import_local/import_dir.leo
rename to disabled_tests/compiler/import_local/import_dir.leo
diff --git a/tests/compiler/import_local/import_files.leo b/disabled_tests/compiler/import_local/import_files.leo
similarity index 100%
rename from tests/compiler/import_local/import_files.leo
rename to disabled_tests/compiler/import_local/import_files.leo
diff --git a/tests/compiler/import_local/import_many.leo b/disabled_tests/compiler/import_local/import_many.leo
similarity index 100%
rename from tests/compiler/import_local/import_many.leo
rename to disabled_tests/compiler/import_local/import_many.leo
diff --git a/tests/compiler/import_local/import_weird_names.leo b/disabled_tests/compiler/import_local/import_weird_names.leo
similarity index 100%
rename from tests/compiler/import_local/import_weird_names.leo
rename to disabled_tests/compiler/import_local/import_weird_names.leo
diff --git a/tests/compiler/import_local/import_weird_names_nested.leo b/disabled_tests/compiler/import_local/import_weird_names_nested.leo
similarity index 100%
rename from tests/compiler/import_local/import_weird_names_nested.leo
rename to disabled_tests/compiler/import_local/import_weird_names_nested.leo
diff --git a/tests/compiler/import_local/input/dummy.in b/disabled_tests/compiler/import_local/input/dummy.in
similarity index 100%
rename from tests/compiler/import_local/input/dummy.in
rename to disabled_tests/compiler/import_local/input/dummy.in
diff --git a/tests/compiler/import_local/local_imports/a-9.leo b/disabled_tests/compiler/import_local/local_imports/a-9.leo
similarity index 100%
rename from tests/compiler/import_local/local_imports/a-9.leo
rename to disabled_tests/compiler/import_local/local_imports/a-9.leo
diff --git a/tests/compiler/import_local/local_imports/circuits.leo b/disabled_tests/compiler/import_local/local_imports/circuits.leo
similarity index 100%
rename from tests/compiler/import_local/local_imports/circuits.leo
rename to disabled_tests/compiler/import_local/local_imports/circuits.leo
diff --git a/tests/compiler/import_local/local_imports/lib.leo b/disabled_tests/compiler/import_local/local_imports/lib.leo
similarity index 100%
rename from tests/compiler/import_local/local_imports/lib.leo
rename to disabled_tests/compiler/import_local/local_imports/lib.leo
diff --git a/tests/compiler/import_local/local_imports/nested/c-d.leo b/disabled_tests/compiler/import_local/local_imports/nested/c-d.leo
similarity index 100%
rename from tests/compiler/import_local/local_imports/nested/c-d.leo
rename to disabled_tests/compiler/import_local/local_imports/nested/c-d.leo
diff --git a/tests/compiler/import_local/local_imports/nested/hello.leo b/disabled_tests/compiler/import_local/local_imports/nested/hello.leo
similarity index 100%
rename from tests/compiler/import_local/local_imports/nested/hello.leo
rename to disabled_tests/compiler/import_local/local_imports/nested/hello.leo
diff --git a/tests/compiler/import_old/alias.leo b/disabled_tests/compiler/import_old/alias.leo
similarity index 100%
rename from tests/compiler/import_old/alias.leo
rename to disabled_tests/compiler/import_old/alias.leo
diff --git a/tests/compiler/import_old/basic.leo b/disabled_tests/compiler/import_old/basic.leo
similarity index 100%
rename from tests/compiler/import_old/basic.leo
rename to disabled_tests/compiler/import_old/basic.leo
diff --git a/tests/compiler/import_old/imports/a-9.leo b/disabled_tests/compiler/import_old/imports/a-9.leo
similarity index 100%
rename from tests/compiler/import_old/imports/a-9.leo
rename to disabled_tests/compiler/import_old/imports/a-9.leo
diff --git a/tests/compiler/import_old/imports/a0-f.leo b/disabled_tests/compiler/import_old/imports/a0-f.leo
similarity index 100%
rename from tests/compiler/import_old/imports/a0-f.leo
rename to disabled_tests/compiler/import_old/imports/a0-f.leo
diff --git a/tests/compiler/import_old/imports/bar/.gitignore b/disabled_tests/compiler/import_old/imports/bar/.gitignore
similarity index 100%
rename from tests/compiler/import_old/imports/bar/.gitignore
rename to disabled_tests/compiler/import_old/imports/bar/.gitignore
diff --git a/tests/compiler/import_old/imports/bar/Leo.toml b/disabled_tests/compiler/import_old/imports/bar/Leo.toml
similarity index 100%
rename from tests/compiler/import_old/imports/bar/Leo.toml
rename to disabled_tests/compiler/import_old/imports/bar/Leo.toml
diff --git a/tests/compiler/import_old/imports/bar/src/bat/bat.leo b/disabled_tests/compiler/import_old/imports/bar/src/bat/bat.leo
similarity index 100%
rename from tests/compiler/import_old/imports/bar/src/bat/bat.leo
rename to disabled_tests/compiler/import_old/imports/bar/src/bat/bat.leo
diff --git a/tests/compiler/import_old/imports/bar/src/baz.leo b/disabled_tests/compiler/import_old/imports/bar/src/baz.leo
similarity index 100%
rename from tests/compiler/import_old/imports/bar/src/baz.leo
rename to disabled_tests/compiler/import_old/imports/bar/src/baz.leo
diff --git a/tests/compiler/import_old/imports/bar/src/lib.leo b/disabled_tests/compiler/import_old/imports/bar/src/lib.leo
similarity index 100%
rename from tests/compiler/import_old/imports/bar/src/lib.leo
rename to disabled_tests/compiler/import_old/imports/bar/src/lib.leo
diff --git a/tests/compiler/import_old/imports/car/.gitignore b/disabled_tests/compiler/import_old/imports/car/.gitignore
similarity index 100%
rename from tests/compiler/import_old/imports/car/.gitignore
rename to disabled_tests/compiler/import_old/imports/car/.gitignore
diff --git a/tests/compiler/import_old/imports/car/Leo.toml b/disabled_tests/compiler/import_old/imports/car/Leo.toml
similarity index 100%
rename from tests/compiler/import_old/imports/car/Leo.toml
rename to disabled_tests/compiler/import_old/imports/car/Leo.toml
diff --git a/tests/compiler/import_old/imports/car/src/lib.leo b/disabled_tests/compiler/import_old/imports/car/src/lib.leo
similarity index 100%
rename from tests/compiler/import_old/imports/car/src/lib.leo
rename to disabled_tests/compiler/import_old/imports/car/src/lib.leo
diff --git a/tests/compiler/import_old/imports/hello-world.leo b/disabled_tests/compiler/import_old/imports/hello-world.leo
similarity index 100%
rename from tests/compiler/import_old/imports/hello-world.leo
rename to disabled_tests/compiler/import_old/imports/hello-world.leo
diff --git a/tests/compiler/import_old/imports/lib.leo b/disabled_tests/compiler/import_old/imports/lib.leo
similarity index 100%
rename from tests/compiler/import_old/imports/lib.leo
rename to disabled_tests/compiler/import_old/imports/lib.leo
diff --git a/tests/compiler/import_old/imports/test-import.leo b/disabled_tests/compiler/import_old/imports/test-import.leo
similarity index 100%
rename from tests/compiler/import_old/imports/test-import.leo
rename to disabled_tests/compiler/import_old/imports/test-import.leo
diff --git a/tests/compiler/import_old/input/dummy.in b/disabled_tests/compiler/import_old/input/dummy.in
similarity index 100%
rename from tests/compiler/import_old/input/dummy.in
rename to disabled_tests/compiler/import_old/input/dummy.in
diff --git a/tests/compiler/import_old/many_import.leo b/disabled_tests/compiler/import_old/many_import.leo
similarity index 100%
rename from tests/compiler/import_old/many_import.leo
rename to disabled_tests/compiler/import_old/many_import.leo
diff --git a/tests/compiler/import_old/many_import_star.leo b/disabled_tests/compiler/import_old/many_import_star.leo
similarity index 100%
rename from tests/compiler/import_old/many_import_star.leo
rename to disabled_tests/compiler/import_old/many_import_star.leo
diff --git a/tests/compiler/import_old/multiple.leo b/disabled_tests/compiler/import_old/multiple.leo
similarity index 100%
rename from tests/compiler/import_old/multiple.leo
rename to disabled_tests/compiler/import_old/multiple.leo
diff --git a/tests/compiler/import_old/names.leo b/disabled_tests/compiler/import_old/names.leo
similarity index 100%
rename from tests/compiler/import_old/names.leo
rename to disabled_tests/compiler/import_old/names.leo
diff --git a/tests/compiler/import_old/names_a_dash_fail.leo b/disabled_tests/compiler/import_old/names_a_dash_fail.leo
similarity index 100%
rename from tests/compiler/import_old/names_a_dash_fail.leo
rename to disabled_tests/compiler/import_old/names_a_dash_fail.leo
diff --git a/tests/compiler/import_old/names_dash_a_fail.leo b/disabled_tests/compiler/import_old/names_dash_a_fail.leo
similarity index 100%
rename from tests/compiler/import_old/names_dash_a_fail.leo
rename to disabled_tests/compiler/import_old/names_dash_a_fail.leo
diff --git a/tests/compiler/import_old/names_dollar_fail.leo b/disabled_tests/compiler/import_old/names_dollar_fail.leo
similarity index 100%
rename from tests/compiler/import_old/names_dollar_fail.leo
rename to disabled_tests/compiler/import_old/names_dollar_fail.leo
diff --git a/tests/compiler/import_old/names_underscore_fail.leo b/disabled_tests/compiler/import_old/names_underscore_fail.leo
similarity index 100%
rename from tests/compiler/import_old/names_underscore_fail.leo
rename to disabled_tests/compiler/import_old/names_underscore_fail.leo
diff --git a/tests/compiler/import_old/star.leo b/disabled_tests/compiler/import_old/star.leo
similarity index 100%
rename from tests/compiler/import_old/star.leo
rename to disabled_tests/compiler/import_old/star.leo
diff --git a/tests/compiler/import_old/star_fail.leo b/disabled_tests/compiler/import_old/star_fail.leo
similarity index 100%
rename from tests/compiler/import_old/star_fail.leo
rename to disabled_tests/compiler/import_old/star_fail.leo
diff --git a/tests/compiler/import_old/string_import.leo b/disabled_tests/compiler/import_old/string_import.leo
similarity index 100%
rename from tests/compiler/import_old/string_import.leo
rename to disabled_tests/compiler/import_old/string_import.leo
diff --git a/tests/compiler/input_files/program_input/different_types_const_signed_fail.leo b/disabled_tests/compiler/input_files/program_input/different_types_const_signed_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/different_types_const_signed_fail.leo
rename to disabled_tests/compiler/input_files/program_input/different_types_const_signed_fail.leo
diff --git a/tests/compiler/input_files/program_input/different_types_fail_signed.leo b/disabled_tests/compiler/input_files/program_input/different_types_fail_signed.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/different_types_fail_signed.leo
rename to disabled_tests/compiler/input_files/program_input/different_types_fail_signed.leo
diff --git a/tests/compiler/input_files/program_input/different_types_unsigned_fail.leo b/disabled_tests/compiler/input_files/program_input/different_types_unsigned_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/different_types_unsigned_fail.leo
rename to disabled_tests/compiler/input_files/program_input/different_types_unsigned_fail.leo
diff --git a/tests/compiler/input_files/program_input/main_array.leo b/disabled_tests/compiler/input_files/program_input/main_array.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_array.leo
rename to disabled_tests/compiler/input_files/program_input/main_array.leo
diff --git a/tests/compiler/input_files/program_input/main_array_fail.leo b/disabled_tests/compiler/input_files/program_input/main_array_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_array_fail.leo
rename to disabled_tests/compiler/input_files/program_input/main_array_fail.leo
diff --git a/tests/compiler/input_files/program_input/main_char.leo b/disabled_tests/compiler/input_files/program_input/main_char.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_char.leo
rename to disabled_tests/compiler/input_files/program_input/main_char.leo
diff --git a/tests/compiler/input_files/program_input/main_multi_dimension_array.leo b/disabled_tests/compiler/input_files/program_input/main_multi_dimension_array.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_multi_dimension_array.leo
rename to disabled_tests/compiler/input_files/program_input/main_multi_dimension_array.leo
diff --git a/tests/compiler/input_files/program_input/main_multiple.leo b/disabled_tests/compiler/input_files/program_input/main_multiple.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_multiple.leo
rename to disabled_tests/compiler/input_files/program_input/main_multiple.leo
diff --git a/tests/compiler/input_files/program_input/main_string.leo b/disabled_tests/compiler/input_files/program_input/main_string.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_string.leo
rename to disabled_tests/compiler/input_files/program_input/main_string.leo
diff --git a/tests/compiler/input_files/program_input/main_tuple.leo b/disabled_tests/compiler/input_files/program_input/main_tuple.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_tuple.leo
rename to disabled_tests/compiler/input_files/program_input/main_tuple.leo
diff --git a/tests/compiler/input_files/program_input/main_tuple_fail.leo b/disabled_tests/compiler/input_files/program_input/main_tuple_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/main_tuple_fail.leo
rename to disabled_tests/compiler/input_files/program_input/main_tuple_fail.leo
diff --git a/tests/compiler/input_files/program_input/non_const_input_const.leo b/disabled_tests/compiler/input_files/program_input/non_const_input_const.leo
similarity index 100%
rename from tests/compiler/input_files/program_input/non_const_input_const.leo
rename to disabled_tests/compiler/input_files/program_input/non_const_input_const.leo
diff --git a/tests/compiler/input_files/program_input_and_program_state/basic.leo b/disabled_tests/compiler/input_files/program_input_and_program_state/basic.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_and_program_state/basic.leo
rename to disabled_tests/compiler/input_files/program_input_and_program_state/basic.leo
diff --git a/tests/compiler/input_files/program_input_and_program_state/input/basic.in b/disabled_tests/compiler/input_files/program_input_and_program_state/input/basic.in
similarity index 100%
rename from tests/compiler/input_files/program_input_and_program_state/input/basic.in
rename to disabled_tests/compiler/input_files/program_input_and_program_state/input/basic.in
diff --git a/tests/compiler/input_files/program_input_and_program_state/input/basic.state b/disabled_tests/compiler/input_files/program_input_and_program_state/input/basic.state
similarity index 100%
rename from tests/compiler/input_files/program_input_and_program_state/input/basic.state
rename to disabled_tests/compiler/input_files/program_input_and_program_state/input/basic.state
diff --git a/tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.in b/disabled_tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.in
similarity index 100%
rename from tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.in
rename to disabled_tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.in
diff --git a/tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.state b/disabled_tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.state
similarity index 100%
rename from tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.state
rename to disabled_tests/compiler/input_files/program_input_and_program_state/input/token_withdraw.state
diff --git a/tests/compiler/input_files/program_input_and_program_state/token_withdraw.leo b/disabled_tests/compiler/input_files/program_input_and_program_state/token_withdraw.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_and_program_state/token_withdraw.leo
rename to disabled_tests/compiler/input_files/program_input_and_program_state/token_withdraw.leo
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main.in b/disabled_tests/compiler/input_files/program_input_constants/input/main.in
new file mode 100644
index 0000000000..3b9dcc2a87
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main.in
@@ -0,0 +1,8 @@
+[main]
+b: bool = true;
+
+[constants]
+a: bool = true;
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_array.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_array.in
new file mode 100644
index 0000000000..6f7e331085
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_array.in
@@ -0,0 +1,8 @@
+[main]
+y: bool = true;
+
+[constants]
+x: [i16; 1] = [0i16; 1];
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_array_fail.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_array_fail.in
new file mode 100644
index 0000000000..3fe6502e8f
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_array_fail.in
@@ -0,0 +1,2 @@
+[constants]
+x: [i16; 1] = [0i16; 1];
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_char.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_char.in
new file mode 100644
index 0000000000..fd975f08aa
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_char.in
@@ -0,0 +1,8 @@
+[main]
+y: bool = true;
+
+[constants]
+a: char = '👍';
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_fail_name.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_fail_name.in
new file mode 100644
index 0000000000..5c7bcd0957
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_fail_name.in
@@ -0,0 +1,2 @@
+[constants]
+bad_name: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_fail_type.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_fail_type.in
new file mode 100644
index 0000000000..8ea9b7fbf5
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_fail_type.in
@@ -0,0 +1,2 @@
+[constants]
+a: u8 = 1;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_field.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_field.in
new file mode 100644
index 0000000000..5f581d8ee1
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_field.in
@@ -0,0 +1,9 @@
+[main]
+y: bool = true;
+
+[constants]
+a: field = 1;
+b: field = -1;
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_group.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_group.in
new file mode 100644
index 0000000000..65922026c4
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_group.in
@@ -0,0 +1,10 @@
+[main]
+y: bool = true;
+
+[constants]
+a: group = 1group;
+b: group = -1group;
+c: group = (0, -1)group;
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_multi_dimension_array.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_multi_dimension_array.in
new file mode 100644
index 0000000000..dc39e2d92c
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_multi_dimension_array.in
@@ -0,0 +1,8 @@
+[main]
+y: [i16; (2, 2, 3)] = [0i16; (2, 2, 3)];
+
+[constants]
+x: [i16; (2, 2, 3)] = [0i16; (2, 2, 3)];
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_multiple.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_multiple.in
new file mode 100644
index 0000000000..92c9e7b192
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_multiple.in
@@ -0,0 +1,9 @@
+[main]
+y: bool = true;
+
+[constants]
+a: bool = true;
+b: bool = false;
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_string.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_string.in
new file mode 100644
index 0000000000..ba500531cc
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_string.in
@@ -0,0 +1,8 @@
+[main]
+y: bool = true;
+
+[constants]
+a: [char; 5] = "😭😂👍😁😘";
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_tuple.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_tuple.in
new file mode 100644
index 0000000000..de4cb26a2f
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_tuple.in
@@ -0,0 +1,8 @@
+[main]
+y: bool = true;
+
+[constants]
+x: (u8, bool, u8) = (10, true, 10);
+
+[registers]
+r0: bool = true;
diff --git a/disabled_tests/compiler/input_files/program_input_constants/input/main_tuple_fail.in b/disabled_tests/compiler/input_files/program_input_constants/input/main_tuple_fail.in
new file mode 100644
index 0000000000..0c1cad5312
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/input/main_tuple_fail.in
@@ -0,0 +1,2 @@
+[constants]
+x: (u8, bool) = (10, true); // wrong size here; main expects (u8, bool, u8)
diff --git a/tests/compiler/input_files/program_input_constants/main_array.leo b/disabled_tests/compiler/input_files/program_input_constants/main_array.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_constants/main_array.leo
rename to disabled_tests/compiler/input_files/program_input_constants/main_array.leo
diff --git a/tests/compiler/input_files/program_input_constants/main_array_fail.leo b/disabled_tests/compiler/input_files/program_input_constants/main_array_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_constants/main_array_fail.leo
rename to disabled_tests/compiler/input_files/program_input_constants/main_array_fail.leo
diff --git a/tests/compiler/input_files/program_input_constants/main_char.leo b/disabled_tests/compiler/input_files/program_input_constants/main_char.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_constants/main_char.leo
rename to disabled_tests/compiler/input_files/program_input_constants/main_char.leo
diff --git a/tests/compiler/input_files/program_input_constants/main_multi_dimension_array.leo b/disabled_tests/compiler/input_files/program_input_constants/main_multi_dimension_array.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_constants/main_multi_dimension_array.leo
rename to disabled_tests/compiler/input_files/program_input_constants/main_multi_dimension_array.leo
diff --git a/disabled_tests/compiler/input_files/program_input_constants/main_multiple.leo b/disabled_tests/compiler/input_files/program_input_constants/main_multiple.leo
new file mode 100644
index 0000000000..e06775ea4b
--- /dev/null
+++ b/disabled_tests/compiler/input_files/program_input_constants/main_multiple.leo
@@ -0,0 +1,9 @@
+/*
+namespace: Compile
+expectation: Pass
+input_file: input/main_multiple.in
+*/
+
+function main(const a: bool, const b: bool, y: bool) -> bool {
+    return (a != b) == y;
+}
diff --git a/tests/compiler/input_files/program_input_constants/main_string.leo b/disabled_tests/compiler/input_files/program_input_constants/main_string.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_constants/main_string.leo
rename to disabled_tests/compiler/input_files/program_input_constants/main_string.leo
diff --git a/tests/compiler/input_files/program_input_constants/main_tuple_fail.leo b/disabled_tests/compiler/input_files/program_input_constants/main_tuple_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_input_constants/main_tuple_fail.leo
rename to disabled_tests/compiler/input_files/program_input_constants/main_tuple_fail.leo
diff --git a/tests/compiler/input_files/program_registers/input/array.in b/disabled_tests/compiler/input_files/program_registers/input/array.in
similarity index 100%
rename from tests/compiler/input_files/program_registers/input/array.in
rename to disabled_tests/compiler/input_files/program_registers/input/array.in
diff --git a/tests/compiler/input_files/program_registers/input/main.in b/disabled_tests/compiler/input_files/program_registers/input/main.in
similarity index 100%
rename from tests/compiler/input_files/program_registers/input/main.in
rename to disabled_tests/compiler/input_files/program_registers/input/main.in
diff --git a/tests/compiler/input_files/program_registers/registers_array.leo b/disabled_tests/compiler/input_files/program_registers/registers_array.leo
similarity index 100%
rename from tests/compiler/input_files/program_registers/registers_array.leo
rename to disabled_tests/compiler/input_files/program_registers/registers_array.leo
diff --git a/tests/compiler/input_files/program_registers/registers_fail.leo b/disabled_tests/compiler/input_files/program_registers/registers_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_registers/registers_fail.leo
rename to disabled_tests/compiler/input_files/program_registers/registers_fail.leo
diff --git a/tests/compiler/input_files/program_registers/registers_pass.leo b/disabled_tests/compiler/input_files/program_registers/registers_pass.leo
similarity index 100%
rename from tests/compiler/input_files/program_registers/registers_pass.leo
rename to disabled_tests/compiler/input_files/program_registers/registers_pass.leo
diff --git a/tests/compiler/input_files/program_state/access_all.leo b/disabled_tests/compiler/input_files/program_state/access_all.leo
similarity index 100%
rename from tests/compiler/input_files/program_state/access_all.leo
rename to disabled_tests/compiler/input_files/program_state/access_all.leo
diff --git a/tests/compiler/input_files/program_state/access_state.leo b/disabled_tests/compiler/input_files/program_state/access_state.leo
similarity index 100%
rename from tests/compiler/input_files/program_state/access_state.leo
rename to disabled_tests/compiler/input_files/program_state/access_state.leo
diff --git a/tests/compiler/input_files/program_state/basic.leo b/disabled_tests/compiler/input_files/program_state/basic.leo
similarity index 100%
rename from tests/compiler/input_files/program_state/basic.leo
rename to disabled_tests/compiler/input_files/program_state/basic.leo
diff --git a/tests/compiler/input_files/program_state/input/basic.state b/disabled_tests/compiler/input_files/program_state/input/basic.state
similarity index 100%
rename from tests/compiler/input_files/program_state/input/basic.state
rename to disabled_tests/compiler/input_files/program_state/input/basic.state
diff --git a/tests/compiler/input_files/program_state/input/dummy.in b/disabled_tests/compiler/input_files/program_state/input/dummy.in
similarity index 100%
rename from tests/compiler/input_files/program_state/input/dummy.in
rename to disabled_tests/compiler/input_files/program_state/input/dummy.in
diff --git a/tests/compiler/input_files/program_state/input/section_invalid.state b/disabled_tests/compiler/input_files/program_state/input/section_invalid.state
similarity index 100%
rename from tests/compiler/input_files/program_state/input/section_invalid.state
rename to disabled_tests/compiler/input_files/program_state/input/section_invalid.state
diff --git a/tests/compiler/input_files/program_state/input/section_undefined.state b/disabled_tests/compiler/input_files/program_state/input/section_undefined.state
similarity index 100%
rename from tests/compiler/input_files/program_state/input/section_undefined.state
rename to disabled_tests/compiler/input_files/program_state/input/section_undefined.state
diff --git a/tests/compiler/input_files/program_state/input/token_withdraw.state b/disabled_tests/compiler/input_files/program_state/input/token_withdraw.state
similarity index 100%
rename from tests/compiler/input_files/program_state/input/token_withdraw.state
rename to disabled_tests/compiler/input_files/program_state/input/token_withdraw.state
diff --git a/tests/compiler/input_files/program_state/input/visibility_fail.state b/disabled_tests/compiler/input_files/program_state/input/visibility_fail.state
similarity index 100%
rename from tests/compiler/input_files/program_state/input/visibility_fail.state
rename to disabled_tests/compiler/input_files/program_state/input/visibility_fail.state
diff --git a/tests/compiler/input_files/program_state/section_invalid.leo b/disabled_tests/compiler/input_files/program_state/section_invalid.leo
similarity index 100%
rename from tests/compiler/input_files/program_state/section_invalid.leo
rename to disabled_tests/compiler/input_files/program_state/section_invalid.leo
diff --git a/tests/compiler/input_files/program_state/section_undefined.leo b/disabled_tests/compiler/input_files/program_state/section_undefined.leo
similarity index 100%
rename from tests/compiler/input_files/program_state/section_undefined.leo
rename to disabled_tests/compiler/input_files/program_state/section_undefined.leo
diff --git a/tests/compiler/input_files/program_state/visibility_fail.leo b/disabled_tests/compiler/input_files/program_state/visibility_fail.leo
similarity index 100%
rename from tests/compiler/input_files/program_state/visibility_fail.leo
rename to disabled_tests/compiler/input_files/program_state/visibility_fail.leo
diff --git a/tests/compiler/integers/i128/max_fail.leo b/disabled_tests/compiler/integers/i128/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/i128/max_fail.leo
rename to disabled_tests/compiler/integers/i128/max_fail.leo
diff --git a/tests/compiler/integers/i128/min_fail.leo b/disabled_tests/compiler/integers/i128/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/i128/min_fail.leo
rename to disabled_tests/compiler/integers/i128/min_fail.leo
diff --git a/tests/compiler/integers/i128/negate_min.leo b/disabled_tests/compiler/integers/i128/negate_min.leo
similarity index 100%
rename from tests/compiler/integers/i128/negate_min.leo
rename to disabled_tests/compiler/integers/i128/negate_min.leo
diff --git a/tests/compiler/integers/i16/max_fail.leo b/disabled_tests/compiler/integers/i16/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/i16/max_fail.leo
rename to disabled_tests/compiler/integers/i16/max_fail.leo
diff --git a/tests/compiler/integers/i16/min_fail.leo b/disabled_tests/compiler/integers/i16/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/i16/min_fail.leo
rename to disabled_tests/compiler/integers/i16/min_fail.leo
diff --git a/tests/compiler/integers/i16/negate_min.leo b/disabled_tests/compiler/integers/i16/negate_min.leo
similarity index 100%
rename from tests/compiler/integers/i16/negate_min.leo
rename to disabled_tests/compiler/integers/i16/negate_min.leo
diff --git a/disabled_tests/compiler/integers/i32/max.leo b/disabled_tests/compiler/integers/i32/max.leo
new file mode 100644
index 0000000000..a0a9b81009
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/max.leo
@@ -0,0 +1,10 @@
+/*
+namespace: Compile
+expectation: Pass
+input_file: ../input/dummy.in
+*/
+
+function main(y: bool) -> bool {
+    const a: i32 = 2147483647;
+    return y == true;
+}
diff --git a/tests/compiler/integers/i32/max_fail.leo b/disabled_tests/compiler/integers/i32/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/i32/max_fail.leo
rename to disabled_tests/compiler/integers/i32/max_fail.leo
diff --git a/disabled_tests/compiler/integers/i32/min.leo b/disabled_tests/compiler/integers/i32/min.leo
new file mode 100644
index 0000000000..a8ba83186c
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/min.leo
@@ -0,0 +1,10 @@
+/*
+namespace: Compile
+expectation: Pass
+input_file: ../input/dummy.in
+*/
+
+function main(y: bool) -> bool {
+    const a: i32 = -2147483648;
+    return y == true;
+}
diff --git a/tests/compiler/integers/i32/min_fail.leo b/disabled_tests/compiler/integers/i32/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/i32/min_fail.leo
rename to disabled_tests/compiler/integers/i32/min_fail.leo
diff --git a/disabled_tests/compiler/integers/i32/mul.leo b/disabled_tests/compiler/integers/i32/mul.leo
new file mode 100644
index 0000000000..ce66848f09
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/mul.leo
@@ -0,0 +1,17 @@
+/*
+namespace: Compile
+expectation: Pass
+inputs:
+ - i32.in: |
+    [main]
+    a: i32 = 2;
+    b: i32 = 5;
+    c: i32 = 10;
+    
+    [registers]
+    r0: bool = false;
+*/
+
+function main(a: i32, b: i32, c: i32) -> bool {
+    return a * b == c;
+}
diff --git a/disabled_tests/compiler/integers/i32/ne.leo b/disabled_tests/compiler/integers/i32/ne.leo
new file mode 100644
index 0000000000..502ca22281
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/ne.leo
@@ -0,0 +1,25 @@
+/*
+namespace: Compile
+expectation: Pass
+inputs:
+ - i32_ne.in: |
+    [main]
+    a: i32 = 2;
+    b: i32 = 5;
+    c: bool = true;
+
+    [registers]
+    r0: bool = false;
+ - i32_e.in: |
+    [main]
+    a: i32 = 5;
+    b: i32 = 5;
+    c: bool = false;
+
+    [registers]
+    r0: bool = false;
+*/
+
+function main(a: i32, b: i32, c: bool) -> bool{
+    return (a != b) == c;
+}
diff --git a/disabled_tests/compiler/integers/i32/negate.leo b/disabled_tests/compiler/integers/i32/negate.leo
new file mode 100644
index 0000000000..2aee276336
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/negate.leo
@@ -0,0 +1,23 @@
+/*
+namespace: Compile
+expectation: Pass
+inputs:
+ - i32.in: |
+    [main]
+    a: i32 = 5;
+    b: i32 = -5;
+
+    [registers]
+    r0: bool = false;
+ - i32.in: |
+    [main]
+    a: i32 = -5;
+    b: i32 = 5;
+
+    [registers]
+    r0: bool = false;
+*/
+
+function main(a: i32, b: i32) -> bool {
+    return -a == b;
+}
diff --git a/tests/compiler/integers/i32/negate_min.leo b/disabled_tests/compiler/integers/i32/negate_min.leo
similarity index 100%
rename from tests/compiler/integers/i32/negate_min.leo
rename to disabled_tests/compiler/integers/i32/negate_min.leo
diff --git a/disabled_tests/compiler/integers/i32/negate_zero.leo b/disabled_tests/compiler/integers/i32/negate_zero.leo
new file mode 100644
index 0000000000..fe9084ea56
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/negate_zero.leo
@@ -0,0 +1,17 @@
+/*
+namespace: Compile
+expectation: Pass
+inputs:
+ - dummy.in: |
+    [main]
+    y: bool = true;
+
+    [registers]
+    r0: bool = false;
+*/
+
+function main(y: bool) -> bool {
+    const a = 0i32;
+
+    return (-a == 0i32) == y;
+}
diff --git a/tests/compiler/integers/u128/min_fail.leo b/disabled_tests/compiler/integers/i32/no_space_between_literal.leo
similarity index 72%
rename from tests/compiler/integers/u128/min_fail.leo
rename to disabled_tests/compiler/integers/i32/no_space_between_literal.leo
index 321104f74c..f3a03890d3 100644
--- a/tests/compiler/integers/u128/min_fail.leo
+++ b/disabled_tests/compiler/integers/i32/no_space_between_literal.leo
@@ -4,5 +4,5 @@ expectation: Fail
 */
 
 function main() {
-    const a: u128 = -1;
+    const i = 1 i32;
 }
diff --git a/disabled_tests/compiler/integers/i32/pow.leo b/disabled_tests/compiler/integers/i32/pow.leo
new file mode 100644
index 0000000000..2db0063b3d
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/pow.leo
@@ -0,0 +1,3 @@
+function main(a: i32, b: i32, c: i32) -> bool {
+    return a ** b == c;
+}
diff --git a/disabled_tests/compiler/integers/i32/sub.leo b/disabled_tests/compiler/integers/i32/sub.leo
new file mode 100644
index 0000000000..cf554eba72
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/sub.leo
@@ -0,0 +1,17 @@
+/*
+namespace: Compile
+expectation: Pass
+inputs:
+ - i32.in: |
+    [main]
+    a: i32 = 100;
+    b: i32 = 50;
+    c: i32 = 50;
+    
+    [registers]
+    r0: bool = false;
+*/
+
+function main(a: i32, b: i32, c: i32) -> bool {
+    return a - b == c;
+}
diff --git a/disabled_tests/compiler/integers/i32/ternary.leo b/disabled_tests/compiler/integers/i32/ternary.leo
new file mode 100644
index 0000000000..bbbb2ac2db
--- /dev/null
+++ b/disabled_tests/compiler/integers/i32/ternary.leo
@@ -0,0 +1,29 @@
+/*
+namespace: Compile
+expectation: Pass
+inputs:
+ - i32.in: |
+    [main]
+    s: bool = true;
+    a: i32 = 10;
+    b: i32 = 5;
+    c: i32 = 10;
+
+    [registers]
+    r0: bool = false;
+ - i32_rev.in: |
+    [main]
+    s: bool = false;
+    a: i32 = 10;
+    b: i32 = 5;
+    c: i32 = 5;
+
+    [registers]
+    r0: bool = false;
+*/
+
+function main(s: bool, a: i32, b: i32, c: i32) -> bool {
+    let r = s ? a : b;
+
+    return r == c;
+}
diff --git a/tests/compiler/integers/i64/max_fail.leo b/disabled_tests/compiler/integers/i64/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/i64/max_fail.leo
rename to disabled_tests/compiler/integers/i64/max_fail.leo
diff --git a/tests/compiler/integers/i64/min_fail.leo b/disabled_tests/compiler/integers/i64/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/i64/min_fail.leo
rename to disabled_tests/compiler/integers/i64/min_fail.leo
diff --git a/tests/compiler/integers/i64/negate_min.leo b/disabled_tests/compiler/integers/i64/negate_min.leo
similarity index 100%
rename from tests/compiler/integers/i64/negate_min.leo
rename to disabled_tests/compiler/integers/i64/negate_min.leo
diff --git a/tests/compiler/integers/i8/max_fail.leo b/disabled_tests/compiler/integers/i8/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/i8/max_fail.leo
rename to disabled_tests/compiler/integers/i8/max_fail.leo
diff --git a/tests/compiler/integers/i8/min_fail.leo b/disabled_tests/compiler/integers/i8/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/i8/min_fail.leo
rename to disabled_tests/compiler/integers/i8/min_fail.leo
diff --git a/tests/compiler/integers/i8/negate_min.leo b/disabled_tests/compiler/integers/i8/negate_min.leo
similarity index 100%
rename from tests/compiler/integers/i8/negate_min.leo
rename to disabled_tests/compiler/integers/i8/negate_min.leo
diff --git a/tests/compiler/integers/u16/max_fail.leo b/disabled_tests/compiler/integers/u16/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/u16/max_fail.leo
rename to disabled_tests/compiler/integers/u16/max_fail.leo
diff --git a/tests/compiler/integers/u16/min_fail.leo b/disabled_tests/compiler/integers/u16/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/u16/min_fail.leo
rename to disabled_tests/compiler/integers/u16/min_fail.leo
diff --git a/tests/compiler/integers/u32/max_fail.leo b/disabled_tests/compiler/integers/u32/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/u32/max_fail.leo
rename to disabled_tests/compiler/integers/u32/max_fail.leo
diff --git a/tests/compiler/integers/u32/min_fail.leo b/disabled_tests/compiler/integers/u32/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/u32/min_fail.leo
rename to disabled_tests/compiler/integers/u32/min_fail.leo
diff --git a/tests/compiler/integers/u64/max_fail.leo b/disabled_tests/compiler/integers/u64/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/u64/max_fail.leo
rename to disabled_tests/compiler/integers/u64/max_fail.leo
diff --git a/tests/compiler/integers/u64/min_fail.leo b/disabled_tests/compiler/integers/u64/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/u64/min_fail.leo
rename to disabled_tests/compiler/integers/u64/min_fail.leo
diff --git a/tests/compiler/integers/u8/max_fail.leo b/disabled_tests/compiler/integers/u8/max_fail.leo
similarity index 100%
rename from tests/compiler/integers/u8/max_fail.leo
rename to disabled_tests/compiler/integers/u8/max_fail.leo
diff --git a/tests/compiler/integers/u8/min_fail.leo b/disabled_tests/compiler/integers/u8/min_fail.leo
similarity index 100%
rename from tests/compiler/integers/u8/min_fail.leo
rename to disabled_tests/compiler/integers/u8/min_fail.leo
diff --git a/tests/compiler/mutability/array_dyn_mut.leo b/disabled_tests/compiler/mutability/array_dyn_mut.leo
similarity index 100%
rename from tests/compiler/mutability/array_dyn_mut.leo
rename to disabled_tests/compiler/mutability/array_dyn_mut.leo
diff --git a/tests/compiler/mutability/array_dyn_mut_indirect.leo b/disabled_tests/compiler/mutability/array_dyn_mut_indirect.leo
similarity index 100%
rename from tests/compiler/mutability/array_dyn_mut_indirect.leo
rename to disabled_tests/compiler/mutability/array_dyn_mut_indirect.leo
diff --git a/tests/compiler/mutability/array_fail.leo b/disabled_tests/compiler/mutability/array_fail.leo
similarity index 100%
rename from tests/compiler/mutability/array_fail.leo
rename to disabled_tests/compiler/mutability/array_fail.leo
diff --git a/tests/compiler/mutability/array_mut.leo b/disabled_tests/compiler/mutability/array_mut.leo
similarity index 100%
rename from tests/compiler/mutability/array_mut.leo
rename to disabled_tests/compiler/mutability/array_mut.leo
diff --git a/tests/compiler/mutability/array_splice_mut.leo b/disabled_tests/compiler/mutability/array_splice_mut.leo
similarity index 100%
rename from tests/compiler/mutability/array_splice_mut.leo
rename to disabled_tests/compiler/mutability/array_splice_mut.leo
diff --git a/tests/compiler/mutability/array_tuple_mut.leo b/disabled_tests/compiler/mutability/array_tuple_mut.leo
similarity index 100%
rename from tests/compiler/mutability/array_tuple_mut.leo
rename to disabled_tests/compiler/mutability/array_tuple_mut.leo
diff --git a/tests/compiler/mutability/circuit_fail.leo b/disabled_tests/compiler/mutability/circuit_fail.leo
similarity index 100%
rename from tests/compiler/mutability/circuit_fail.leo
rename to disabled_tests/compiler/mutability/circuit_fail.leo
diff --git a/tests/compiler/mutability/circuit_function_const.leo b/disabled_tests/compiler/mutability/circuit_function_const.leo
similarity index 100%
rename from tests/compiler/mutability/circuit_function_const.leo
rename to disabled_tests/compiler/mutability/circuit_function_const.leo
diff --git a/tests/compiler/mutability/circuit_function_mut.leo b/disabled_tests/compiler/mutability/circuit_function_mut.leo
similarity index 100%
rename from tests/compiler/mutability/circuit_function_mut.leo
rename to disabled_tests/compiler/mutability/circuit_function_mut.leo
diff --git a/tests/compiler/mutability/circuit_static_function_mut_fail.leo b/disabled_tests/compiler/mutability/circuit_static_function_mut_fail.leo
similarity index 100%
rename from tests/compiler/mutability/circuit_static_function_mut_fail.leo
rename to disabled_tests/compiler/mutability/circuit_static_function_mut_fail.leo
diff --git a/tests/compiler/mutability/circuit_variable_mut.leo b/disabled_tests/compiler/mutability/circuit_variable_mut.leo
similarity index 100%
rename from tests/compiler/mutability/circuit_variable_mut.leo
rename to disabled_tests/compiler/mutability/circuit_variable_mut.leo
diff --git a/tests/compiler/mutability/const.leo b/disabled_tests/compiler/mutability/const.leo
similarity index 100%
rename from tests/compiler/mutability/const.leo
rename to disabled_tests/compiler/mutability/const.leo
diff --git a/tests/compiler/mutability/function_input.leo b/disabled_tests/compiler/mutability/function_input.leo
similarity index 100%
rename from tests/compiler/mutability/function_input.leo
rename to disabled_tests/compiler/mutability/function_input.leo
diff --git a/tests/compiler/mutability/let_fail.leo b/disabled_tests/compiler/mutability/let_fail.leo
similarity index 100%
rename from tests/compiler/mutability/let_fail.leo
rename to disabled_tests/compiler/mutability/let_fail.leo
diff --git a/disabled_tests/compiler/mutability/let_mut_nested.leo b/disabled_tests/compiler/mutability/let_mut_nested.leo
new file mode 100644
index 0000000000..98d1293211
--- /dev/null
+++ b/disabled_tests/compiler/mutability/let_mut_nested.leo
@@ -0,0 +1,12 @@
+/*
+namespace: Compile
+expectation: Pass
+input_file: input/dummy.in
+*/
+
+function main(a: bool) -> bool {
+    let x = 2u8;
+    let y = x;
+    let z = y / 2u8;
+    return (z == 1) == a;
+}
diff --git a/tests/compiler/mutability/swap.leo b/disabled_tests/compiler/mutability/swap.leo
similarity index 100%
rename from tests/compiler/mutability/swap.leo
rename to disabled_tests/compiler/mutability/swap.leo
diff --git a/tests/compiler/statements/all_loops.leo b/disabled_tests/compiler/statements/all_loops.leo
similarity index 100%
rename from tests/compiler/statements/all_loops.leo
rename to disabled_tests/compiler/statements/all_loops.leo
diff --git a/tests/compiler/statements/assign_ternary.leo b/disabled_tests/compiler/statements/assign_ternary.leo
similarity index 100%
rename from tests/compiler/statements/assign_ternary.leo
rename to disabled_tests/compiler/statements/assign_ternary.leo
diff --git a/tests/compiler/statements/block.leo b/disabled_tests/compiler/statements/block.leo
similarity index 100%
rename from tests/compiler/statements/block.leo
rename to disabled_tests/compiler/statements/block.leo
diff --git a/tests/compiler/statements/compound_assignment.leo b/disabled_tests/compiler/statements/compound_assignment.leo
similarity index 100%
rename from tests/compiler/statements/compound_assignment.leo
rename to disabled_tests/compiler/statements/compound_assignment.leo
diff --git a/tests/compiler/statements/duplicate_variable.leo b/disabled_tests/compiler/statements/duplicate_variable.leo
similarity index 100%
rename from tests/compiler/statements/duplicate_variable.leo
rename to disabled_tests/compiler/statements/duplicate_variable.leo
diff --git a/tests/compiler/statements/for_loop.leo b/disabled_tests/compiler/statements/for_loop.leo
similarity index 100%
rename from tests/compiler/statements/for_loop.leo
rename to disabled_tests/compiler/statements/for_loop.leo
diff --git a/tests/compiler/statements/iteration_basic.leo b/disabled_tests/compiler/statements/iteration_basic.leo
similarity index 100%
rename from tests/compiler/statements/iteration_basic.leo
rename to disabled_tests/compiler/statements/iteration_basic.leo
diff --git a/tests/compiler/statements/iteration_variable.leo b/disabled_tests/compiler/statements/iteration_variable.leo
similarity index 100%
rename from tests/compiler/statements/iteration_variable.leo
rename to disabled_tests/compiler/statements/iteration_variable.leo
diff --git a/tests/compiler/statements/nested_mutate.leo b/disabled_tests/compiler/statements/nested_mutate.leo
similarity index 100%
rename from tests/compiler/statements/nested_mutate.leo
rename to disabled_tests/compiler/statements/nested_mutate.leo
diff --git a/tests/compiler/statements/reverse_loops.leo b/disabled_tests/compiler/statements/reverse_loops.leo
similarity index 100%
rename from tests/compiler/statements/reverse_loops.leo
rename to disabled_tests/compiler/statements/reverse_loops.leo
diff --git a/tests/compiler/statements/reverse_one.leo b/disabled_tests/compiler/statements/reverse_one.leo
similarity index 100%
rename from tests/compiler/statements/reverse_one.leo
rename to disabled_tests/compiler/statements/reverse_one.leo
diff --git a/tests/compiler/statements/ternary_non_const_fail.leo b/disabled_tests/compiler/statements/ternary_non_const_fail.leo
similarity index 100%
rename from tests/compiler/statements/ternary_non_const_fail.leo
rename to disabled_tests/compiler/statements/ternary_non_const_fail.leo
diff --git a/tests/compiler/stdlib/core_circuit_star_fail.leo b/disabled_tests/compiler/stdlib/core_circuit_star_fail.leo
similarity index 100%
rename from tests/compiler/stdlib/core_circuit_star_fail.leo
rename to disabled_tests/compiler/stdlib/core_circuit_star_fail.leo
diff --git a/tests/compiler/stdlib/core_package_invalid.leo b/disabled_tests/compiler/stdlib/core_package_invalid.leo
similarity index 100%
rename from tests/compiler/stdlib/core_package_invalid.leo
rename to disabled_tests/compiler/stdlib/core_package_invalid.leo
diff --git a/tests/compiler/stdlib/core_unstable_package_invalid.leo b/disabled_tests/compiler/stdlib/core_unstable_package_invalid.leo
similarity index 100%
rename from tests/compiler/stdlib/core_unstable_package_invalid.leo
rename to disabled_tests/compiler/stdlib/core_unstable_package_invalid.leo
diff --git a/tests/compiler/stdlib/strings.leo b/disabled_tests/compiler/stdlib/strings.leo
similarity index 100%
rename from tests/compiler/stdlib/strings.leo
rename to disabled_tests/compiler/stdlib/strings.leo
diff --git a/tests/compiler/string/circuit.leo b/disabled_tests/compiler/string/circuit.leo
similarity index 100%
rename from tests/compiler/string/circuit.leo
rename to disabled_tests/compiler/string/circuit.leo
diff --git a/tests/compiler/string/equality.leo b/disabled_tests/compiler/string/equality.leo
similarity index 100%
rename from tests/compiler/string/equality.leo
rename to disabled_tests/compiler/string/equality.leo
diff --git a/tests/compiler/string/inputs/string.in b/disabled_tests/compiler/string/inputs/string.in
similarity index 100%
rename from tests/compiler/string/inputs/string.in
rename to disabled_tests/compiler/string/inputs/string.in
diff --git a/tests/compiler/string/inputs/string_out.in b/disabled_tests/compiler/string/inputs/string_out.in
similarity index 100%
rename from tests/compiler/string/inputs/string_out.in
rename to disabled_tests/compiler/string/inputs/string_out.in
diff --git a/tests/compiler/string/inputs/two.in b/disabled_tests/compiler/string/inputs/two.in
similarity index 100%
rename from tests/compiler/string/inputs/two.in
rename to disabled_tests/compiler/string/inputs/two.in
diff --git a/tests/compiler/string/inputs/weird.in b/disabled_tests/compiler/string/inputs/weird.in
similarity index 100%
rename from tests/compiler/string/inputs/weird.in
rename to disabled_tests/compiler/string/inputs/weird.in
diff --git a/tests/compiler/string/replace.leo b/disabled_tests/compiler/string/replace.leo
similarity index 100%
rename from tests/compiler/string/replace.leo
rename to disabled_tests/compiler/string/replace.leo
diff --git a/tests/compiler/string/string_transformation.leo b/disabled_tests/compiler/string/string_transformation.leo
similarity index 100%
rename from tests/compiler/string/string_transformation.leo
rename to disabled_tests/compiler/string/string_transformation.leo
diff --git a/tests/compiler/tuples/access.leo b/disabled_tests/compiler/tuples/access.leo
similarity index 100%
rename from tests/compiler/tuples/access.leo
rename to disabled_tests/compiler/tuples/access.leo
diff --git a/tests/compiler/tuples/basic.leo b/disabled_tests/compiler/tuples/basic.leo
similarity index 100%
rename from tests/compiler/tuples/basic.leo
rename to disabled_tests/compiler/tuples/basic.leo
diff --git a/tests/compiler/tuples/dependent.leo b/disabled_tests/compiler/tuples/dependent.leo
similarity index 100%
rename from tests/compiler/tuples/dependent.leo
rename to disabled_tests/compiler/tuples/dependent.leo
diff --git a/tests/compiler/tuples/destructured.leo b/disabled_tests/compiler/tuples/destructured.leo
similarity index 100%
rename from tests/compiler/tuples/destructured.leo
rename to disabled_tests/compiler/tuples/destructured.leo
diff --git a/tests/compiler/tuples/inputs/true_true.in b/disabled_tests/compiler/tuples/inputs/true_true.in
similarity index 100%
rename from tests/compiler/tuples/inputs/true_true.in
rename to disabled_tests/compiler/tuples/inputs/true_true.in
diff --git a/tests/compiler/tuples/nested_access.leo b/disabled_tests/compiler/tuples/nested_access.leo
similarity index 100%
rename from tests/compiler/tuples/nested_access.leo
rename to disabled_tests/compiler/tuples/nested_access.leo
diff --git a/leo/commands/build.rs b/leo/commands/build.rs
index 3996c17dcf..1808186973 100644
--- a/leo/commands/build.rs
+++ b/leo/commands/build.rs
@@ -15,7 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::{commands::Command, context::Context};
-use leo_compiler::{Ast, Compiler};
+use leo_compiler::{Ast, Compiler, InputAst};
 use leo_errors::{CliError, Result};
 use leo_package::{
     inputs::InputFile,
@@ -101,7 +101,7 @@ pub struct Build {
 
 impl Command for Build {
     type Input = ();
-    type Output = (Ast, bool);
+    type Output = (Option<InputAst>, Ast, bool);
 
     fn log_span(&self) -> Span {
         tracing::span!(tracing::Level::INFO, "Build")
@@ -180,13 +180,15 @@ impl Command for Build {
         // Initialize error handler
         let handler = leo_errors::emitter::Handler::default();
 
-        let program = Compiler::new(&handler, main_file_path, output_directory, input_path.to_path_buf());
+        let mut program = Compiler::new(&handler, main_file_path, output_directory);
+        program.parse_program()?;
+        program.parse_input(input_path.to_path_buf())?;
 
         // Compute the current program checksum
         let program_checksum = program.checksum()?;
 
         // Compile the program
-        let program_compiled = program.compile()?;
+        program.compile()?;
 
         // Generate the program on the constraint system and verify correctness
         {
@@ -240,6 +242,6 @@ impl Command for Build {
 
         tracing::info!("Complete");
 
-        Ok((program_compiled, checksum_differs))
+        Ok((program.input_ast, program.ast, checksum_differs))
     }
 }
diff --git a/leo/errors/src/common/macros.rs b/leo/errors/src/common/macros.rs
index e353922bfb..4f880c1c17 100644
--- a/leo/errors/src/common/macros.rs
+++ b/leo/errors/src/common/macros.rs
@@ -33,7 +33,7 @@ macro_rules! create_messages {
         use backtrace::Backtrace;
 
         // Generates the enum and implements from FormattedError and BacktracedErrors.
-        #[derive(Debug, Error)]
+        #[derive(Clone, Debug, Error)]
         $(#[$error_type_docs])*
         pub enum $type_ {
             #[error(transparent)]
diff --git a/leo/errors/src/emitter/mod.rs b/leo/errors/src/emitter/mod.rs
index f736e8c879..ce3d407ac8 100644
--- a/leo/errors/src/emitter/mod.rs
+++ b/leo/errors/src/emitter/mod.rs
@@ -27,18 +27,29 @@ pub trait Emitter {
     /// Emit the error `err`.
     fn emit_err(&mut self, err: LeoError);
 
+    /// Tracks last emmited error.
+    fn last_emited_err(&self) -> Option<LeoError>;
+
     /// Emit the warning.
     fn emit_warning(&mut self, warning: LeoWarning);
 }
 
 /// A trivial `Emitter` using the standard error.
-pub struct StderrEmitter;
+pub struct StderrEmitter {
+    /// The last emitted error.
+    last_error: Option<LeoError>,
+}
 
 impl Emitter for StderrEmitter {
     fn emit_err(&mut self, err: LeoError) {
+        self.last_error = Some(err.clone());
         eprintln!("{}", err);
     }
 
+    fn last_emited_err(&self) -> Option<LeoError> {
+        self.last_error.clone()
+    }
+
     fn emit_warning(&mut self, warning: LeoWarning) {
         eprintln!("{warning}");
     }
@@ -64,6 +75,11 @@ impl<T> Buffer<T> {
     pub fn into_inner(self) -> Vec<T> {
         self.0
     }
+
+    /// Last entry to the buffer.
+    pub fn last_entry(&self) -> Option<&T> {
+        self.0.last()
+    }
 }
 
 impl<T: fmt::Display> fmt::Display for Buffer<T> {
@@ -110,6 +126,11 @@ impl Emitter for BufferEmitter {
         self.0.borrow_mut().push(err);
     }
 
+    fn last_emited_err(&self) -> Option<LeoError> {
+        let temp = &*self.0.borrow();
+        temp.last_entry().cloned()
+    }
+
     fn emit_warning(&mut self, warning: LeoWarning) {
         self.1.borrow_mut().push(warning);
     }
@@ -133,6 +154,11 @@ impl HandlerInner {
         self.emitter.emit_err(err);
     }
 
+    /// Gets the last emitted error's exit code.
+    fn last_emited_err(&self) -> Option<LeoError> {
+        self.emitter.last_emited_err()
+    }
+
     /// Emit the error `err`.
     fn emit_warning(&mut self, warning: LeoWarning) {
         self.warn_count = self.warn_count.saturating_add(1);
@@ -149,7 +175,7 @@ pub struct Handler {
 
 impl Default for Handler {
     fn default() -> Self {
-        Self::new(Box::new(StderrEmitter))
+        Self::new(Box::new(StderrEmitter { last_error: None }))
     }
 }
 
@@ -211,6 +237,16 @@ impl Handler {
         self.err_count() > 0
     }
 
+    /// Gets the last emitted error's exit code if it exists.
+    /// Then exits the program with it if it did exist.
+    pub fn last_err(&self) -> Result<(), LeoError> {
+        if let Some(code) = self.inner.borrow().last_emited_err() {
+            Err(code)
+        } else {
+            Ok(())
+        }
+    }
+
     /// Extend handler with `error` given `res = Err(error)`.
     #[allow(clippy::result_unit_err)]
     pub fn extend_if_error<T>(&self, res: Result<T, LeoError>) -> Result<T, ()> {
diff --git a/leo/errors/src/errors/ast/ast_errors.rs b/leo/errors/src/errors/ast/ast_errors.rs
index f52e1c6c3f..3ca7ad1b10 100644
--- a/leo/errors/src/errors/ast/ast_errors.rs
+++ b/leo/errors/src/errors/ast/ast_errors.rs
@@ -138,4 +138,28 @@ create_messages!(
         msg: "tuples of 1 element are not allowed",
         help: None,
     }
+
+    /// For when a user shadows a function.
+    @formatted
+    shadowed_function {
+        args: (func: impl Display),
+        msg: format!("function `{func}` shadowed"),
+        help: None,
+    }
+
+    /// For when a user shadows a function input.
+    @formatted
+    shadowed_function_input {
+        args: (fn_input: impl Display),
+        msg: format!("function input `{fn_input}` shadowed"),
+        help: None,
+    }
+
+    /// For when a user shadows a variable.
+    @formatted
+    shadowed_variable {
+        args: (var: impl Display),
+        msg: format!("variable `{var}` shadowed"),
+        help: None,
+    }
 );
diff --git a/leo/errors/src/errors/mod.rs b/leo/errors/src/errors/mod.rs
index 2970c9549a..90014fafdc 100644
--- a/leo/errors/src/errors/mod.rs
+++ b/leo/errors/src/errors/mod.rs
@@ -43,7 +43,7 @@ pub use self::parser::*;
 
 /// The LeoError type that contains all sub error types.
 /// This allows a unified error type throughout the Leo crates.
-#[derive(Debug, Error)]
+#[derive(Clone, Debug, Error)]
 pub enum LeoError {
     /// Represents an AST Error in a Leo Error.
     #[error(transparent)]
diff --git a/leo/main.rs b/leo/main.rs
index 34a3d66a71..2b8ebe9abb 100644
--- a/leo/main.rs
+++ b/leo/main.rs
@@ -29,6 +29,7 @@ use commands::{
     // Deploy, Init, Lint, New, Prove, Run, Setup, Test, Update, Watch,
 };
 use leo_errors::Result;
+use leo_span::symbol::create_session_if_not_set_then;
 // use snarkvm_utilities::Write;
 
 use std::{path::PathBuf, process::exit};
@@ -206,7 +207,7 @@ fn set_panic_hook() {
 
 fn main() {
     set_panic_hook();
-    handle_error(run_with_args(Opt::from_args()));
+    handle_error(create_session_if_not_set_then(|_| run_with_args(Opt::from_args())));
 }
 
 /// Run command with custom build arguments.
diff --git a/tests/compiler/definition/out_of_order.leo b/tests/compiler/definition/out_of_order.leo
index 047b5a2238..3b3a7551f7 100644
--- a/tests/compiler/definition/out_of_order.leo
+++ b/tests/compiler/definition/out_of_order.leo
@@ -4,11 +4,11 @@ expectation: Pass
 input_file: input/dummy.in
 */
 
-@test
-function fake_test() {}
+// @test
+// function fake_test() {}
 
 function main(y: bool) -> bool {
     return y == true;
 }
 
-circuit Foo {}
+// circuit Foo {}
diff --git a/tests/compiler/function/duplicate_definition_fail.leo b/tests/compiler/function/duplicate_definition_fail.leo
index 9b003b6015..4f3a449a13 100644
--- a/tests/compiler/function/duplicate_definition_fail.leo
+++ b/tests/compiler/function/duplicate_definition_fail.leo
@@ -4,7 +4,6 @@ expectation: Fail
 input_file: input/dummy.in
 */
 
-
 function main(y: bool) -> bool {
     console.log("{}", 1u8);
     return y;
diff --git a/tests/compiler/function/iteration.leo b/tests/compiler/function/iteration.leo
index 1c0b310fa5..6811a9da9c 100644
--- a/tests/compiler/function/iteration.leo
+++ b/tests/compiler/function/iteration.leo
@@ -12,7 +12,7 @@ function main(y: bool) -> bool {
     let a = 0u32;
 
     for i in 0..10 {
-        a += one();
+        a = a + one();
     }
 
     return (a == 10u32) == y;
diff --git a/tests/compiler/function/iteration_repeated.leo b/tests/compiler/function/iteration_repeated.leo
index bf443867bd..bbcd429322 100644
--- a/tests/compiler/function/iteration_repeated.leo
+++ b/tests/compiler/function/iteration_repeated.leo
@@ -8,7 +8,7 @@ function iteration() -> u32 {
     let a = 0u32;
 
     for i in 0..10 {
-        a += 1;
+        a = a + 1;
     }
 
     return a;
diff --git a/tests/compiler/input_files/program_input/const_input_non_const.leo b/tests/compiler/input_files/program_input/const_input_non_const.leo
deleted file mode 100644
index 86d8333c54..0000000000
--- a/tests/compiler/input_files/program_input/const_input_non_const.leo
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-input_file: input/const_input_non_const.in
-*/
-
-function main(a: u32) {
-    let b = a * 2;
-}
diff --git a/tests/compiler/input_files/program_input/const_var_in_both_sections_fail.leo b/tests/compiler/input_files/program_input/const_var_in_both_sections_fail.leo
deleted file mode 100644
index 168f144c6c..0000000000
--- a/tests/compiler/input_files/program_input/const_var_in_both_sections_fail.leo
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-input_file: input/var_in_both_sections_fail.in
-*/
-
-function main(const a: u32) {
-    let b = a * 2;
-}
diff --git a/tests/compiler/input_files/program_input/different_types_const_unsigned_fail.leo b/tests/compiler/input_files/program_input/different_types_const_unsigned_fail.leo
deleted file mode 100644
index c8e13aaf04..0000000000
--- a/tests/compiler/input_files/program_input/different_types_const_unsigned_fail.leo
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-input_file: input/different_types_const_unsigned_fail.in
-*/
-
-function main(const a: u32) {
-    let b = a * 2;
-}
diff --git a/tests/compiler/input_files/program_input/input/const_input_non_const.in b/tests/compiler/input_files/program_input/input/const_input_non_const.in
index 27cf6f4b00..8096414b6b 100644
--- a/tests/compiler/input_files/program_input/input/const_input_non_const.in
+++ b/tests/compiler/input_files/program_input/input/const_input_non_const.in
@@ -1,2 +1,2 @@
-[constants]
-a: u32 = 2;
\ No newline at end of file
+[main]
+constant a: u32 = 2;
\ No newline at end of file
diff --git a/tests/compiler/input_files/program_input/input/var_in_both_sections_fail.in b/tests/compiler/input_files/program_input/input/var_in_both_sections_fail.in
deleted file mode 100644
index af3110a8a5..0000000000
--- a/tests/compiler/input_files/program_input/input/var_in_both_sections_fail.in
+++ /dev/null
@@ -1,5 +0,0 @@
-[main]
-a: u32 = 2u32;
-
-[constants]
-a: u32 = 2u32;
\ No newline at end of file
diff --git a/tests/compiler/input_files/program_input/var_in_both_sections_fail.leo b/tests/compiler/input_files/program_input/var_in_both_sections_fail.leo
deleted file mode 100644
index 4aef4366df..0000000000
--- a/tests/compiler/input_files/program_input/var_in_both_sections_fail.leo
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-input_file: input/var_in_both_sections_fail.in
-*/
-
-function main(a: u32) {
-    let b = a * 2;
-}
diff --git a/tests/compiler/input_files/program_input_constants/main_tuple.leo b/tests/compiler/input_files/program_input_constants/main_tuple.leo
deleted file mode 100644
index ef0d5e85e7..0000000000
--- a/tests/compiler/input_files/program_input_constants/main_tuple.leo
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
-namespace: Compile
-expectation: Pass
-input_file: input/main_tuple.in
-*/
-
-function main(const x: (u8, bool, u8), y: bool) -> bool {
-    return x.0 == 10 && x.1 == true && x.2 == 10;
-}
diff --git a/tests/compiler/integers/u128/max_fail.leo b/tests/compiler/integers/u128/max_fail.leo
deleted file mode 100644
index 3872bdf79d..0000000000
--- a/tests/compiler/integers/u128/max_fail.leo
+++ /dev/null
@@ -1,8 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-*/
-
-function main() {
-    const a: u128 = 340282366920938463463374607431768211456;
-}
diff --git a/tests/compiler/integers/u128/negative_input_fail.leo b/tests/compiler/integers/u128/negative_input_fail.leo
deleted file mode 100644
index c7d86f79f2..0000000000
--- a/tests/compiler/integers/u128/negative_input_fail.leo
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-inputs:
- - u128.in: |
-    [main]
-    a: u128 = -2;
-*/
-
-function main(a: u128) {}
\ No newline at end of file
diff --git a/tests/compiler/integers/u16/negative_input_fail.leo b/tests/compiler/integers/u16/negative_input_fail.leo
deleted file mode 100644
index 68195f2a45..0000000000
--- a/tests/compiler/integers/u16/negative_input_fail.leo
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-inputs:
- - u16.in: |
-    [main]
-    a: u16 = -2;
-*/
-
-function main(a: u16) {}
\ No newline at end of file
diff --git a/tests/compiler/integers/u32/negative_input_fail.leo b/tests/compiler/integers/u32/negative_input_fail.leo
deleted file mode 100644
index 5dc1d2f223..0000000000
--- a/tests/compiler/integers/u32/negative_input_fail.leo
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-inputs:
- - u32.in: |
-    [main]
-    a: u32 = -2;
-*/
-
-function main(a: u32) {}
\ No newline at end of file
diff --git a/tests/compiler/integers/u64/negative_input_fail.leo b/tests/compiler/integers/u64/negative_input_fail.leo
deleted file mode 100644
index cac01bcdad..0000000000
--- a/tests/compiler/integers/u64/negative_input_fail.leo
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-inputs:
- - u64.in: |
-    [main]
-    a: u64 = -2;
-*/
-
-function main(a: u64) {}
\ No newline at end of file
diff --git a/tests/compiler/integers/u8/negative_input_fail.leo b/tests/compiler/integers/u8/negative_input_fail.leo
deleted file mode 100644
index ca7b5616fe..0000000000
--- a/tests/compiler/integers/u8/negative_input_fail.leo
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
-namespace: Compile
-expectation: Fail
-inputs:
- - u8.in: |
-    [main]
-    a: u8 = -2;
-*/
-
-function main(a: u8) {}
\ No newline at end of file
diff --git a/tests/compiler/mutability/cond_mut.leo b/tests/compiler/mutability/cond_mut.leo
index 1cac6d876d..7a4a188804 100644
--- a/tests/compiler/mutability/cond_mut.leo
+++ b/tests/compiler/mutability/cond_mut.leo
@@ -8,7 +8,7 @@ function main(y: bool) -> bool {
     let x = 100i8;
     if false {
         x = 1i8;
-        x *= 100i8;
+        x = x * 100i8;
     }
     
     return (x == 100i8) == y;
diff --git a/tests/compiler/mutability/input/dummy.in b/tests/compiler/mutability/input/dummy.in
index 7cbf636d04..67c4b89ded 100644
--- a/tests/compiler/mutability/input/dummy.in
+++ b/tests/compiler/mutability/input/dummy.in
@@ -1,7 +1,7 @@
 [main]
 a: bool = true;
 y: bool = true;
-arr: [u32; 2] = [10, 8];
+// arr: [u32; 2] = [10, 8];
 
 [constants]
 b: bool = true;
diff --git a/tests/compiler/mutability/let_mut.leo b/tests/compiler/mutability/let_mut.leo
deleted file mode 100644
index 7c303ac0d4..0000000000
--- a/tests/compiler/mutability/let_mut.leo
+++ /dev/null
@@ -1,13 +0,0 @@
-/*
-namespace: Compile
-expectation: Pass
-input_file: input/dummy.in
-*/
-
-// Adding the `mut` keyword makes a variable mutable.
-function main(y: bool) -> bool {
-    let a = 1u32;
-    a = 0;
-
-    return (a == 0u32) == y;
-}
diff --git a/tests/expectations/compiler/compiler/address/branch.leo.out b/tests/expectations/compiler/compiler/address/branch.leo.out
index e7bad0daa0..936e0a2745 100644
--- a/tests/expectations/compiler/compiler/address/branch.leo.out
+++ b/tests/expectations/compiler/compiler/address/branch.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1024
-      num_constraints: 1536
-      at: 5afd1d58b6826912fe5cba06b60d9a7debdbad9e922b8a78ed49f7a7ca0ac65e
-      bt: db77c3470cf1b3c80c2e3b1b3ddc59d9891912489bfcf39b7f67c2f314ca7f6d
-      ct: d0993682df5b495f4a6784882e0f007dbc378adb35007d250e2c098975f4d32e
-    output:
-      - input_file: inputs/branch.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "true"
-    initial_ast: 7ad5e2d2d6b833861f055b51029ed74cb9aba444d689578b0a1d1e2ff90d848d
-    imports_resolved_ast: 045b43d9a82ffc1c7d36d8c299aa42e682e43e11b7af043d5d9bde522ef43f24
-    canonicalized_ast: 045b43d9a82ffc1c7d36d8c299aa42e682e43e11b7af043d5d9bde522ef43f24
-    type_inferenced_ast: 45e22455ff329af7695237d84c319e6160fd5a181d18e6b4edfa6bfb33845011
+  - output:
+      - initial_input_ast: bbe973798ab14152165455260924a0de60131d31da32d2e223228954365dc609
+        symbol_table: 6f506e4bd93ca4a193014f33276e519aec48586d26a29a6a40c7fc7434a70b6d
+    initial_ast: eec1883a71c0ffd8b84ccf32538073fb8dece4b49f502227eef42f55ed4970af
diff --git a/tests/expectations/compiler/compiler/address/equal.leo.out b/tests/expectations/compiler/compiler/address/equal.leo.out
index eb3bcfb75d..0ef478b0d2 100644
--- a/tests/expectations/compiler/compiler/address/equal.leo.out
+++ b/tests/expectations/compiler/compiler/address/equal.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 511
-      num_constraints: 511
-      at: 61e8ee994e9e7edc1f84fa3cbe8c421ade231189b9ddf6a9a75eeef9915c20f7
-      bt: 2194515882da93c79fa24d47c40fddc44f0284da25da7b89efb935c0ea7382f8
-      ct: a0736e8c8f3bb1c39a147348754e53dfd31fd76a1df9cd9960472841bcc531df
-    output:
-      - input_file: inputs/address1.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "true"
-      - input_file: inputs/address2.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "false"
-    initial_ast: d30da3fdf0dd78daaa3e9c9205d4b0586e1b7ac260bb7ffd8e2d4987bfa9abaf
-    imports_resolved_ast: e92ad6367f56037fc168702523540baf869e2c5b089812a08e2e230ba45c40b4
-    canonicalized_ast: e92ad6367f56037fc168702523540baf869e2c5b089812a08e2e230ba45c40b4
-    type_inferenced_ast: 3dab0722613f664942053774b68d600d51ebaef77d30e166f707c5ce88749443
+  - output: []
+    initial_ast: 645b5ba48404f604913d22b3ad993adbcd44eaaf5c8f8291e40f7af64871e56e
diff --git a/tests/expectations/compiler/compiler/address/ternary.leo.out b/tests/expectations/compiler/compiler/address/ternary.leo.out
index 54fad5e547..940748e04a 100644
--- a/tests/expectations/compiler/compiler/address/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/address/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1022
-      num_constraints: 1022
-      at: 1b42ef63a212d2ea51cab07171c8fb1438112afdbd14501470c2477b9eeb4c99
-      bt: 15054154626f1ae748008fc4ed9a650c3873b608988ff31312fe4049957dfffb
-      ct: dbda9de51fe9897456cbbcc3b450ed7d66185fb6018c7a0c72414784f29b2ad4
-    output:
-      - input_file: inputs/address1.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "false"
-      - input_file: inputs/address2.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "false"
-    initial_ast: 85d3058b1d8ec4612bc789d7ac9bc49ec5d8edce42d3363eefe4de1a3808b44d
-    imports_resolved_ast: fe38e424a54f4d75e998fd43899428009a99f4f412eae9cd536ce3e22eace228
-    canonicalized_ast: fe38e424a54f4d75e998fd43899428009a99f4f412eae9cd536ce3e22eace228
-    type_inferenced_ast: ef12afa598976ebeda5e1c755f3b4f01ce74ecd72a46a8dda8bf7fe53c32a228
+  - output: []
+    initial_ast: 8baa16e9a7222f4579562286af1f60cdff52a128460c4f3c123aa46d8d3e2e28
diff --git a/tests/expectations/compiler/compiler/boolean/and.leo.out b/tests/expectations/compiler/compiler/boolean/and.leo.out
index 6c9ecc6292..ae26b05d29 100644
--- a/tests/expectations/compiler/compiler/boolean/and.leo.out
+++ b/tests/expectations/compiler/compiler/boolean/and.leo.out
@@ -2,39 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3
-      num_constraints: 3
-      at: bbd0722c65502a4b903833f9ff9e614e877f9b5c58c670593e2aa290d0457b2f
-      bt: 49e8fa1fd3f85b0f486c49f194e4fff3da5e8039685fca1f3327389cbe9fc180
-      ct: ae5c1ab4ec8811a2ec2efb38b91ab4a8b6fb80bd914b31f9a70559531aeb6a46
-    output:
-      - input_file: input/false_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/false_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/true_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/true_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-    initial_ast: 7a4ea96dd5092207c18b972784f4dee261b8fcfcbd6591a8f1376afabe2b09f5
-    imports_resolved_ast: 3529a67adc02429d5a17758c0f895348e44469a434a3af443c382135b89c5169
-    canonicalized_ast: 3529a67adc02429d5a17758c0f895348e44469a434a3af443c382135b89c5169
-    type_inferenced_ast: e5daa67ef6314295794fd13dd5b513abfd692ddf36fe2b4509edf99dc34645f5
+  - output: []
+    initial_ast: 603affb858de195474d9dc4f5896b019649fbd6f9fb28eb94c5ff41f9bcf67e2
diff --git a/tests/expectations/compiler/compiler/boolean/conditional.leo.out b/tests/expectations/compiler/compiler/boolean/conditional.leo.out
index 535b9e5aa8..16c9062fc6 100644
--- a/tests/expectations/compiler/compiler/boolean/conditional.leo.out
+++ b/tests/expectations/compiler/compiler/boolean/conditional.leo.out
@@ -2,39 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3
-      num_constraints: 3
-      at: bbd0722c65502a4b903833f9ff9e614e877f9b5c58c670593e2aa290d0457b2f
-      bt: 49e8fa1fd3f85b0f486c49f194e4fff3da5e8039685fca1f3327389cbe9fc180
-      ct: ae5c1ab4ec8811a2ec2efb38b91ab4a8b6fb80bd914b31f9a70559531aeb6a46
-    output:
-      - input_file: input/false_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/false_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/true_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/true_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-    initial_ast: 45a04deb6029e54df7233eadfef5d67f56ca3e757e232f0b27febe8b92a7a037
-    imports_resolved_ast: 6aa3054db501b621e4ee499a42a47431f8da29a2b6dd44a6b0ae16f3303aea48
-    canonicalized_ast: 6aa3054db501b621e4ee499a42a47431f8da29a2b6dd44a6b0ae16f3303aea48
-    type_inferenced_ast: 13c07566232bd3efaf33c3b685cf05ab7d14960347bee22c8ddcbe424e7ed7a3
+  - output: []
+    initial_ast: f577369ef75a92dd680338305c55f95a94ffb0b5ea8e6d090d4e7682666da163
diff --git a/tests/expectations/compiler/compiler/boolean/equal.leo.out b/tests/expectations/compiler/compiler/boolean/equal.leo.out
index 1f10b48e3b..d40e257a55 100644
--- a/tests/expectations/compiler/compiler/boolean/equal.leo.out
+++ b/tests/expectations/compiler/compiler/boolean/equal.leo.out
@@ -2,39 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3
-      num_constraints: 3
-      at: 01e9615846575e848deea9a9802ceed188fdbfc4660f6f22de41845adcce14ac
-      bt: 49e8fa1fd3f85b0f486c49f194e4fff3da5e8039685fca1f3327389cbe9fc180
-      ct: 7ca43d5c34997f3c866631161cb33186cc016972238c07771ae105ca1b05320d
-    output:
-      - input_file: input/false_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-      - input_file: input/false_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/true_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/true_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-    initial_ast: 48ea8376628464c6968c55a725f095f6f5060bf7f66961b8f3ea118758207656
-    imports_resolved_ast: 24e8288d6a7ba36e0f73cb6469d499bd058049047086844c800dfd2cafa68c31
-    canonicalized_ast: 24e8288d6a7ba36e0f73cb6469d499bd058049047086844c800dfd2cafa68c31
-    type_inferenced_ast: 9d2e51bd9b2ea5391e45d5355c11cab2df0d693a99748aad10c62f57063cf19a
+  - output: []
+    initial_ast: c366a1ca90cc0d6bd3bafb7e83313549d028b101d1759d30d587aeca574f36c6
diff --git a/tests/expectations/compiler/compiler/boolean/not_equal.leo.out b/tests/expectations/compiler/compiler/boolean/not_equal.leo.out
index b44f511e46..029d2e95c2 100644
--- a/tests/expectations/compiler/compiler/boolean/not_equal.leo.out
+++ b/tests/expectations/compiler/compiler/boolean/not_equal.leo.out
@@ -2,39 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3
-      num_constraints: 3
-      at: 01e9615846575e848deea9a9802ceed188fdbfc4660f6f22de41845adcce14ac
-      bt: 49e8fa1fd3f85b0f486c49f194e4fff3da5e8039685fca1f3327389cbe9fc180
-      ct: 7ca43d5c34997f3c866631161cb33186cc016972238c07771ae105ca1b05320d
-    output:
-      - input_file: input/false_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/false_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-      - input_file: input/true_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-      - input_file: input/true_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-    initial_ast: 3d0dc21618d13dfb8087f0927018e473ae7d8e62d834003c14e3d180e07a56df
-    imports_resolved_ast: 3a02fa251d1c4386286e0c46b469e907d30140d80b29405e25fc103e073d6ce7
-    canonicalized_ast: 3a02fa251d1c4386286e0c46b469e907d30140d80b29405e25fc103e073d6ce7
-    type_inferenced_ast: 97132ba7a71063118cf6353b9178b21416ec429e43770f1db5b6a92dc6609236
+  - output: []
+    initial_ast: 760e9080bf2690928551e6f4f2466824c75f81464043faa37580ac9d9e07ce2a
diff --git a/tests/expectations/compiler/compiler/boolean/or.leo.out b/tests/expectations/compiler/compiler/boolean/or.leo.out
index b8731948a5..3369afa293 100644
--- a/tests/expectations/compiler/compiler/boolean/or.leo.out
+++ b/tests/expectations/compiler/compiler/boolean/or.leo.out
@@ -2,39 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3
-      num_constraints: 3
-      at: 1df8316bf2fa59a7a92242252ec3c26a425f07212a4c716b2fefd4ddabc2d773
-      bt: b95daadce52bb9a3b59565f7078664afbebde46b9b5d6a187e4877926e7a506c
-      ct: fc07ea064122a2b3be5414ded4cd1e51e3aef7240ad33c8888d757909e9c2c07
-    output:
-      - input_file: input/false_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "false"
-      - input_file: input/false_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-      - input_file: input/true_false.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-      - input_file: input/true_true.in
-        output:
-          registers:
-            x:
-              type: bool
-              value: "true"
-    initial_ast: e1d9891781a91d415be3fefdc4362bc69317f4bbddd5c51ec1fa817004c07bcd
-    imports_resolved_ast: e64ef7e89a12cdbb7a8d6d5cf4c2fd52157820391f6d1ed0b43f597dc83183e0
-    canonicalized_ast: e64ef7e89a12cdbb7a8d6d5cf4c2fd52157820391f6d1ed0b43f597dc83183e0
-    type_inferenced_ast: 15a9981ccb9dac48ac8a755d1219d21bbfab9ef80b27dfd302209aad151485e1
+  - output: []
+    initial_ast: 0ed2a39bfdc56279524de062f31305fb67a8e073e29e159414bd82c17585369a
diff --git a/tests/expectations/compiler/compiler/definition/out_of_order.leo.out b/tests/expectations/compiler/compiler/definition/out_of_order.leo.out
index ebd7248768..b27f67e4ca 100644
--- a/tests/expectations/compiler/compiler/definition/out_of_order.leo.out
+++ b/tests/expectations/compiler/compiler/definition/out_of_order.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 63a00adfea5e1c974020e0ee0b7499cda444cfbfb11f0de2ada1e0b5ffe990d7
-    imports_resolved_ast: e77168ff058f4e108286532bca8e74cad8af6eec6d1ccc04a2fb2baa69b21a8a
-    canonicalized_ast: cd2f45e163acc4ac3aae12ed8cf1adf6d377dc92405e288aa568104df61ed3e5
-    type_inferenced_ast: cce5364f933e2a249363fa3a454b35903e9eef597649395a826fbfa178df9722
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: fe836874629cdc86427a1048352c6e75e7a2981ee5c9819df0fd946eb79d4d8b
+    initial_ast: 5ef5995607c9487bbba88bd6e2806f19ca1ef11bf6bb7507f75f6a5f32d39fb6
diff --git a/tests/expectations/compiler/compiler/field/add.leo.out b/tests/expectations/compiler/compiler/field/add.leo.out
index b7af48cd9d..8a0f18d33a 100644
--- a/tests/expectations/compiler/compiler/field/add.leo.out
+++ b/tests/expectations/compiler/compiler/field/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 5
-      num_constraints: 3
-      at: 58e404664f2d64d2fd5fee64bf6e997f542a822b8b17e394fcdd7bed05386db8
-      bt: f91b8601243dbd0d25e7df8f34ff304ca78a295fdfafbe0102ec6ce4fcb3c0f0
-      ct: fe68b86a12c0b8c1585a656d7c4b8c47fbe19677b5da7ce0aae1d80dffb2a2ca
-    output:
-      - input_file: inputs/fields.in
-        output:
-          registers:
-            r:
-              type: bool
-              value: "true"
-    initial_ast: ffc8d42ca8a5b9f473036aba6df1b2977ecce1ff8e733824f6ad557bfb331369
-    imports_resolved_ast: fe1b3ec06440cf6213ecff80c4bf47ddae102275eeadd74e65e55bdd0fbb5511
-    canonicalized_ast: fe1b3ec06440cf6213ecff80c4bf47ddae102275eeadd74e65e55bdd0fbb5511
-    type_inferenced_ast: 7b9036a020392e3a05903476543b3e2c28ffdbff3b13c63ee21aba0a6189d27c
+  - output: []
+    initial_ast: c0f200537ad3f17f2dc9f703cd995c7644356a2eff79aa6d49bf799028e12c87
diff --git a/tests/expectations/compiler/compiler/field/div.leo.out b/tests/expectations/compiler/compiler/field/div.leo.out
index e978104ca2..9d185fecd7 100644
--- a/tests/expectations/compiler/compiler/field/div.leo.out
+++ b/tests/expectations/compiler/compiler/field/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 7
-      num_constraints: 5
-      at: 545f3730dcbdb3a3dff41db4263dd41f9be9cf279fdc3cde9518973db0c88685
-      bt: 0a5ae5a6be6351f852bbcc193e57320be38fff279cf6fd65a3239c3a64239b27
-      ct: f25b05da849d0d7fcaab89d41d9624efacb48b7ba983f73a0d5f383b16f7009b
-    output:
-      - input_file: inputs/fields.in
-        output:
-          registers:
-            r:
-              type: bool
-              value: "true"
-    initial_ast: 932b406167eb569de88471503766528ac8a4c5f670d3e160e6f9f0bfcf02461d
-    imports_resolved_ast: e23c3850779a2b30f704e545780a15652b97bd4bf77df7f579ef2abb3a5c4d94
-    canonicalized_ast: e23c3850779a2b30f704e545780a15652b97bd4bf77df7f579ef2abb3a5c4d94
-    type_inferenced_ast: 2b8e44a4e7becef177df33b48ed19175d60f2578a40a6a1de1851eb2aaf28256
+  - output: []
+    initial_ast: 385b93965a80f1b5eadb12bf1d49f5fbaeebfefe3d24c735d94ef4f30730bdaf
diff --git a/tests/expectations/compiler/compiler/field/eq.leo.out b/tests/expectations/compiler/compiler/field/eq.leo.out
index 05373817a4..4f8a5c5215 100644
--- a/tests/expectations/compiler/compiler/field/eq.leo.out
+++ b/tests/expectations/compiler/compiler/field/eq.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 4
-      num_constraints: 3
-      at: ca775a363045cd405dd1d60cd10edb6cc6e4c0b164934951dab0977509b8225c
-      bt: 02c492cb6df07172e56cffd0cfd902a8443921e1256a2d907bbabd30bf6b8f6d
-      ct: a1f8e2b168c0f2f28f0ca3f16ce9b25ba7f7c410cfd68b0912bf19c90b53f2a2
-    output:
-      - input_file: inputs/fields.in
-        output:
-          registers:
-            r:
-              type: bool
-              value: "true"
-    initial_ast: e9ac98692c288217864688ca094e0451dd6c845550cfc2ea5769b5deb4547eaf
-    imports_resolved_ast: 0c47b5152a7b72c27970efb8c85601172c72661d9172ec748ea1785a79d8fdd8
-    canonicalized_ast: 0c47b5152a7b72c27970efb8c85601172c72661d9172ec748ea1785a79d8fdd8
-    type_inferenced_ast: 2b5ada02d0374e5c30ac6ab90c2ab7376ff52702a3963d6141821ab126302e23
+  - output: []
+    initial_ast: 63b88151e636d767e04285b45861e6f08c9a96bbaea5f65f8d68b21ee9d332c8
diff --git a/tests/expectations/compiler/compiler/field/field.leo.out b/tests/expectations/compiler/compiler/field/field.leo.out
index 2bbca103ed..7ce7da1f5e 100644
--- a/tests/expectations/compiler/compiler/field/field.leo.out
+++ b/tests/expectations/compiler/compiler/field/field.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3
-      num_constraints: 3
-      at: 0b86cac5ba812f96b6db4b5ffdd1d8463fdaadd3fc8c3eaad8049aca72850ddf
-      bt: 96fe80788f9958c843626c6f725ffd743f3ada2504e3bd16be94746921689578
-      ct: f1ede3ef5da6734d87d6254c41b53dd3e93b4b7a9e9b232f10d9525554fe16c6
-    output:
-      - input_file: inputs/fields.in
-        output:
-          registers:
-            r:
-              type: bool
-              value: "true"
-    initial_ast: 6135fa40327e58ea773bff67c6e76b5b50b0994186d9aa54fb13491334e3532d
-    imports_resolved_ast: 79d6894d3028943497549f7cb781fbed5db7c152f956e688150e99745bc9ad5b
-    canonicalized_ast: 79d6894d3028943497549f7cb781fbed5db7c152f956e688150e99745bc9ad5b
-    type_inferenced_ast: 3de55f7092ee12e91501d6354fa6209f6603ef54aca9c68b2faadd1ffeecfa85
+  - output: []
+    initial_ast: 7807bb74715d079409f6cb1b57e0e8a2d265df94a00c6a941f9302d2bf3a183b
diff --git a/tests/expectations/compiler/compiler/field/mul.leo.out b/tests/expectations/compiler/compiler/field/mul.leo.out
index 76b0c83c00..0f2b9baab9 100644
--- a/tests/expectations/compiler/compiler/field/mul.leo.out
+++ b/tests/expectations/compiler/compiler/field/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 6
-      num_constraints: 4
-      at: 7dcea624bdc7a6e6fb5f5e93395e84a96db66898779eb3f5595c4e30e3684f17
-      bt: c21a8e9f463d2fad68fd3a88904dd88f2a3dc7dcb01835357fa4ee457ef1673b
-      ct: 4b4ef106804964b8a1ee7c1dad3d4682d20a0d07f576130bfec9989b353bf596
-    output:
-      - input_file: inputs/fields.in
-        output:
-          registers:
-            r:
-              type: bool
-              value: "false"
-    initial_ast: 30cb94ba997d6fcefaf262c46c458d79c8d91ca82093176bc6f15acc6d0a8c5f
-    imports_resolved_ast: ec196189f619b82d485797d2135a9f6ced582cf3cc5243f1eaabd176b2735b74
-    canonicalized_ast: ec196189f619b82d485797d2135a9f6ced582cf3cc5243f1eaabd176b2735b74
-    type_inferenced_ast: 65dd23f12d7325fa6dd0940d420e18144e3239f5e3fde6caf2368bd7f2860811
+  - output: []
+    initial_ast: 7daee749c08af61d98febaa31f6b0b372dd5e4edd8ac7782ade6e78072e54ad4
diff --git a/tests/expectations/compiler/compiler/field/negate.leo.out b/tests/expectations/compiler/compiler/field/negate.leo.out
index fb5fb43001..97fcd94580 100644
--- a/tests/expectations/compiler/compiler/field/negate.leo.out
+++ b/tests/expectations/compiler/compiler/field/negate.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 4
-      num_constraints: 3
-      at: cc1286e0b6fa2e90fb6f0880431a7c1e2cc37a329fae3aff1c13f51036c66f12
-      bt: 02c492cb6df07172e56cffd0cfd902a8443921e1256a2d907bbabd30bf6b8f6d
-      ct: a1f8e2b168c0f2f28f0ca3f16ce9b25ba7f7c410cfd68b0912bf19c90b53f2a2
-    output:
-      - input_file: inputs/fields.in
-        output:
-          registers:
-            r:
-              type: bool
-              value: "true"
-    initial_ast: 5c4f471a1aad427a69fd882c654d86c883c7b7d624d7acf502fabb3c1a76da6c
-    imports_resolved_ast: aeb53d96b9622a8ef8f03bf1c7df09c4026b44729c8d0767a3e884e329faebfe
-    canonicalized_ast: aeb53d96b9622a8ef8f03bf1c7df09c4026b44729c8d0767a3e884e329faebfe
-    type_inferenced_ast: e090e43fe73bb5988858a30e1a569a51d8c016cf2209b64e0c8bb50a50d9310e
+  - output: []
+    initial_ast: a379c937898e9a3ab56fee13ac2e5bb137f96dcc7faf121c0c8f5daec726a510
diff --git a/tests/expectations/compiler/compiler/function/conditional_return.leo.out b/tests/expectations/compiler/compiler/function/conditional_return.leo.out
index ffd8cd9391..96ed2a4266 100644
--- a/tests/expectations/compiler/compiler/function/conditional_return.leo.out
+++ b/tests/expectations/compiler/compiler/function/conditional_return.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 95
-      num_constraints: 127
-      at: 2cbb45563950440ec6b2ad12e378f1df49d6a12d4e773f0aa898f65f4eb109ff
-      bt: 7e12153373f45abf58e3b2954d1f1abfc951c7c1203e9e6c96fc37d9d25d8442
-      ct: 50977b6cd45450d9fddf5934d9167f889165f6ff117b03bb780bd6d89434daf4
-    output:
-      - input_file: input/integers.in
-        output:
-          registers:
-            a:
-              type: u32
-              value: "4"
-    initial_ast: b0aee81e563eee312c23111cbc8e4539b75e0327aa542a47fab9d4ef37b38fbe
-    imports_resolved_ast: 0804164d1eb1d00132f7f5a7f2610d939694ece73e1705062dbd2793308c2cc8
-    canonicalized_ast: 0804164d1eb1d00132f7f5a7f2610d939694ece73e1705062dbd2793308c2cc8
-    type_inferenced_ast: e1a8d8a2ad3b963df503aa562c3b59d37a9c083e63d7de2cc871fd86c6c2be8c
+  - output:
+      - initial_input_ast: 5f87daedee2388c007b6a79619b20407b8460a41ff30433a611554f9bacd6ecf
+        symbol_table: 201ed1188a77438794f46c40fd317d61309595d6b8a6964db2391ea33194ba9c
+    initial_ast: 9e6a274bbf78b10fc2fe402fb5b75fec31690d4661259dec5695ee38520a9d6f
diff --git a/tests/expectations/compiler/compiler/function/duplicate_definition_fail.leo.out b/tests/expectations/compiler/compiler/function/duplicate_definition_fail.leo.out
index c7ba950269..3a6791e0f2 100644
--- a/tests/expectations/compiler/compiler/function/duplicate_definition_fail.leo.out
+++ b/tests/expectations/compiler/compiler/function/duplicate_definition_fail.leo.out
@@ -2,4 +2,4 @@
 namespace: Compile
 expectation: Fail
 outputs:
-  - "Error [EASG0373015]: a function named \"main\" already exists in this scope\n    --> compiler-test:9:1\n     |\n   9 | function main(y: bool) -> bool {\n  10 |      ...\n  11 |      ...\n  12 | }\n     | ^"
+  - "Error [EAST0372014]: function `main` shadowed\n    --> compiler-test:3:1\n     |\n   3 | function main(y: bool) -> bool {\n   4 |      ...\n   5 |      ...\n   6 | }\n     | ^\nError [EAST0372014]: function `main` shadowed\n    --> compiler-test:3:1\n     |\n   3 | function main(y: bool) -> bool {\n   4 |      ...\n   5 |      ...\n   6 | }\n     | ^"
diff --git a/tests/expectations/compiler/compiler/function/empty.leo.out b/tests/expectations/compiler/compiler/function/empty.leo.out
index 4c39d46a9c..b0731c74d2 100644
--- a/tests/expectations/compiler/compiler/function/empty.leo.out
+++ b/tests/expectations/compiler/compiler/function/empty.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: cca2be9dc274619a310c6164cce0419e04a39ae11691ee481dad8baa7e071201
-    imports_resolved_ast: 7430eee72d434ad161eea282f0f7040f3a7eb854490b457da6e8a5b1ae46dda5
-    canonicalized_ast: 0f277252cd55431007a479ac4c37558e7a14a9c20e2d7bc6f7474958de3863ff
-    type_inferenced_ast: 50dab7153ad39a75117d76a8e39c87a1540b24e836b6b2585017ad5897182c2f
+  - output:
+      - initial_input_ast: d718416ac1a3ae6c6d9cc30f75175eb408f584cff8de4994a756a054e4571dbc
+        symbol_table: d1ff083142697183ed20f1989dd069d1910f9732684ade2ec955004b77853b7a
+    initial_ast: 4f0c4b4f3a3059043a32edfa4afee21866fff6870d398897c57b7849d39ab004
diff --git a/tests/expectations/compiler/compiler/function/iteration.leo.out b/tests/expectations/compiler/compiler/function/iteration.leo.out
index b6d3f4c789..2755de171b 100644
--- a/tests/expectations/compiler/compiler/function/iteration.leo.out
+++ b/tests/expectations/compiler/compiler/function/iteration.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 15a5fd1ead3be9705022c6b8d6b1d5b027ce3372197d4d342f30ba5dc5108d3a
-    imports_resolved_ast: be81990192561dd8a22cbf67cc29447f0a61a33b8bb676819be381c84298c4d4
-    canonicalized_ast: c0311c2e3223d0a32afee57aafb1323bb08366a904d0775ef48f701bc108e37d
-    type_inferenced_ast: 8a5cc60bef30ee846dd5bd18f0d1df4539c0b6c000f7dca1aeb1b3853bb10621
+  - output:
+      - initial_input_ast: d718416ac1a3ae6c6d9cc30f75175eb408f584cff8de4994a756a054e4571dbc
+        symbol_table: b3e2b8611c915bb1cc02c55da02f52b14220c46b641a64c12d373e5b080e05aa
+    initial_ast: fe8956cdb15c1c47f66eaf29a4432aba5bc8ac69317bcde3373515ab3a9c4e0f
diff --git a/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out b/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out
index 29ddba27e8..f96583248a 100644
--- a/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out
+++ b/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 2739f323c714258c2f41be1ea0e7d5d4b1b6100d41a232204221540e3d155b98
-    imports_resolved_ast: 1348982d07ba2b271bde48ec59dcadcf287d4878832bfd504dc225126f3bb0db
-    canonicalized_ast: 5e9ba7cd47bd28af1a72b83d830cde2c9c737cce10e87f928fb3fbbb010a81c9
-    type_inferenced_ast: fb07aaa6e07d7ab768366ae79ba95f3938a76892155ca7b142d3ed65efe6c6a5
+  - output:
+      - initial_input_ast: d718416ac1a3ae6c6d9cc30f75175eb408f584cff8de4994a756a054e4571dbc
+        symbol_table: 810eac2cd2c03bd318d5216b4bba024737c31201ee0ca7f2713ef1adf01b78d4
+    initial_ast: aa3f5e742a53e960cd3e522099fca35f0a80977fe5815241a50b367c34a76600
diff --git a/tests/expectations/compiler/compiler/function/repeated.leo.out b/tests/expectations/compiler/compiler/function/repeated.leo.out
index 9aac24bcb1..e8108c14d1 100644
--- a/tests/expectations/compiler/compiler/function/repeated.leo.out
+++ b/tests/expectations/compiler/compiler/function/repeated.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 9db2132a80b875db93ba9faa272d46c8e0b9bd3e561f457e4388b6b75f2da708
-    imports_resolved_ast: 1d17d29a3020a099484220650ad8f1477b713874f5ba7181a4e96752f9addbe3
-    canonicalized_ast: 1d17d29a3020a099484220650ad8f1477b713874f5ba7181a4e96752f9addbe3
-    type_inferenced_ast: 333404df1440cae1176b04c0c9eee5a0370c16295a20ce45c6144849e209ff44
+  - output:
+      - initial_input_ast: d718416ac1a3ae6c6d9cc30f75175eb408f584cff8de4994a756a054e4571dbc
+        symbol_table: 2cfbddeb0164fe71820d396f5eb04b09e354158022e54c498a676cb9ce676a57
+    initial_ast: af7f82d7b8b1c09d0658813c7f59fa5ae9b65f697ae04399d01f6fb142e5f880
diff --git a/tests/expectations/compiler/compiler/function/return.leo.out b/tests/expectations/compiler/compiler/function/return.leo.out
index c47ff8ed25..62c797ab37 100644
--- a/tests/expectations/compiler/compiler/function/return.leo.out
+++ b/tests/expectations/compiler/compiler/function/return.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: baf6543c53c08f26703bca8541dd804c699470fd9378c5f1fc0edccf8f070a54
-    imports_resolved_ast: bc8f34c08103383ddc262f881a669798e66f8944302448fd87315928e5a161e4
-    canonicalized_ast: bc8f34c08103383ddc262f881a669798e66f8944302448fd87315928e5a161e4
-    type_inferenced_ast: ccdd5b12784e3763ec28fe860feb45e0c3b8866d15e8b939ab8fe8c343d1b855
+  - output:
+      - initial_input_ast: d718416ac1a3ae6c6d9cc30f75175eb408f584cff8de4994a756a054e4571dbc
+        symbol_table: b25c0ab70906c0cac81eca91609c3ad6201198c2f871147e455f0689d1222e6d
+    initial_ast: 3c9f874c442a8b41ff0e3f3f212d96690d2665022d7898045bec0b18495db1bc
diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out
index 5a353752cd..ad763c111b 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/main.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 3448b9b7ffa15f9d66783b0f28de8869111da903ad1ee87599af52dc520af15d
-    imports_resolved_ast: 44e8ee4ec6b14400cf1e4a2b9e90462b3f8b46d52384d9ec3d32a3e88b607adb
-    canonicalized_ast: 44e8ee4ec6b14400cf1e4a2b9e90462b3f8b46d52384d9ec3d32a3e88b607adb
-    type_inferenced_ast: d601032c7e53d4b29378721b0768d1e57ed4a4c3526d46d2cd1dadfae6873f3e
+  - output:
+      - initial_input_ast: dcc83a9319d9784c4bed7596d95f4bb19e2f5db1122e17bfa37e3458ed69c4fd
+        symbol_table: aabee41c31620f09539e282b4e32b28bde056bd182c3866ffd9a095f1dd60c14
+    initial_ast: 06f1b743bd89e797249d51660f05d3b53d8c3e5a55c00c414795059fdd194ca1
diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out
index 027c52ce75..a28e6b24f3 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 6
-      num_constraints: 5
-      at: ab475a59a3c7d4299665005e00fe7232cd3ea2238493f31211c33f3057e3c1d7
-      bt: 691f0be87cb1ac6a001269af3d7dbe2c860290538950dc921f318ccf2f319d66
-      ct: 6d17d0577f11cb480fd832f84c38611e836e8aa93457407aa17c07c6ef9d3e03
-    output:
-      - input_file: input/main_field.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 7bef1d7dc04dee6e2d6269059cb95d6fa5386fdd00a64369d33dbdcd12e9d4f3
-    imports_resolved_ast: a830a8e344a9debd20112d1dcb994f7891cb695d546f36e840dc301bbc2bf971
-    canonicalized_ast: a830a8e344a9debd20112d1dcb994f7891cb695d546f36e840dc301bbc2bf971
-    type_inferenced_ast: f75d47a38b82f1ce3eeb4b9999deed924d211c7543c1996f44d56e7e5b772054
+  - output:
+      - initial_input_ast: 26ff565eeaeeca7a4cc7c752bfe5e745db05dbbb559a36b7dcb4a9c9d5cf899e
+        symbol_table: 5a73abac57c301567a8824e865c06c6e771418fb1b6aec0d7e5f598ccbcdfed0
+    initial_ast: ffdacfde92b14a8fc1e7c53d51cf47345ba944ceac0340520122f64e80c0ab1e
diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out
index 281748fe8c..53cbf1aa75 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out
@@ -2,18 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 12
-      num_constraints: 9
-      at: df88b362955f00b8c41afd9e31c9e41e4b8254a71ea0f3f2f97d5b6b8b767415
-      bt: df58aff07b131c34e977ffb5657bbd21852f59fd7e059117c419c3c6070a7053
-      ct: 335cdfb09b13172262042abccf4560511666deaa63cc1b3f30dd35dcb554840f
-    output:
-      - input_file: input/main_group.in
-        output:
-          registers: {}
-    initial_ast: 574b9f0bb10b896d43f2ce2a75e9f6a53f795066963fa09463e2da4abfeaae08
-    imports_resolved_ast: 84556b9ce4167fcd7f8f00efbdc440b893045a7b3f860ba4570a021fe54db91a
-    canonicalized_ast: fd0df53c9f6093e952a04240d4b667d360d1f29083aa896a91bd80103d58e08f
-    type_inferenced_ast: 915167f337d76b6a6c58860a763aad64450ca27dcad6264b34a591f9bf418c18
+  - output:
+      - initial_input_ast: 723e9ab87822d7d8d793ca1611eabcebc684097a64f37a4cd246ff9e506a4865
+        symbol_table: 27ba3868c5417bf99f34622b3a2f074fc400f9550b4a282b47c559391f961b55
+    initial_ast: 7e9c14acddc22727d5f7a480aaa8a88eabb1be94072f9124d286bd0c2224d018
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out
index 56ebcee0e1..3afe4bfd40 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/main.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: afff6e446053138cbf5af07b4610b1f2ecc16b522b9659f459e0803b64b947d7
-    imports_resolved_ast: 1b294caf522987b87060d0beae9493d75c3516278fcc584dd3a06c4c51dff0c2
-    canonicalized_ast: 1b294caf522987b87060d0beae9493d75c3516278fcc584dd3a06c4c51dff0c2
-    type_inferenced_ast: bea359569618e21dc7b9db8a1fb0a720a698c6c7a5927fb778148a57680919b7
+  - output:
+      - initial_input_ast: ce38ef1ec7bdaaf35b68d011803255589ed870002583000a76f137d7682bc3d6
+        symbol_table: 21f3e603be14808f79859aaf18a4b7da2a22a7aef7f4b758b0514b745bc52474
+    initial_ast: 806f13e7c1584039d0f1aae5c8b4f8ed432d35770ec576610d6249afb88141bb
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out
index 781f7807d2..48b70f1745 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 4
-      num_constraints: 5
-      at: 992d6f01cfca64e86db6fe2886e91e8f17a4adaf663a344190bfbeda791ee53d
-      bt: 6d3a525cf2df60aa6d24cdfc442b4d97ee54b70d2c685ff8d0dc01201f53fab7
-      ct: 0cbdac23e63505aa9f74483b5fff133d1f9f976417e6370626514df04711d802
-    output:
-      - input_file: input/main_field.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: a3a3fece322e4a9ea891b2ecf26bfcff0d8a55365b7eb17e48bf1c692b7510be
-    imports_resolved_ast: 4ae183ab1504194000aa011540bac9ca3c01b4e2cfa0ac6eaca14fe85e2a639c
-    canonicalized_ast: 4ae183ab1504194000aa011540bac9ca3c01b4e2cfa0ac6eaca14fe85e2a639c
-    type_inferenced_ast: 683e7732660c51ad8c526f15c8d2401e5def743b0b463f79431bab8de3523584
+  - output:
+      - initial_input_ast: 93b2623d14170f20805af8b04d8ca7c6a61263fa9ae2a2f0afa24168af9ff4d2
+        symbol_table: e3a4953e1d858fcd09177faa813c5a4f70850a7fb3394ac3c6b32eb37d38931c
+    initial_ast: f64a7585251a99b5a711175263bf8bd39fa959a7f1488f9aa3a8ba40a5dc9247
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out
index f478dbaa41..a8c87c40b6 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/main_group.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 3415b9dc8670e8ef08c87c8b6e36532cbba0a086e4583f0972603ea6dc4b6bfb
-    imports_resolved_ast: 25ac6b39c6a2b2bbf637ed2a06bb0c02762c228c437ed9b2e7dd362e20001935
-    canonicalized_ast: 25ac6b39c6a2b2bbf637ed2a06bb0c02762c228c437ed9b2e7dd362e20001935
-    type_inferenced_ast: 55b3f679b11855cf22023a34b5d5d09d1772994bd61baf6b7ceb26b327f4c4f1
+  - output:
+      - initial_input_ast: eebcd00b27aba004420d4f00da025325da9ff86d29162e54401fa55b5758ae39
+        symbol_table: 218ef310cf0f462d7729c17904f4abd6e7f1fb05a4de0ab0a80b1eba84f765e7
+    initial_ast: 8b077463b76328b9a910bf0eaab51a74e7b69e1cddbcedc9226a5358f13b9bf0
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out
index 0ffa562438..fa1dbe706f 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/main_multiple.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 841fab63212fa6030fe800e4494dc455a9f4d91a583a3780669f6d5431702646
-    imports_resolved_ast: 8d90701424ca8b5722a13dc009ee0a84f62e4869c74c79e9590cefa07ce61e2a
-    canonicalized_ast: 8d90701424ca8b5722a13dc009ee0a84f62e4869c74c79e9590cefa07ce61e2a
-    type_inferenced_ast: d85a4f34150f9b87932f445575f606078fccff1649919264de7daed050c09d30
+  - output:
+      - initial_input_ast: 81306ba48e4ea08106311612bfd5c1bce79242ca08695fda8584780329266063
+        symbol_table: 6680aaab1d739d10eb145876c05f90779c9888b98dce5eeb122517ef87fb4536
+    initial_ast: 3c27f9f5dddfc4a5a036c33fd9bbbff4594bcdb188cff720d0e8ae7f171f6acf
diff --git a/tests/expectations/compiler/compiler/integers/i128/add.leo.out b/tests/expectations/compiler/compiler/integers/i128/add.leo.out
index 030857833a..c83e1d2ec8 100644
--- a/tests/expectations/compiler/compiler/integers/i128/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1404
-      num_constraints: 1405
-      at: b738445f9fa8039b6d93543917f21faebabd70ce5f0fc95bc2b82f9a96653e78
-      bt: 7d12a27b02e7c965ac1775f6711d6da181ea2a809f8bf644ab1755929013f7e4
-      ct: e7b4e2f5a4e98c3a9016990ee3dd9bbf5e55e7a98e1dc3ac7d4b458ecdcdde7e
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 6034e46458c03b523ce65a652bc031b57afcbc68acea179ff8e44bbe5bcff61e
-    imports_resolved_ast: 0b0f9b493707ed1b625c187c66455cef5921ba296d71eeea22ab359dc8307d1f
-    canonicalized_ast: 0b0f9b493707ed1b625c187c66455cef5921ba296d71eeea22ab359dc8307d1f
-    type_inferenced_ast: d9f69bce638f3eb17f03d30dedc531bfa45de823877531c4ac0b404c5e84aa53
+  - output: []
+    initial_ast: 4ba3f688a429a73f874a1c391a591e7155a4722ff99c339d0814eb903b3265db
diff --git a/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out
index 7bcacc58f8..1c289fc9a0 100644
--- a/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out
@@ -2,18 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 511
-      num_constraints: 511
-      at: f130bde196ac7e190b505a42dfb30c41772c4c7eafe9e7203be9222892b767ce
-      bt: 7ac37b347f82644239128aa66e9caf34375b1fd860069659581477883d92fb7a
-      ct: 3e4c7833e73f9ee37e42c796e8af7a6d417a012b776b348abedbfd317110858d
-    output:
-      - input_file: i128.in
-        output:
-          registers: {}
-    initial_ast: 9ad8cfe49e90701d2c611dcabc3ee3b935e29fd0d0dae3824f8a382249daaaf6
-    imports_resolved_ast: 43ce18da004d1a1ddfe615d059cd847ed493f76190b3ab468597d137d94cec09
-    canonicalized_ast: 2180b2223a05b40e9a776f1075aa6c004af89d7a6114334272614a46894cc1a1
-    type_inferenced_ast: 034e65d40da9f8b49afb59eaec8220a03719a09e2a3b17554014eb918390526f
+  - output: []
+    initial_ast: 04f4837fea457bc8b7903f3127998e42bee7e36d49665a66beca315b3cc52427
diff --git a/tests/expectations/compiler/compiler/integers/i128/div.leo.out b/tests/expectations/compiler/compiler/integers/i128/div.leo.out
index 6322d3561a..55ff9cf3ab 100644
--- a/tests/expectations/compiler/compiler/integers/i128/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 264820
-      num_constraints: 330868
-      at: 90e89968758ed4552073b4217621741d7471a683f004aff63679ee176690ebb4
-      bt: a83224709a5d2ea9ba982fd81f35188e299590ab7ce201773857c54a39b27d93
-      ct: 26d5f56acb9effc130128af10b00b426d2396e7d8962636268b3dd08ba8df5e3
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 84c18747e64a1a09dc6b5b06967246347b3e38e78a4d4d9c1e95380766d062ba
-    imports_resolved_ast: 71eeef56b912a8e6088a228484e80d98e8a567e9e0203b3ae504457f914eaaed
-    canonicalized_ast: 71eeef56b912a8e6088a228484e80d98e8a567e9e0203b3ae504457f914eaaed
-    type_inferenced_ast: e0f6b00947eff709f6dfd80de777e15bed76fda1732395127b6710cbd9a7defb
+  - output: []
+    initial_ast: 22d811ec372bfcfa643f49485200451dc5fe2b928483cb9801cd10461100e3b1
diff --git a/tests/expectations/compiler/compiler/integers/i128/eq.leo.out b/tests/expectations/compiler/compiler/integers/i128/eq.leo.out
index 3acb409665..ef00d86cd3 100644
--- a/tests/expectations/compiler/compiler/integers/i128/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/eq.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 513
-      num_constraints: 513
-      at: 75b34d698fc2359df51943102062181aa5ee62b84a221747dfd7f8868bf48efd
-      bt: c1e085f0d8047bc5b5f574ca9de7d79a0ce3b3235e3bfb83ff15aecf05ad1323
-      ct: c224fec21cf5a2b24eb94033a20aeb4729d3d0cf596339145cb49ea6a44cc5d8
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 5b8836b42a69a418b1f0f3f55959616682ce695e0f41547120fd482575861678
-    imports_resolved_ast: 284635ff7125d7d7260051441431840b5e28cd8bb2563f5fe5c4e1aa1bc7b54e
-    canonicalized_ast: 284635ff7125d7d7260051441431840b5e28cd8bb2563f5fe5c4e1aa1bc7b54e
-    type_inferenced_ast: e04fa34f4a3d2730c9b94cb317afc4dab5376264ac6b9aa043453a7acfd69073
+  - output: []
+    initial_ast: da2b5ade996589a255e02d69a67f76814bb7ac0b0e685bf7e9776ceb4e0b9a7c
diff --git a/tests/expectations/compiler/compiler/integers/i128/ge.leo.out b/tests/expectations/compiler/compiler/integers/i128/ge.leo.out
index ae96d1e04e..3e1908472e 100644
--- a/tests/expectations/compiler/compiler/integers/i128/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/ge.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: 96f20d0620bc9136e98bfe583ce40c6ad4359d33c7bafe02d1e121e411b1df50
-      bt: bf4203445221fa42994f563865391d625b571513cf25a20cf465fbe26647ec5d
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: i128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: ee0b7f6fd6fd4f705e68084965585ecbdbc0f8eea502e2cfe8c3dfd92b7426e7
-    imports_resolved_ast: 34492e7460ef8d2463e1f5bfda5f60cb49a0f0abe86fe5be0bb5ba94ff25ee5f
-    canonicalized_ast: 34492e7460ef8d2463e1f5bfda5f60cb49a0f0abe86fe5be0bb5ba94ff25ee5f
-    type_inferenced_ast: 93347222970d5b687d1d392be338728e673c03fee2beef6cc9df42988c109315
+  - output: []
+    initial_ast: 8eba6b11f24d8570a20e459d8aab9622ea6a5ba7af9a694c2987a3b7fd9ebbbe
diff --git a/tests/expectations/compiler/compiler/integers/i128/gt.leo.out b/tests/expectations/compiler/compiler/integers/i128/gt.leo.out
index 49c5d162ff..29c74ceb12 100644
--- a/tests/expectations/compiler/compiler/integers/i128/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/gt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: 98a9cad46c764246288557ee4b5ded8e4f2ca8c99e07068d8e5cfef000e22e31
-      bt: 7734cf8efdd437cd881763da604d9524fca91092bda9b6fc677ff9c30fa4b3c7
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: i128_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 1ae3ca50d98602aa4dcca75215feeeaeca83c3ea6fa4a3f7a81c2587575c2fd5
-    imports_resolved_ast: 2fedd9cb4ad257ba301485cbbeb76b6a50c59d94376f0e9108c41550094811f1
-    canonicalized_ast: 2fedd9cb4ad257ba301485cbbeb76b6a50c59d94376f0e9108c41550094811f1
-    type_inferenced_ast: 4600bac734a533107314804a8b5664fd3976d33cc890a6a72e91ff5c55057ba8
+  - output: []
+    initial_ast: b8f337da7484c626ac9f36d2b2ef1b6d64a4c71c83fea6371fa8074580397f73
diff --git a/tests/expectations/compiler/compiler/integers/i128/le.leo.out b/tests/expectations/compiler/compiler/integers/i128/le.leo.out
index bcb965ab43..0f2779551b 100644
--- a/tests/expectations/compiler/compiler/integers/i128/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/le.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: e7341bd3736199176968e0d217b64de1913590fe3c69e32c4a398014df18f20f
-      bt: 78d5b43e2c7d048af797f16a430d0ce5b99f8305fb1dbd0c7a0a6f36cbd6b046
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: i128_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d75f1f5197239fea5c992f6e837f6b1659c8c0bbadad7d49846fca2332219549
-    imports_resolved_ast: 241b092d8611fa27a868cb351721822aa55645df2b1e587eac0bc008318d642e
-    canonicalized_ast: 241b092d8611fa27a868cb351721822aa55645df2b1e587eac0bc008318d642e
-    type_inferenced_ast: bda96fc9fd4bad06fcf502e83879a68fb01eaab8386a2cfafef27d427eecd604
+  - output: []
+    initial_ast: 565fed6c7ba818dd47e2623c8a1abb63d28ecb1a5038c076879fdf43dc908166
diff --git a/tests/expectations/compiler/compiler/integers/i128/lt.leo.out b/tests/expectations/compiler/compiler/integers/i128/lt.leo.out
index ce8586a6d6..6e6fd295e6 100644
--- a/tests/expectations/compiler/compiler/integers/i128/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: 9164a7c32351fa140180bb6aedc74fc291dde69bbff2b1e9c2191b3d155356dd
-      bt: 9a46d23879218b3aa9d5b6575fc677aca1f7470b3b4e623a26f410a38200661b
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: i128_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4cbaa69424d3ffdd2f98e1268414b0f2fff0616c82a5f3ae8141f16907ab0f05
-    imports_resolved_ast: 0ced04514468ff96b0c806fa758f066e5be577331d329f8e5b2e91d45ceed4e9
-    canonicalized_ast: 0ced04514468ff96b0c806fa758f066e5be577331d329f8e5b2e91d45ceed4e9
-    type_inferenced_ast: d5f6de9a8c5ebe0e3b15ee39e1b79eccfdca4c8483ec72b022ebe7a40c894606
+  - output: []
+    initial_ast: 7cb86efce158b9f000dc417a73bb2030617e38bc813f413bc36386fab0520406
diff --git a/tests/expectations/compiler/compiler/integers/i128/max.leo.out b/tests/expectations/compiler/compiler/integers/i128/max.leo.out
index 4422e22f1e..3e9186d952 100644
--- a/tests/expectations/compiler/compiler/integers/i128/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: dfd2116080ae00021bbe710cd430ce0787e7513dd5216c991094a7d74718c270
-    imports_resolved_ast: 41bc1f24ed123efa16903f481a6af0e55290c45ca5895acfed92e3cc5578bc9e
-    canonicalized_ast: 41bc1f24ed123efa16903f481a6af0e55290c45ca5895acfed92e3cc5578bc9e
-    type_inferenced_ast: ddab2e55e873db3490299850ab4c3d8670724519da384ad04f304d9d227f61be
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: f3ca97d86f57b944c4231dc0b69741a03effae440313f160eed441bb0daa4d37
+    initial_ast: 107fb1218c428388b2e1b713bf70d1f6094409c8cef3c43bf62a3f22297989f3
diff --git a/tests/expectations/compiler/compiler/integers/i128/min.leo.out b/tests/expectations/compiler/compiler/integers/i128/min.leo.out
index bf86573765..55295c1737 100644
--- a/tests/expectations/compiler/compiler/integers/i128/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 62a0e940523a1eb558134e9e79f6299650b288c6ebaa4915e9c909f4690cbad9
-    imports_resolved_ast: fd0ac331b476fada250afd3c28680854af0192cdc14b06d63527a8cce8be9abc
-    canonicalized_ast: fd0ac331b476fada250afd3c28680854af0192cdc14b06d63527a8cce8be9abc
-    type_inferenced_ast: 0e291d0831657249651e533987cf6e6584a6e8aeae0fa3144a0600f5bfd0ad9f
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 3fcab5bb182f20887ba91b5c07936bdc26f26aefcbcce901d9a9c32437b8770f
+    initial_ast: 1c9df75524411cf53c17b8d3e2a879b6caf9b46aeeabbe9681d251e4c1e66e21
diff --git a/tests/expectations/compiler/compiler/integers/i128/mul.leo.out b/tests/expectations/compiler/compiler/integers/i128/mul.leo.out
index c8b0d1db0e..dad6dc39be 100644
--- a/tests/expectations/compiler/compiler/integers/i128/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 393216
-      num_constraints: 393217
-      at: d5a0c9b374587e6c25f437a157bef0c152665743371172ba94d04e13a1a8f509
-      bt: 2d0600e403e694d114c452c3e5c1ad2137e48b5344b3760dbec2e826420b8a9e
-      ct: 76b519a48f8267fa180bc68f3e7a84fe7319a3ad2e76338916cb399d9cea22d8
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: afd28dda487ee76e68423a2920cfda3442787bea37f98bae0dc65e10e0a06f98
-    imports_resolved_ast: 4dcb6f9ac89f8f3e0287f2e435cd5bdfd62372f45f5ae1a4ffd6bca9f381f556
-    canonicalized_ast: 4dcb6f9ac89f8f3e0287f2e435cd5bdfd62372f45f5ae1a4ffd6bca9f381f556
-    type_inferenced_ast: d3280b6ef4a324c14e2116f157fe0176534d5f5fc892355c54091bb407cb0d02
+  - output: []
+    initial_ast: 58d78b11cee52cae54a5684cccaf0569c9788f8c2af0e51d18bae25004246a58
diff --git a/tests/expectations/compiler/compiler/integers/i128/ne.leo.out b/tests/expectations/compiler/compiler/integers/i128/ne.leo.out
index df22039d2b..826e325a46 100644
--- a/tests/expectations/compiler/compiler/integers/i128/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/ne.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 513
-      num_constraints: 513
-      at: 8f9d3ef916a970cb762ca6f3829a8b4897dc65d493a2ea2eb4fa812a2062fe67
-      bt: edc1de9388a8bb2c659c9b4e9deecd8406826abcfe220d295bf7d85a550c0c43
-      ct: c224fec21cf5a2b24eb94033a20aeb4729d3d0cf596339145cb49ea6a44cc5d8
-    output:
-      - input_file: i128_ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: f909a4b98fa5f8c422c25bfa4485281f9691a0c193803c442af9633e6f736a12
-    imports_resolved_ast: b9cc37e7790a5b6acb6b98a569371865d6ea9fd06dc1ac04106ff345eec2a192
-    canonicalized_ast: b9cc37e7790a5b6acb6b98a569371865d6ea9fd06dc1ac04106ff345eec2a192
-    type_inferenced_ast: 41fc4c4007ea1c31f3053c314175de037b78f23f0edf881503227722d1e785d6
+  - output: []
+    initial_ast: 5d8779407cc50f3e981e519370b2c0a3a73037572c8e35fc19b4dd421eee3d44
diff --git a/tests/expectations/compiler/compiler/integers/i128/negate.leo.out b/tests/expectations/compiler/compiler/integers/i128/negate.leo.out
index ac2709d8b9..ffc3338d54 100644
--- a/tests/expectations/compiler/compiler/integers/i128/negate.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/negate.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 765
-      num_constraints: 765
-      at: 46af0432868923f7cad6e7db2de33a69ccad1a789e92d552ec26f8fc19a7d33d
-      bt: f1167d856668e1efcd49f020430a704e62ad6e46006e7faf58acdac8bb8a5ba2
-      ct: 075f6359a5dd933b671b42c06465f4c70f5ec152176c234fb4d3cdfbe6255daf
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 8b068086883db13819b6efd8628f5bc09eababff85065acc4eecf4140eb0c551
-    imports_resolved_ast: d6f4b8d96e9eaf7abb34193fc2dfb0ed26eacfa8a054ff617f6d63cc572c27d7
-    canonicalized_ast: d6f4b8d96e9eaf7abb34193fc2dfb0ed26eacfa8a054ff617f6d63cc572c27d7
-    type_inferenced_ast: ef1e57c07da313c5da529f929c1fb541b069bc0d00e7abf606faf2164ebbe43a
+  - output: []
+    initial_ast: 26273053686377beb2d82077eadc49db45ca8b5bc24df8b9515182b998421cb9
diff --git a/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out
index 47b10180ba..352db96b08 100644
--- a/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4fe155558501b42818f65f8e4a4afd0492a67be902c6cc818a05d423a9e9d13e
-    imports_resolved_ast: 86d46c81ec2766f019c83cdd853037e841798e342ffbec5caf1d5ef541808f97
-    canonicalized_ast: 86d46c81ec2766f019c83cdd853037e841798e342ffbec5caf1d5ef541808f97
-    type_inferenced_ast: 76f7439f6d914f701aa70b26d5448db0f5919ad681774da2b5eefbda7426482a
+  - output: []
+    initial_ast: 528c451e9e0700c2d8f73b8281c28ce11dfb04663786922a18e200f2267ca80d
diff --git a/tests/expectations/compiler/compiler/integers/i128/sub.leo.out b/tests/expectations/compiler/compiler/integers/i128/sub.leo.out
index 6bf5fa791f..9e5e78c417 100644
--- a/tests/expectations/compiler/compiler/integers/i128/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1658
-      num_constraints: 1659
-      at: bb46c735f0d1698aa6cf8637b23babcdf0df3ec6e64f4b2e7d3e86f6f461e961
-      bt: 859297637693ebdf41005288cf212906c1d7619049b4305d34d9dededb24b5c5
-      ct: 50293f70acfe4a8aadffa8b17c18b0411493c8760fc474dcdf26f5bc7d70ada4
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 95a992f9baa8ae05f61ec38f6d21a9e89f819995f1a83419841f06e280f690d5
-    imports_resolved_ast: ef4d9e2ed70f25e499fe342442189e5bb6f8ad52ce8fedade9e12cd0a97b06e6
-    canonicalized_ast: ef4d9e2ed70f25e499fe342442189e5bb6f8ad52ce8fedade9e12cd0a97b06e6
-    type_inferenced_ast: d3b2effd142a931373677f62eba3e179791178b6c7bdd34071054e80e7e39f19
+  - output: []
+    initial_ast: 656588e753eb72edb9e3bde30e16df4fd81fc101eb8ccf9bfe572d5166e9b056
diff --git a/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out
index 7bf262b5cd..6a18a92bf2 100644
--- a/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 896
-      num_constraints: 1024
-      at: 0830a3e788b536b36f271fadaadcc919281b2171d4e18814385b74f6820cb5c9
-      bt: 1fb9bfc22c01a54c08602e7f3883c19b00de1070aa9bad9e9234e322f9043711
-      ct: ee9facabe4c76f5eb89984d3c5cb15f92eaa0cc3b4bc4fdff261aeb36ad0101b
-    output:
-      - input_file: i128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i128_rev.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 3b42fdbc16215a5c0e3eab7631532dda76c0a0e70dcb5c371728110490c04b3f
-    imports_resolved_ast: 4bdaf4198b69c9c74cb8b2a6c7f55620bf1170feb86bae7a6facc4a2e7557aa9
-    canonicalized_ast: 4bdaf4198b69c9c74cb8b2a6c7f55620bf1170feb86bae7a6facc4a2e7557aa9
-    type_inferenced_ast: f42af0eb2d23891c0ab9cfc58353414fed8370278868fe5224b8a3b56583c7fe
+  - output: []
+    initial_ast: 6ad007a9081030e9b3664f92e25c8c0f21903eef6dc6cd567254092d174a1b6b
diff --git a/tests/expectations/compiler/compiler/integers/i16/add.leo.out b/tests/expectations/compiler/compiler/integers/i16/add.leo.out
index ae7ca47f08..39aec1774a 100644
--- a/tests/expectations/compiler/compiler/integers/i16/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 172
-      num_constraints: 173
-      at: 6b89cd61c27d609100734788caaf250a61c4e65e8bb53a70cb9a67bd3970d344
-      bt: 3685748e2150def12598827c6d3217b7665ad912fcf517afafed7dd933dd68a2
-      ct: acefb38d2e822ba8454f989fcdcfad22e9c15b0115cebecf3ec7f842412b0812
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 99f96607c14de0fce0813cad8cd9e84653ba8fe288b109bd0e9001adaf5d82c1
-    imports_resolved_ast: dc1dbe71dc3b1e019851331b75c96751543c88b65a17429b53da6bc5feb1fb3a
-    canonicalized_ast: dc1dbe71dc3b1e019851331b75c96751543c88b65a17429b53da6bc5feb1fb3a
-    type_inferenced_ast: 887e275be95e7291f9acafcea8e2d14871cebe50c671be7978ad54120e26ef4a
+  - output: []
+    initial_ast: 9ebcf93a3a1c925cbda80ad0a4f715a975500a8a08698ef25e8c980bc5c074fc
diff --git a/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out
index d37b1d81e5..429bb19db9 100644
--- a/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out
@@ -2,18 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 63
-      num_constraints: 63
-      at: 781fbf42db29f7fa9c21d99e21d8f011ec22b33ad26d3f80438687aafd462285
-      bt: abee7b67c55170fc3341444203a9a70e68690dce751aa36d3e91f1cf7ceef73d
-      ct: 51c18ee4216feeb01d0b0d661dfeb294e7e100873586edf79be89c8b54d9e168
-    output:
-      - input_file: i16.in
-        output:
-          registers: {}
-    initial_ast: e8362061274eedee498ed14c69d5b9de596a036962cb442fd5a4aab49696399c
-    imports_resolved_ast: f30e735f5103336e1f3f474190ff3c6a47b761863ca7bae71d6aa6a08092a70c
-    canonicalized_ast: fb3b4c2c850bb43869348b440f896cf3112578fb7aca1fd3870e90eefc31cbdd
-    type_inferenced_ast: 7555df3659bd5172d1397c9116111090c7fd449faa8b80a79ee1e7bae934a332
+  - output: []
+    initial_ast: dffc9c5f763636aadaeb4ccf27b66f91ddb298ded717e90de09e8fd48f61a29e
diff --git a/tests/expectations/compiler/compiler/integers/i16/div.leo.out b/tests/expectations/compiler/compiler/integers/i16/div.leo.out
index 30431d8b1b..30398ca36c 100644
--- a/tests/expectations/compiler/compiler/integers/i16/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 4358
-      num_constraints: 5446
-      at: 285c49252166e044a1648d7cdeaa3975efca0e746efd365d2f170900157df8b9
-      bt: b7dcf6f446108df31801263f54f0d504800d85f341baa945f13eb2dbbbbe4851
-      ct: 6743f276428e33d909885898f76d747836254decaf153021c75df8d62b890e41
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 7756afceadfc7fa1dc9afab299d27601551ac69b297fd9a223226ddfb753a020
-    imports_resolved_ast: 61bcd95ca9c803ddf141cc2e738ccdb94205c819dc2a607364bddf879522ff5d
-    canonicalized_ast: 61bcd95ca9c803ddf141cc2e738ccdb94205c819dc2a607364bddf879522ff5d
-    type_inferenced_ast: 53f823da78e8717691e1e50984326ee995c287b3c96d93a291ee22236c3f175d
+  - output: []
+    initial_ast: 69e960fb1923255efda2ba99dc07c01cd2e8d38cbf63363f7112f9c4e9efc768
diff --git a/tests/expectations/compiler/compiler/integers/i16/eq.leo.out b/tests/expectations/compiler/compiler/integers/i16/eq.leo.out
index 10aca7e07e..3dba06bbf8 100644
--- a/tests/expectations/compiler/compiler/integers/i16/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/eq.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 65
-      num_constraints: 65
-      at: 8c8b795ef4142f2651625b90b3624d24de5138c3fb0981288a8cc5e12bf31f82
-      bt: eba2113bdda3d667d9e8c87f545fe4e2a0143b18a3fff0c1aaa46dd376ed1735
-      ct: f037d279ccea3ca689e05801ec3ba0053b5ce66a1763d4620262ea9b69873008
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e3cc75ff118c1332194bf933cf9ee2d416c9e5ed11566e7d3f3bfd34446ad70b
-    imports_resolved_ast: 1d5cb688ec58ebfccab6483b1b148d2958d8f4cfa4264c403a3073a887a2b446
-    canonicalized_ast: 1d5cb688ec58ebfccab6483b1b148d2958d8f4cfa4264c403a3073a887a2b446
-    type_inferenced_ast: 8a2e833a9cee516de296cfc8b6fb5ca73250c6a508705f745a3310a49ba4cdeb
+  - output: []
+    initial_ast: a6cb462814fae8bb80601fdc772c4ba3831c35b069b235e01f1ad8fe857d879d
diff --git a/tests/expectations/compiler/compiler/integers/i16/ge.leo.out b/tests/expectations/compiler/compiler/integers/i16/ge.leo.out
index 6f849bdb9d..79985ce6a0 100644
--- a/tests/expectations/compiler/compiler/integers/i16/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/ge.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: aacaa02fab172aad56801a9785e4265f42a5b7a8a90f3277508d9bdf9b71739e
-      bt: dc20f75204b1fb858e1971441f24a4aa1780e545581c55ff3d52cec41be65b79
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: i16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 71d93023a409ba4ce05685f7f02c994d17690e2fcced5dcf1f9fb3e6418a509b
-    imports_resolved_ast: c366e2b45215eb2a95fe3f0f655f569da6e03c86bc577550dacfc05d70f3d33d
-    canonicalized_ast: c366e2b45215eb2a95fe3f0f655f569da6e03c86bc577550dacfc05d70f3d33d
-    type_inferenced_ast: c59992698eb83b75604521bc83c1e21a48077a65584e1b58a33f2971906048e5
+  - output: []
+    initial_ast: 5351c113c7e45be9e1ce080daaa2f8c8944d9cc551146e0da6bbfae5eb69ed01
diff --git a/tests/expectations/compiler/compiler/integers/i16/gt.leo.out b/tests/expectations/compiler/compiler/integers/i16/gt.leo.out
index 60448b0ac5..347881b7aa 100644
--- a/tests/expectations/compiler/compiler/integers/i16/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/gt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: 5c1bf4b2c0dcee44497206b68fafb1e2e98bc020688d260da3730723c0c90dd8
-      bt: 07da85fcfccc58758d043e27b0aab5a749760c644824684c13befde258deb78c
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: i16_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: abaf30eaa93168e2278ad57b590f35a40305c381c4f960f4e5250be97f36c3ba
-    imports_resolved_ast: bf30f06fe2b71dfc9003637ea777a6d9c167e3c0463f0e23129652a430818b41
-    canonicalized_ast: bf30f06fe2b71dfc9003637ea777a6d9c167e3c0463f0e23129652a430818b41
-    type_inferenced_ast: bbeecdd0ee1d6f63ca5bb2ad65c123fd78c5f6720d257a64c2f2f869bbcff23f
+  - output: []
+    initial_ast: 31949f3b3950c34aadb02b7220d0b9ef6f088fc14bc9496ff1649d7dd3c44347
diff --git a/tests/expectations/compiler/compiler/integers/i16/le.leo.out b/tests/expectations/compiler/compiler/integers/i16/le.leo.out
index 5c2dbdc27d..a2d67d81fb 100644
--- a/tests/expectations/compiler/compiler/integers/i16/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/le.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: a38a17fb5f40313343215b604602dfb492eb06cc8ac81d7d75443663398eb105
-      bt: 34c1c5f1fd258fc5f18137e0cd367a6c3149958ec8b92123518e293db31afbe3
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: i16_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: f88584dc5972b47adff02db485e2ed1cbd0543920b8bddc81825f78858abe7c8
-    imports_resolved_ast: aff8e32cea55a795d5cb6e75ac699d64b8efbf8b56b05c426fb9a02d39cab638
-    canonicalized_ast: aff8e32cea55a795d5cb6e75ac699d64b8efbf8b56b05c426fb9a02d39cab638
-    type_inferenced_ast: e56aed4642b5ef4a01fd4c081a84f5fc375e5729abbc8dd7a1445bff7294799f
+  - output: []
+    initial_ast: fcb3b9db14c713d885ec37a40aca86d034f1d12e85b22d103a20b7e181848e73
diff --git a/tests/expectations/compiler/compiler/integers/i16/lt.leo.out b/tests/expectations/compiler/compiler/integers/i16/lt.leo.out
index a835e60f22..21ec865033 100644
--- a/tests/expectations/compiler/compiler/integers/i16/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: 882216b2b7d92dafe18a2ba6eefed789ba0084c92957772d0b1e3797ac391d8f
-      bt: 564588048812d9300963caf70148f154c231faa3209aed2ee5f9dd51a31af0ef
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: i16_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: cda07fb1513a03d04a2d3292755c983e8d88dafa79ab0b0fef4d16a3fe8afb5b
-    imports_resolved_ast: fd280f73552a8c4124bd29955251c327a3932e8459532b86ba99fe5425bfe8ca
-    canonicalized_ast: fd280f73552a8c4124bd29955251c327a3932e8459532b86ba99fe5425bfe8ca
-    type_inferenced_ast: 3478c50e629b52f5aeee33321a83cf1000f2fe1bb556140b351cdbb4142553fc
+  - output: []
+    initial_ast: 0058f607e4e76d621419f0378ced319e9bb7228e0af27793bb44f433369c23c3
diff --git a/tests/expectations/compiler/compiler/integers/i16/max.leo.out b/tests/expectations/compiler/compiler/integers/i16/max.leo.out
index e524a16212..cd12e881be 100644
--- a/tests/expectations/compiler/compiler/integers/i16/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: ba7bfe3ce062ce779f8c5f5d61418493a3a2f80a4ac30340f220d71b41b6b39c
-    imports_resolved_ast: 0fe889ab132710a23334db606472bdae6b3ff34d2bf681af85aba7e062e6455d
-    canonicalized_ast: 0fe889ab132710a23334db606472bdae6b3ff34d2bf681af85aba7e062e6455d
-    type_inferenced_ast: 07e923fee2cc01fdab28ecc90382e7dbc334d8045eea0a66a86f29e5d31606ce
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 02a03bd789d65f3fdf169614383ffb75c91552cf605371c6b9911d71e8af847c
+    initial_ast: 4483b50dc6ddcc0b0335aa19ba2eb01397005bf0a921d62bed0c5ec35d9a0e20
diff --git a/tests/expectations/compiler/compiler/integers/i16/min.leo.out b/tests/expectations/compiler/compiler/integers/i16/min.leo.out
index 4e7c5fddbf..489567e9e2 100644
--- a/tests/expectations/compiler/compiler/integers/i16/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b9611f22206d9b705c34836cffee572fcdb2e8c5ccd90e849a59f8adce458a9b
-    imports_resolved_ast: 8da6b2eda68cc06f39dd136e5c86e5849be8b81b5efb314f5b2f92c7a5ea6232
-    canonicalized_ast: 8da6b2eda68cc06f39dd136e5c86e5849be8b81b5efb314f5b2f92c7a5ea6232
-    type_inferenced_ast: 80ee1d0aff494fd6dc62ef54cdc3efb1ad3db8420a57853843b0f0bbb89a682f
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 3694da9bbe8a47ac5735ccc5678eaea27ef70acd77d772dde2631f00656a58f1
+    initial_ast: 58d7dbc3db636edf6a92ecce907f3930f9908136e7bee11c05ca4fd82ce51789
diff --git a/tests/expectations/compiler/compiler/integers/i16/mul.leo.out b/tests/expectations/compiler/compiler/integers/i16/mul.leo.out
index b34360d077..465a8df148 100644
--- a/tests/expectations/compiler/compiler/integers/i16/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 6144
-      num_constraints: 6145
-      at: a82b875e925052eba2aa8b33aaa6a654c144148e94e18bbe9649dcdd1fc0ad71
-      bt: cd23bca179b84ca9238460e8de4ec0c0afdc0ce1e3d6669329fc4baf08e7e0db
-      ct: f60e073d0353b71ab07769daa585ce03799bb2f4095a0dda5f9009b4f42162ed
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d62af4365da48b13e9df51f8b7a3b8b3f609ab764b415bb99a094ea1a8fc7a2e
-    imports_resolved_ast: 0cda3017d008096b443c02b8c8e491bd1b91c9f1f487d8486a369adbadf41287
-    canonicalized_ast: 0cda3017d008096b443c02b8c8e491bd1b91c9f1f487d8486a369adbadf41287
-    type_inferenced_ast: b6f3b0f420a47508fe624ff37fc5640350a7f8d564c6fba2b7f6d247b7ddcaa8
+  - output: []
+    initial_ast: 7a0a6c7ece2f9c1a51f97c6a71b8c60a527329c30a3957185c2bc53b2fc00001
diff --git a/tests/expectations/compiler/compiler/integers/i16/ne.leo.out b/tests/expectations/compiler/compiler/integers/i16/ne.leo.out
index 319c29b936..39a977291b 100644
--- a/tests/expectations/compiler/compiler/integers/i16/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/ne.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 65
-      num_constraints: 65
-      at: 83a4d089927a9811a9d4ed5b3ee2e50e395cd598de865653be04a2c51904b072
-      bt: 30bc7cfbc53a2e928ca0310b6041f1f1548ad7c1197ffc9301b46522122e5561
-      ct: f037d279ccea3ca689e05801ec3ba0053b5ce66a1763d4620262ea9b69873008
-    output:
-      - input_file: i16_ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: ab347fb23adc7386d049a372c97636bf7ad8379e4212401feb2af3e9aba9ee9b
-    imports_resolved_ast: d9278f9252b3bdbbb88c2af4a1aa1d969524a99db8f126c312e781a9dcee19cd
-    canonicalized_ast: d9278f9252b3bdbbb88c2af4a1aa1d969524a99db8f126c312e781a9dcee19cd
-    type_inferenced_ast: 32585f870fcc610d1d54794b2a1487159d532e691839b24d0e026ca3f4003635
+  - output: []
+    initial_ast: 571a0fb0e0122a7ecb2f631c44fd426c4b165d3610d81481fb395a3391175897
diff --git a/tests/expectations/compiler/compiler/integers/i16/negate.leo.out b/tests/expectations/compiler/compiler/integers/i16/negate.leo.out
index dacfe394cf..e443c3d4d9 100644
--- a/tests/expectations/compiler/compiler/integers/i16/negate.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/negate.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 93
-      num_constraints: 93
-      at: 29988ea86584610f4511315204ed49c45d0303c44e0fb59c0df19dc048cee369
-      bt: 9bba1722080b8c396e72a645c5ca7dff2943c0b29a741569acdba3887e40c8af
-      ct: 4f89ea4838bc4544e2767b7dc68a1e0fa0649d7401bb7ae8292bd6aa654eda28
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 14634c6a1f222f0b83d91a1d95124a718ae34e4bd2109bae5fbfbf68bc2ee886
-    imports_resolved_ast: fd9397c59e2639310f0de7f048d81e60fd839e8d20acc552c15af7b5eadeb7ec
-    canonicalized_ast: fd9397c59e2639310f0de7f048d81e60fd839e8d20acc552c15af7b5eadeb7ec
-    type_inferenced_ast: b74e7e036d01b01cc6d16201b20cf07aefb2d9d025be6f200234d0ba9a330e38
+  - output: []
+    initial_ast: 06c7e204e308b875e2e027bf9a98e175aea8140a6af146562343fa19dd5b0f44
diff --git a/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out
index 0e23b4cfc6..309a943a71 100644
--- a/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b3f714fb9e373dd75f75d07945f8ba3e62362d4b3ac8d5013554a3f46c2cbb4c
-    imports_resolved_ast: 6f4f21e3271f6b8a4db73fb3096fc9b1e83148464fe78177f11cf63b5f20881d
-    canonicalized_ast: 6f4f21e3271f6b8a4db73fb3096fc9b1e83148464fe78177f11cf63b5f20881d
-    type_inferenced_ast: af9335ce25e82348e7f8261ec93befca9574b1ee056eac9666feba6436551086
+  - output: []
+    initial_ast: 1e78dafdd49c39aa74bdd491b4511bfbb257c6499e18707612660cc63e700213
diff --git a/tests/expectations/compiler/compiler/integers/i16/sub.leo.out b/tests/expectations/compiler/compiler/integers/i16/sub.leo.out
index 8b889e46e8..afd095888b 100644
--- a/tests/expectations/compiler/compiler/integers/i16/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 202
-      num_constraints: 203
-      at: 7b1b870d629fe64b117f0be092b7336e6b4149ac6778d0f4d02273e0c2b59a2a
-      bt: 035e3e8f741942f4683b2262c8f0fc75c0c5a89252c069ed956abce34019b988
-      ct: cd38769a0ae3aefd48815d80555886d23370399b29596b8433ad23be67afc55f
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 00919354c09e704c845bdfddd56834f44235ef24c1ce44f5651bc892c6a11c86
-    imports_resolved_ast: 8bcd351f4dc60aa26755a094604468baee22cc5ab5d7e4059b00f2ecc88ff85e
-    canonicalized_ast: 8bcd351f4dc60aa26755a094604468baee22cc5ab5d7e4059b00f2ecc88ff85e
-    type_inferenced_ast: b35c8407548a49b7da95b7c442639da750c4e8d58b78dbedc6559e0b15b6ea88
+  - output: []
+    initial_ast: f384f22efa0623afef6b74e89df6e2e238aea9bc84a9d422c1ac7f8ff567fd38
diff --git a/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out
index d4fa8a8bb9..d50bfeee7c 100644
--- a/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 112
-      num_constraints: 128
-      at: b0a107f586de648c8446ae3246117de3b20ba9c0249d261f234106809d112f0a
-      bt: 0e5faacb5d80488eeda9e7fa79ddd96e54c010e0e98571449f79cad816cc18a2
-      ct: 2b3428d7c7335edc32ab219fe11c92e215d70a52c89434de349f4951561d5795
-    output:
-      - input_file: i16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i16_rev.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 39f44e1206b330ac89617df226f2d3b9317214cf976689c6cc6f16e46a7a966d
-    imports_resolved_ast: 462ca17ca9eeb151f3ac567148ee8906555ebf15a52f124673b0eccc6d9a2e95
-    canonicalized_ast: 462ca17ca9eeb151f3ac567148ee8906555ebf15a52f124673b0eccc6d9a2e95
-    type_inferenced_ast: b0960a45a74143df7b8af02f70c7e0aff3cccc24c669a6b1c10d940fd4e9f172
+  - output: []
+    initial_ast: 062bd0e314de8e322f80a370fac6f2f23d8cad39581327ff0997c328793ecc64
diff --git a/tests/expectations/compiler/compiler/integers/i32/add.leo.out b/tests/expectations/compiler/compiler/integers/i32/add.leo.out
index 925da202d8..918782d562 100644
--- a/tests/expectations/compiler/compiler/integers/i32/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 348
-      num_constraints: 349
-      at: 2fe67b488b0f96f2f6be7e96dc7f102984b0132232e452f44e40cad21a1dc5f3
-      bt: 8dd304125c8178327f11b0894be2788080258a5a80aab3c1df046fea9f262789
-      ct: 8b73986e71edfc8b716f535eaa069b04cc15502adbd166ae713df42cb9d37a3c
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 625094bfb91d344d53609a8599b1da8496164ff42f888d30694cbe88cfc6ad64
-    imports_resolved_ast: acba46220d4bf574b5cadcd08c5e706ba836a1f5ea60909264f2671dd9ba1ddf
-    canonicalized_ast: acba46220d4bf574b5cadcd08c5e706ba836a1f5ea60909264f2671dd9ba1ddf
-    type_inferenced_ast: 47c211d717f70ef018a319b7b983d2294c214019da2ae8f536269016b3d51c99
+  - output: []
+    initial_ast: cf9129f53ff9903788b6c1dc51f1068af87f29e6ba40694f24648ef5c5e147b6
diff --git a/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out
index ad3625486f..d89e19ae97 100644
--- a/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out
@@ -2,18 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 127
-      num_constraints: 127
-      at: 051151c1ab89f2c0ff0fe5d336668c3fcd6dc4744d1f5b8e135dcb7bf6a6195c
-      bt: 6b92443726163ac0fc32f7c9edace0ec8369e793d24105d93d121cb0bd5c3128
-      ct: 7cb2d3f0ccfb9a2e747c6a05bdb52812c4539c836ff62c4e555fac13ef2084d4
-    output:
-      - input_file: i32.in
-        output:
-          registers: {}
-    initial_ast: 35901da0284aa67e84c2528297159dad9f35703579cfb9f84eeee7203de63454
-    imports_resolved_ast: 633371d562e45789e5d5fb1b2b03d509a387335be8ec6f7f3c4e07fce84326e2
-    canonicalized_ast: 42f4bd4729d2e23dfd1e5d243eeab2071149991087a55d26e5792c4ace943a58
-    type_inferenced_ast: 324ca8d20b5b654a896ebab2e3cebaf94e11a6b5f356db56413eb36798796a00
+  - output: []
+    initial_ast: 9e7038db9098b5bf35b833d84df26e3669094c94f59b72fe64593ac56623ac24
diff --git a/tests/expectations/compiler/compiler/integers/i32/div.leo.out b/tests/expectations/compiler/compiler/integers/i32/div.leo.out
index 55c61155bd..6827442baa 100644
--- a/tests/expectations/compiler/compiler/integers/i32/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 16918
-      num_constraints: 21142
-      at: a8ca22c0da8166ef4f88e959be315231681516ee6113dff620637774f8e4a670
-      bt: e09097be6926888dddac4cd61c1b3419e05b5b700ba3acca116f6eb2c01cb0a4
-      ct: 13922ea4b7763c9228f5dfedfb0d8e2f7d5a3bbed934cd6df5ae99f4150222d2
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 3cbf5acf0dc46b596e1d850503f6e55123384c70732e066dd741e909011b441e
-    imports_resolved_ast: 9d41a244e54b2eeeb436c53940a62ba25a25d6a798cb608ccf1aabb944006bd1
-    canonicalized_ast: 9d41a244e54b2eeeb436c53940a62ba25a25d6a798cb608ccf1aabb944006bd1
-    type_inferenced_ast: 9d7cad43ee246163c3473dc29e47d2ecdaaf1a81fd157ef451b4811b9036f18e
+  - output: []
+    initial_ast: a163bed0fb5969ce86f5ee3f27097c710163519a79148e06354a7ae52f598687
diff --git a/tests/expectations/compiler/compiler/integers/i32/eq.leo.out b/tests/expectations/compiler/compiler/integers/i32/eq.leo.out
index ed94e18334..abede25243 100644
--- a/tests/expectations/compiler/compiler/integers/i32/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/eq.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 129
-      num_constraints: 129
-      at: 4ce4f2bf481c4f7e47396527999e129066d1f157413884f91ced3d2b525a3187
-      bt: e63628fc48d1e71ea44830c010e442f577239e29f7ffada0d8df34c28e67f107
-      ct: 9f4c72431c0c7c03e216195a071c971c53deed8e3bfce450bffb3a6fad7418d5
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e43a183197d03e486808de7216e96005515d88e76b0b7b7a4bb7f61a522535fa
-    imports_resolved_ast: d2c893cd8efdf6f7faee35e46ff09a52d24c46e546369c9d82880111bc43d4fe
-    canonicalized_ast: d2c893cd8efdf6f7faee35e46ff09a52d24c46e546369c9d82880111bc43d4fe
-    type_inferenced_ast: ff21b0c65b0bdaf5d27f2d3e7cf5964ab055f5a042357a000cfcc82c48874f5d
+  - output: []
+    initial_ast: ba62f96d9796deebf5cb8c68abe3265e0a0352a6ba500b3197a43ebc19436606
diff --git a/tests/expectations/compiler/compiler/integers/i32/ge.leo.out b/tests/expectations/compiler/compiler/integers/i32/ge.leo.out
index 9636f67585..044bcd730e 100644
--- a/tests/expectations/compiler/compiler/integers/i32/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/ge.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: fba74e6ed7ae0c0cf0bd2c874940e7e9daf6c7c4e08cf9359b31279433ec0ef5
-      bt: 3f23038cdf71876dea48b44b9cae993b3f649b628bcdaf6f1cb77bbafa92b600
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: i32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b0ab554f622a5c76f28a2a777a009a01b24c9fb665f801b2468b57b75e3a46e2
-    imports_resolved_ast: 464ad4da3fa21aea98ea10fce4018fa0f51ffa88ba3bd171159d1a49cb8ad2bc
-    canonicalized_ast: 464ad4da3fa21aea98ea10fce4018fa0f51ffa88ba3bd171159d1a49cb8ad2bc
-    type_inferenced_ast: a789cd193bedf2c5fcaab2d7ddd2a6600b90f5dc7a30349da91c739a25899764
+  - output: []
+    initial_ast: 0917cf6662e2ab5b494a69c4141fc78a4c581fdbf5454bb50c176a09e06da902
diff --git a/tests/expectations/compiler/compiler/integers/i32/gt.leo.out b/tests/expectations/compiler/compiler/integers/i32/gt.leo.out
index ffe4705ea9..565122874d 100644
--- a/tests/expectations/compiler/compiler/integers/i32/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/gt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: fec1628688d454ab244e921b74f7f70ff6c7acf18280488dfb43cd0bb4bd70d2
-      bt: 02fd44d092923c1a89fc492a9660926934e03005d8c3fa5f42ae2a3fbd7048ea
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: i32_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 9ce39e6f7f121e21120326e36451f2ca7e88607a2c4ae92e3a60f93bc2c67d18
-    imports_resolved_ast: eef4fbedb52615283d4bd44a3d7d83506b0c8e999310a4ad3426dbc0c8eb6385
-    canonicalized_ast: eef4fbedb52615283d4bd44a3d7d83506b0c8e999310a4ad3426dbc0c8eb6385
-    type_inferenced_ast: dfc0c88a083d36146aa4140bdf2f822b6882898665bb01c94d4ac416ac057ac8
+  - output: []
+    initial_ast: 2173bf8f6a793f208d79405952c3181a946b32cba0e9e83fb904b90f60c97c68
diff --git a/tests/expectations/compiler/compiler/integers/i32/le.leo.out b/tests/expectations/compiler/compiler/integers/i32/le.leo.out
index ed9d7de177..528e5fd2ed 100644
--- a/tests/expectations/compiler/compiler/integers/i32/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/le.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: 39f909848aee2ee744719f8692f58b9745aeaeededc431f1b06df839384bff07
-      bt: 4e75a3c5fd91239e6bf32d96c6a4a702e040e4a3bddcc282706ca76facb9e942
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: i32_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 5b9f03e7a6a01e5c744b765869cddacc6c37a675c09684d44966de47f58e8c18
-    imports_resolved_ast: 95c493e4807d9a45ded8d4aaf04e18a5aa6a53d3383efe12b5218d3f9e7d0fde
-    canonicalized_ast: 95c493e4807d9a45ded8d4aaf04e18a5aa6a53d3383efe12b5218d3f9e7d0fde
-    type_inferenced_ast: 71341b2152c00ed871849be705b76d7808788d5a5601b88c7de5c4a72fa90f0f
+  - output: []
+    initial_ast: b7a7ca7db84356eb19aa638e3b451da11b4a625b7d250e2de55126c07afadd5a
diff --git a/tests/expectations/compiler/compiler/integers/i32/lt.leo.out b/tests/expectations/compiler/compiler/integers/i32/lt.leo.out
index a664435713..58779d362e 100644
--- a/tests/expectations/compiler/compiler/integers/i32/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: fcca8f94beb99b6f86edd3f8c36b81043482e6c449fc4278d53d546c295810ed
-      bt: 26e3dae4bf8fe37424b8ef7cc60b6136809286a8e64736e63b8b5dfacf774c21
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: i32_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d48f145cc263cc87999654deddaad46e50cd97b5b5c6f7c22cd2a3f72b288bd9
-    imports_resolved_ast: de4f7b1e75f65f649bec62b91000bc977f1585584b8d8add93d0086acd719561
-    canonicalized_ast: de4f7b1e75f65f649bec62b91000bc977f1585584b8d8add93d0086acd719561
-    type_inferenced_ast: 6a52fcf2ee7c3f6034bf01d073407cc239f4dca550b296f81482a5abc6ac0521
+  - output: []
+    initial_ast: 438315810d75e57e5fb24c9ff2526ccf6eeeefaf98216162aaf9d5ef7b845585
diff --git a/tests/expectations/compiler/compiler/integers/i32/max.leo.out b/tests/expectations/compiler/compiler/integers/i32/max.leo.out
index cb0aaa3323..e421b0a642 100644
--- a/tests/expectations/compiler/compiler/integers/i32/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: c69817689712c1263d087639fc0eae160c400b7d66894c86545d6fbffc38b498
-    imports_resolved_ast: c4fa3b1bee50c7ea67e32c9ccbb7123fa53c13c9481d9f74845edce613cc34c5
-    canonicalized_ast: c4fa3b1bee50c7ea67e32c9ccbb7123fa53c13c9481d9f74845edce613cc34c5
-    type_inferenced_ast: 81aa09e40277fc47b0207d619ce259358f644dbfd6d7833c9e1dfa59065acac3
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: f7aef2ca0d768609e83ed03418e4cc7ce6114516d4adeb3b0a516b7cb85a984c
+    initial_ast: 75355c3c6f8e1fde6d8c9600170d912560351c5442cb033427ec4aaa1acefc56
diff --git a/tests/expectations/compiler/compiler/integers/i32/min.leo.out b/tests/expectations/compiler/compiler/integers/i32/min.leo.out
index 159c1cf341..3594870ec4 100644
--- a/tests/expectations/compiler/compiler/integers/i32/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 5700de287e5342a5b9946e3f24896ed4c3605dfdec6f35080c8bd2d3e9dc4ced
-    imports_resolved_ast: ebc86747d263055eaae5628e281c5fd638d9497b91cae7efcf7950145eb6ad30
-    canonicalized_ast: ebc86747d263055eaae5628e281c5fd638d9497b91cae7efcf7950145eb6ad30
-    type_inferenced_ast: 551ce6384757ba7834ba75a34ca4ca1d48c1953324ec894dd627099cab415ffb
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 589e6d748d36d48303beede01181806027b03cff161f846f9d7975a658dbfbf0
+    initial_ast: 37e73ef8bc3214c269ff7034f05d0ec4402eaa225376a60f785ea5bba27be3fc
diff --git a/tests/expectations/compiler/compiler/integers/i32/mul.leo.out b/tests/expectations/compiler/compiler/integers/i32/mul.leo.out
index 240d2250b1..85b7ad5530 100644
--- a/tests/expectations/compiler/compiler/integers/i32/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 24576
-      num_constraints: 24577
-      at: 3f0c50eed51d601da1dd661e666f96fcf5285b7be20881d92b7fa14e6147c5fd
-      bt: fc2efd0d73e1d0feb345c15515e796fcd289003e5e388d35be464e3ee76a0cb5
-      ct: f720f62a8a58bc4a64c837cfad115c98d50ccfe3b208fb9fa346c5c17ff7ded4
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e1b55f63b5b7a7eca8759beba1d7276fed4caab5ec4d18edd2d5e3203c11a6cd
-    imports_resolved_ast: ebb3a175f900fead5eee3ace2863c2ce109b4c1356545eba4770276af2582d09
-    canonicalized_ast: ebb3a175f900fead5eee3ace2863c2ce109b4c1356545eba4770276af2582d09
-    type_inferenced_ast: 2dfa990585f3ffca7b525dd58e285f049cecfef1f9bdf0f32491bbe0fcdab190
+  - output: []
+    initial_ast: ee8e95c8a34b19e8993ac970b94b56dab2c31b7e54dc92b27128000e7d05191d
diff --git a/tests/expectations/compiler/compiler/integers/i32/ne.leo.out b/tests/expectations/compiler/compiler/integers/i32/ne.leo.out
index 85cdd792eb..71f8508046 100644
--- a/tests/expectations/compiler/compiler/integers/i32/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/ne.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 129
-      num_constraints: 129
-      at: 6cde17fb079861287679ad93d9ed9125cfc21000431bfeaf5a2054360ce51ef7
-      bt: 1178e67ab79eac96592f17313168c4300d53e89ab571025054d53d19dfdfd1b8
-      ct: 9f4c72431c0c7c03e216195a071c971c53deed8e3bfce450bffb3a6fad7418d5
-    output:
-      - input_file: i32_ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e139f93b7d7cac2cb16d7f3bfb99cc672bce435c86f3fef08d617f40c954a1fd
-    imports_resolved_ast: b493f0a4d6f71f1b4817a9671d05a4448176381578aafe92814c5c2241091eb6
-    canonicalized_ast: b493f0a4d6f71f1b4817a9671d05a4448176381578aafe92814c5c2241091eb6
-    type_inferenced_ast: b81f804e4a18bd2dd5b544481d28e582c4f897fc4c2c8061436eecc3d3ff09cc
+  - output: []
+    initial_ast: 36333a73320637e60e5992db8f2c6cbf15a6958927a44a8e8a4bd4d6a79aa583
diff --git a/tests/expectations/compiler/compiler/integers/i32/negate.leo.out b/tests/expectations/compiler/compiler/integers/i32/negate.leo.out
index f8a8480b34..9f634666d7 100644
--- a/tests/expectations/compiler/compiler/integers/i32/negate.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/negate.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 189
-      num_constraints: 189
-      at: 2254172298dcedafc294b068f855ab0dd689491362b1b490a8c95435e4b159da
-      bt: 244d201ae16e93cdd97ca56d698598a5a66e1bcb2794d58b5e24f6f9df9760a4
-      ct: 1607b4ad7556c35957a6cbce85868f0f82d2c65e55f13350ef81738caec6e235
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 921ba20eaa9e9cf5a46d692c0893fd03605f64bf36c3d691edd43358b73cfa6f
-    imports_resolved_ast: 3bcb4e29b19fd9d3065ad1032a5cf876fc5b607f187c75bf0bd23d9985135366
-    canonicalized_ast: 3bcb4e29b19fd9d3065ad1032a5cf876fc5b607f187c75bf0bd23d9985135366
-    type_inferenced_ast: 34a2c014038324a928d0d2b2d0c31c64a5d758477f64782bdf58f39137782bad
+  - output: []
+    initial_ast: 1d82fb1de0617c8539255e7ba530cf7583bd799384d76e715da5053f822e976b
diff --git a/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out
index 809d4eff7d..dfe11c0f77 100644
--- a/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 9a77f3ae2b4c9ca610fb20c44c4cde2b7e0a6ddfc13ca3da931a6b46fd1d2e44
-    imports_resolved_ast: 7e81754934090b8f0fdf66c30d38025bb015424996163ab3c841960707169d63
-    canonicalized_ast: 7e81754934090b8f0fdf66c30d38025bb015424996163ab3c841960707169d63
-    type_inferenced_ast: 0a82f705dd8a224a771827e4f12a18da4217102c1e77229239863fec58950684
+  - output: []
+    initial_ast: cf7306f1290d301ed456ae3d68c35563475c18545a204dd332d877992677e466
diff --git a/tests/expectations/compiler/compiler/integers/i32/sub.leo.out b/tests/expectations/compiler/compiler/integers/i32/sub.leo.out
index 98b4f5ff07..117e298009 100644
--- a/tests/expectations/compiler/compiler/integers/i32/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 410
-      num_constraints: 411
-      at: 3293cb0f2e38fae78ca837de736471f6e36a372f92282123f6082e07648b412b
-      bt: c342f65da421c48d402ba324062abbb064eb525a99fe5379fcb1654a33a11d68
-      ct: 8a37ed12cbab476be56f1dc175e38c689f5bde3909161865409085a34c4a19f1
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4a9829bc7a649236d8cbfce735f22e234f3db6e5d9cd56e0bc20903d759c3c51
-    imports_resolved_ast: c318a6e9e552604cfef71931071564c93619920da0526d288925c6f07b091da1
-    canonicalized_ast: c318a6e9e552604cfef71931071564c93619920da0526d288925c6f07b091da1
-    type_inferenced_ast: 7a1028b4efb34b703623bd02f3a0918bb09e29578821d24de69fbcdd3bb4251c
+  - output: []
+    initial_ast: b7e347f0b12557644f817848aabddd9c8da188d6289955cf88844a21714517ea
diff --git a/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out
index 8601636ba8..71636884af 100644
--- a/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 224
-      num_constraints: 256
-      at: 45301188494f0c65b2e88eac9117ba7367e772ea34e9b8f34bf3d49dbd1dd067
-      bt: 35d9c47cfd4fc137760d0ee411c0b097541cab7aae2b0a9ea83b368328fe5c23
-      ct: 032da4c7df957d9ca89b5395be6e1c84cab7d19a78abe1b02bb37b26ca65b0e4
-    output:
-      - input_file: i32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i32_rev.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 16c5c8505b1e4572e7bee37dfc50d118a1cd82f9ac9d3142f67c92997de2490b
-    imports_resolved_ast: f824e2d834ffb13df0c470aa34640ee20d7640ad27f4bd560e8393720da58364
-    canonicalized_ast: f824e2d834ffb13df0c470aa34640ee20d7640ad27f4bd560e8393720da58364
-    type_inferenced_ast: b72f76cb7166f17456dc9f5b47f8b3ac0deaf6f4f083dc8cf0ad005415803fcd
+  - output: []
+    initial_ast: 1d6cbecea691afadddc7e131dcbfb12848aa81f65a0800222800f2291b73ffba
diff --git a/tests/expectations/compiler/compiler/integers/i64/add.leo.out b/tests/expectations/compiler/compiler/integers/i64/add.leo.out
index caec675dba..1d6f0ffb46 100644
--- a/tests/expectations/compiler/compiler/integers/i64/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 700
-      num_constraints: 701
-      at: cecef57cd6d6e05c1f08807f82c42ac9ab45def4542662ca606c2e8183f36c76
-      bt: dbea824d3f892b3f86e08d05b68eecdc0de998bcd12186475d90ede9dfc5dfd8
-      ct: 8bc1636c45d8da73bfa0c5a71972d9829c9954007eff5db6f8fa4672d5b57c4f
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 255b75cbbacb5c9c2c6dd49471f10df5268cf83df9c8cf5ef6c047208a76a943
-    imports_resolved_ast: b06336dfc33748fd1019617e8cd889bfda30d8e0a8731a651eaa327470b1187d
-    canonicalized_ast: b06336dfc33748fd1019617e8cd889bfda30d8e0a8731a651eaa327470b1187d
-    type_inferenced_ast: 55fa816d64681ef3d1cb2efa5f21efefb8123631088e07a69fecb2e29c6087b7
+  - output: []
+    initial_ast: 4c8ecc77fb85464f37ed6510270912bab6d7f59d34c906a47eee5eba72e18b84
diff --git a/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out
index 0260c11d48..ca82b86cfe 100644
--- a/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out
@@ -2,18 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 255
-      num_constraints: 255
-      at: 68080cb19b62be7f91ee2118affb7b55ea272e15e17581869385053a5c6d3623
-      bt: 2c1d031e57e285b1277f2c37853fc7fdff23711e1147d7b26ed74d3acd28ceff
-      ct: 0b136215b60005ed17aa4eea76bc4e2b0349c0fecf57dc06f5dba31981f270d0
-    output:
-      - input_file: i64.in
-        output:
-          registers: {}
-    initial_ast: 7fcacc8d69d15138adc9cf57fc10d14075d30670cda5ffaa3486d480907ecdbf
-    imports_resolved_ast: 6d191954e51c30c96b42295b365c557ff41e9affcb50cb1fd993c8b4e70cf9ed
-    canonicalized_ast: 0eb4b219fa1b14b2d35c053c6142f3debb3f3fa08201567428677aa336914ac4
-    type_inferenced_ast: 75677745f4a61df148b71dd07d22b53841edc45ac9a1e35b1d3396ea7d3cfa8a
+  - output: []
+    initial_ast: 1bea4a8cacb4e61a75f4081614cd52b084cd2e2fe7ff0f1ec14930bd76c0f94b
diff --git a/tests/expectations/compiler/compiler/integers/i64/div.leo.out b/tests/expectations/compiler/compiler/integers/i64/div.leo.out
index f27df5549e..f9acf5f796 100644
--- a/tests/expectations/compiler/compiler/integers/i64/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 66614
-      num_constraints: 83254
-      at: 329edae9756f7bd721526c1b0790df530231fd3294f92161fb6c6b92036f03cd
-      bt: 81f681cc8f8cfc15fbecf76405b9a65ee9bf78492f8c012067a6a3db6efd466a
-      ct: 308cc563c21dc87ce980daf26ae9f4716b2e9f26517940e244ce3d98f488d280
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 30c6f1e5714a6d834c459ab33932c263f3c97d9f7e1a413f9daca0a87ff8bb10
-    imports_resolved_ast: 8c2f46fec027579b617bb1bd0dd9bdc2b17817362890f3fd25df4619aea4a798
-    canonicalized_ast: 8c2f46fec027579b617bb1bd0dd9bdc2b17817362890f3fd25df4619aea4a798
-    type_inferenced_ast: d63ca8d209849df610679929bf65577fef01a1a16fccce0bf371ef6677d68af9
+  - output: []
+    initial_ast: 1ac553449dbba81518d78f57a0728f69efc8040ac83ee09516a99b52812d0ce5
diff --git a/tests/expectations/compiler/compiler/integers/i64/eq.leo.out b/tests/expectations/compiler/compiler/integers/i64/eq.leo.out
index 583c7ed58a..58c5c14d0b 100644
--- a/tests/expectations/compiler/compiler/integers/i64/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/eq.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 257
-      num_constraints: 257
-      at: 30dc67aa22cadc6e5ec8c73e0096443263121e29adf46bb33ed310b07765ff6e
-      bt: 1aaee32179419b6185d75c5745bd13c7c8ba869bad0132405ef1b28915bfe5d9
-      ct: 8edd5528a862bbd5590cfbd0d52871e395cf73e3a22c70839571b36506fbe3a7
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d6147e8092d94583fa1f0981d71dc79ef2c877b8dad8eeda3d45f308354611b0
-    imports_resolved_ast: db17ff882f6b8ab86e752b59a122716c4f585c23a65ebfd3b9c28449d23dd074
-    canonicalized_ast: db17ff882f6b8ab86e752b59a122716c4f585c23a65ebfd3b9c28449d23dd074
-    type_inferenced_ast: 4d8d7555040230b27153a966cf9a706e0508c804c51841b7056c27f561577580
+  - output: []
+    initial_ast: 9d96dab7f2cf21a2358200798a2689f722d388fe23c58bc00f13feefc05328e0
diff --git a/tests/expectations/compiler/compiler/integers/i64/ge.leo.out b/tests/expectations/compiler/compiler/integers/i64/ge.leo.out
index 2eb648bacd..9196417ba0 100644
--- a/tests/expectations/compiler/compiler/integers/i64/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/ge.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 04829ad53a315f620a66d1fc8152176c29a250b57c54482f7e2fba84cad444c4
-      bt: 46fa1dbc8f6cc62609913fe96ad20cff4ba8ba7ea886b3682c3b4dc9a491b334
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: i64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 849578e5fdb50a1b03f862296b364b905ab43cd407955c80ccf677d741887688
-    imports_resolved_ast: 2d99676e2cb0001dda9d2a038c4f038e3dd3f11ba1deeebff2879f2d80cec1ab
-    canonicalized_ast: 2d99676e2cb0001dda9d2a038c4f038e3dd3f11ba1deeebff2879f2d80cec1ab
-    type_inferenced_ast: c5c45d02fafb725c30661e0ad9b9a7cf1207f3315fef863f635d96cd17e6ff60
+  - output: []
+    initial_ast: d051e63b0e248f8876e9d57ef905e0367a52fa9093bd2651ccbbf0312c7fafbc
diff --git a/tests/expectations/compiler/compiler/integers/i64/gt.leo.out b/tests/expectations/compiler/compiler/integers/i64/gt.leo.out
index de0e231225..e0e3fd7408 100644
--- a/tests/expectations/compiler/compiler/integers/i64/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/gt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 2805d5c14f23da221eefbd223bafa37ae210f961594e020f8aeb1a9ff00d7287
-      bt: 3947204249ecf9b6f7339e9c6409daf25d626f7e807ac182d3222e61fb4499dd
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: i64_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 2e62333f498bc96d4cab38ff5c13ed61b06159e4077d6c551acb9186bff44d9b
-    imports_resolved_ast: 9351cd32e1382913137fb087f338ecb01923545cb280135032576f4aee56ba33
-    canonicalized_ast: 9351cd32e1382913137fb087f338ecb01923545cb280135032576f4aee56ba33
-    type_inferenced_ast: 8b1304091ebad20244441d586811e54fa9688f79a0da9fd1c8eb9d2f4f1197ef
+  - output: []
+    initial_ast: 3c6a6a8e102fd584ce5ec3e7bb33a944d13f7d2940b9f7dd62ccffd4497b1858
diff --git a/tests/expectations/compiler/compiler/integers/i64/le.leo.out b/tests/expectations/compiler/compiler/integers/i64/le.leo.out
index aff9d671d0..6c74c826af 100644
--- a/tests/expectations/compiler/compiler/integers/i64/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/le.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 228ee4529b5cacfbd2dfbe9fe20088c9e8de89c4f80fcca316cd4ed3830ff633
-      bt: b228ce69df9ccfd94eb2d43619a82e2720dc0b34666b6850f0cd42db04befdef
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: i64_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4cbe66b4faa6f90f792df2c404d2a1a9ebf4b1f2c61be21751cf438d11984acb
-    imports_resolved_ast: c11552123f4f495d555b4ed8972f08f8ffbb8a9db7876ff0a9bf3d03a44f6cb9
-    canonicalized_ast: c11552123f4f495d555b4ed8972f08f8ffbb8a9db7876ff0a9bf3d03a44f6cb9
-    type_inferenced_ast: 2f5c29250ae6f083bc16ee9b2f7616f3f45ada6b518d2ca22f55043134b3f444
+  - output: []
+    initial_ast: a2708a17884e05a752fcac58df044096170c53df416cb7b5bf4e8d5228d7396d
diff --git a/tests/expectations/compiler/compiler/integers/i64/lt.leo.out b/tests/expectations/compiler/compiler/integers/i64/lt.leo.out
index df66588c5d..9fa444a3a2 100644
--- a/tests/expectations/compiler/compiler/integers/i64/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 639536c4b5bf6a7c935ad88f1b89a66819ee24afa34d949536ab84e9cddd7fa0
-      bt: fcbfd8b9b01e1754f1023d94765533fb9199baa19fddcb89a4d2a010e7844284
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: i64_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 859e9ca0927635af6e7da79a8a59f7b735a644965b1a555993c4d371c46a22c3
-    imports_resolved_ast: 5d3f74c3e66c83953582cc732801a6aae3e0038297d702d2e2a988ec4bec28bf
-    canonicalized_ast: 5d3f74c3e66c83953582cc732801a6aae3e0038297d702d2e2a988ec4bec28bf
-    type_inferenced_ast: e367a96ad3a120e7035e96f9f66eafd71eb88633294683d63afe40eceec0d162
+  - output: []
+    initial_ast: 3fa8bf29f62927c016e625eccec688057f0390f8fe50072598774df9d9e60447
diff --git a/tests/expectations/compiler/compiler/integers/i64/max.leo.out b/tests/expectations/compiler/compiler/integers/i64/max.leo.out
index e597688096..9131d1fab3 100644
--- a/tests/expectations/compiler/compiler/integers/i64/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: bc0571788350649e89585280a26483cf015fd8ee2afd1e6cc695b082f68b5795
-    imports_resolved_ast: 4091dd17cce88b8bb3de9e995371172d534788e84446d959366c9d7e75aac562
-    canonicalized_ast: 4091dd17cce88b8bb3de9e995371172d534788e84446d959366c9d7e75aac562
-    type_inferenced_ast: 9207b20dc522fe8e0781ffed510bf8b056cf9a201d4212bd17ff3c3d74862640
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 75ce16952ea88c8095f3ec9d5d131eade5e4456304d0c9fa042076cfc60a9079
+    initial_ast: bdbcbd06abf74aef338c464844ddb855b785d00d9d78eede6cd188dbc3d2f7e2
diff --git a/tests/expectations/compiler/compiler/integers/i64/min.leo.out b/tests/expectations/compiler/compiler/integers/i64/min.leo.out
index 94aed727ef..f5ec0e5fa6 100644
--- a/tests/expectations/compiler/compiler/integers/i64/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 83811eb3d8cc53f233cee3159bab98c47b1da8cae87a2553a9526b0a6fceb611
-    imports_resolved_ast: f9f17b4c71f4d805d5e24206d5db6e2cacc6368026bba5a22622d79416edc40c
-    canonicalized_ast: f9f17b4c71f4d805d5e24206d5db6e2cacc6368026bba5a22622d79416edc40c
-    type_inferenced_ast: dc5392b74d0805cc9648ff00df5f266cb0ae0606379e79e62c54c33e72f10cd6
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 3ad5b298e23acc3778e9c7f81fd66a5f46bc4b41e83cea6b72ca9128be6d99b4
+    initial_ast: 6c7a17921be4c17f4e50a9e3a4aaf47cde9fd1c9fd06705653ed8d3ad2b184c8
diff --git a/tests/expectations/compiler/compiler/integers/i64/mul.leo.out b/tests/expectations/compiler/compiler/integers/i64/mul.leo.out
index 5efca2d3ed..7342a4e993 100644
--- a/tests/expectations/compiler/compiler/integers/i64/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 98304
-      num_constraints: 98305
-      at: bad40272ae6cda7f44d2b892d1768eee85552b506921982eef405d5cc8d70e43
-      bt: 2fc487f7ec79d8c33c89cf5c899ad0b56f7468af6aec96081b6f08344fbf872f
-      ct: 37717cfdc15b44be3cd83355ff38227c8abc7aa09152746fe4cd7f42ae31ea9f
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 6f09da1337ed873f40341d791b25fd1184f9bd48d4b726d54f81eaa212428482
-    imports_resolved_ast: 6a64959ff1c7e05e9b53599f6cebe9bd067f3a4cf657769697f2bb188d0ce46a
-    canonicalized_ast: 6a64959ff1c7e05e9b53599f6cebe9bd067f3a4cf657769697f2bb188d0ce46a
-    type_inferenced_ast: e3f2d44f9fee75eb789388b6a5f6d794e400a6600aa267b8f3aa4614340db901
+  - output: []
+    initial_ast: 58c1234be63fc6d2e2622d64fdecacac6b657a7f08f5668c39c6f33793cbf910
diff --git a/tests/expectations/compiler/compiler/integers/i64/ne.leo.out b/tests/expectations/compiler/compiler/integers/i64/ne.leo.out
index d3843d0c42..7ffdd36d05 100644
--- a/tests/expectations/compiler/compiler/integers/i64/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/ne.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 257
-      num_constraints: 257
-      at: 2ba8d0827cc16bb5d0076549483425de1dd0da9b3fb06fd790c256ec8d1df36b
-      bt: 7abc1550aed02405fe1d0951da294ee11583b4215ddc3889429f16ac75604766
-      ct: 8edd5528a862bbd5590cfbd0d52871e395cf73e3a22c70839571b36506fbe3a7
-    output:
-      - input_file: i64_ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 996eb3cbab4bdff3f0cbb2b3875849c09df2737496c23aa02e6f865d5aa4559e
-    imports_resolved_ast: 92fc683fde9dccbc30d60dbbf6b3b143fd43fed6201e628a97d461f3ad728d4d
-    canonicalized_ast: 92fc683fde9dccbc30d60dbbf6b3b143fd43fed6201e628a97d461f3ad728d4d
-    type_inferenced_ast: 00bd6ea10e1e3fe863e384e536885a6ae4c5452074f91fb029d0d7d3a3f7c860
+  - output: []
+    initial_ast: 952f7cee27658adbfb5ebc545740bfd721b2752bd9ce1f54a2d01b4d579fff2c
diff --git a/tests/expectations/compiler/compiler/integers/i64/negate.leo.out b/tests/expectations/compiler/compiler/integers/i64/negate.leo.out
index 614a90a003..c8771f29c8 100644
--- a/tests/expectations/compiler/compiler/integers/i64/negate.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/negate.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 381
-      num_constraints: 381
-      at: 417f4d29cfbc9a9a971f4d94932ac19b448b4b7407e37e0558c3e232b4dfa073
-      bt: f99ae12913da76b1006f5da90b82a67453e4ade0ae3c1102088527b9165abfc3
-      ct: e7cff3106d84b6f974711e728b4b6138785655ed58ad24bcd957a5fbbde6be62
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 59a5a06198c05314c7f9e733bc4241ee5032b7a6c593993987874bcb9612f0e8
-    imports_resolved_ast: bc42e1e0d597e25165ed4d47b082480c682757dd954cbd95afe79d15f6340f17
-    canonicalized_ast: bc42e1e0d597e25165ed4d47b082480c682757dd954cbd95afe79d15f6340f17
-    type_inferenced_ast: 4504fc75eb44b0c17378cd59055d6bf02c6674284a425b5dce01a99f9bb63952
+  - output: []
+    initial_ast: 967ef98b19841f65c071e3a99b51e271eac151e6eb29dd005ac2bb4993e2eb5d
diff --git a/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out
index a8cb81bb50..e5ddcd7659 100644
--- a/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: f84b7637698c3b29daa85a754c3f9e5e88cf1531b67ce7a4708026490ccd4de8
-    imports_resolved_ast: 02773a2679c16464cf1661751dd71444b76360b2c494d4146e759474183acc47
-    canonicalized_ast: 02773a2679c16464cf1661751dd71444b76360b2c494d4146e759474183acc47
-    type_inferenced_ast: af6e26e1d5fc936ef953c0fe7dcc7d714d33d9974d14b7ba8c2d4345529dd295
+  - output: []
+    initial_ast: eee3b23e0df3c210153d3ee8b7d83f17c5fad1bf37708cd7affe1da27862c950
diff --git a/tests/expectations/compiler/compiler/integers/i64/sub.leo.out b/tests/expectations/compiler/compiler/integers/i64/sub.leo.out
index 887d6667b6..11512b8d83 100644
--- a/tests/expectations/compiler/compiler/integers/i64/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 826
-      num_constraints: 827
-      at: 353e78ba99a7a4accd8ff4d7fee5562d844f55009ffb547ee95bc741f3b75bde
-      bt: b2855c9d479f9679702723e00941392e8c7e3b66b48b997c2ff7e575b3b2a33d
-      ct: def36d63bd06a167e8b411f9f7a6208bd5da2233b7e44755d8f7fa3d483be554
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 152b827ccf2330f232290a37fa264862f6ba42097ea09f94ee170d4402a096d5
-    imports_resolved_ast: 34d24d3a7d5541705a4ab1fd70f60c024059b21d0ec7589fb853739b2ed7b544
-    canonicalized_ast: 34d24d3a7d5541705a4ab1fd70f60c024059b21d0ec7589fb853739b2ed7b544
-    type_inferenced_ast: 07e6e0ea85e1f02075700c02376fa7cbd5e02c2c404f367303ff5f8a8fe97bad
+  - output: []
+    initial_ast: 5276434ecb5659d594e5d0d70a79253788619f6d14588e3264ae8095e55d14b5
diff --git a/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out
index 03b4d9f68d..7facd256e3 100644
--- a/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 448
-      num_constraints: 512
-      at: e36c9bfd01fbf30c1f31d53e2b19d1a83989e86701ba58838688174b9ad804d7
-      bt: edadcd06780bd97cb60d245565ce94697ee12b4d71ce9148f1546f1c4390b668
-      ct: f1bb709127145aae7603feda04afbc3e401fdf290c1d549be8d2d4b21ece9b58
-    output:
-      - input_file: i64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i64_rev.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 97b751e7282f0d3edf9d1248c949175952c9c1c2510bc24005e5471a59158fd9
-    imports_resolved_ast: d395bca01bf820a93b424734090ec90cc72bc69f74800202738cbfd3b2ec829e
-    canonicalized_ast: d395bca01bf820a93b424734090ec90cc72bc69f74800202738cbfd3b2ec829e
-    type_inferenced_ast: b42bb0bcb6c3486ee92d7bd6903220081544e335df128edfa4137469794df9f5
+  - output: []
+    initial_ast: b3ca29cd4029ebf80b1e8b9f97674cccd70a003fa97ba5ddcb71bbefe1faaf95
diff --git a/tests/expectations/compiler/compiler/integers/i8/add.leo.out b/tests/expectations/compiler/compiler/integers/i8/add.leo.out
index ec8a99d0ba..e4e801e389 100644
--- a/tests/expectations/compiler/compiler/integers/i8/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 84
-      num_constraints: 85
-      at: 5d1a78f3ac820a4873a0602f69d7efb764135c6df25bfc4c182daee12402a595
-      bt: 85916f4efb04caeb618ad35bc96528d6aeffd742b574cb93ed22ffcd46c87751
-      ct: 846591a223fd860defb812adf90d4d103f16e168465e64986ac960819b4fae52
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 9e5c65d701393ac0a10268ab685af928da8bcc834361be8ca83cc5778360907b
-    imports_resolved_ast: 0af291edad09bb357c6efba5eeab896e20af6e482ea09fb5a1e81775aaa1552e
-    canonicalized_ast: 0af291edad09bb357c6efba5eeab896e20af6e482ea09fb5a1e81775aaa1552e
-    type_inferenced_ast: 3135618ce43d9da9bcddf80d47a54953f0a3fb24a754a21e3910de8e500b925f
+  - output: []
+    initial_ast: e5b43164c337c686cc881208115e1bbadd1926c5fb388cb0d0592dd26c40bbb3
diff --git a/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out
index df285c6b2b..634af72845 100644
--- a/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out
@@ -2,18 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 31
-      num_constraints: 31
-      at: 8111e478f64beb722ec96fbd80076cb73b735813b20e8f2ed6e3c21febceaae7
-      bt: c2cfac5aa6e125cb6cde720b0598fef7933c4aa62926fe99405bf1c2829dd4ce
-      ct: a3fa97a403ebea95a47d7ded7c01cee45af74afbfa876c203e4e96f6054b8815
-    output:
-      - input_file: i8.in
-        output:
-          registers: {}
-    initial_ast: e2a747d71854c915b7ec8143e5a2522c64abb1ac971b10f63646806c48330c0c
-    imports_resolved_ast: 4111b88ee2439f09fa213ebe1aee411b0b3fd5545745988762c5f31aa94ff262
-    canonicalized_ast: 2cfac6ce73ea847246d0640e1fc53d685113cffef13ad3684ea554231adb4f85
-    type_inferenced_ast: 812707e0fa896e764c20cc922d6d2149cd57e7673817355248d5905a7d524dcc
+  - output: []
+    initial_ast: 2111ef1f907235b8847a756573741f8bace8e738c88355aa001c66b89c8dd3ea
diff --git a/tests/expectations/compiler/compiler/integers/i8/div.leo.out b/tests/expectations/compiler/compiler/integers/i8/div.leo.out
index e8ee4fbc54..c2a11c4c3f 100644
--- a/tests/expectations/compiler/compiler/integers/i8/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1150
-      num_constraints: 1438
-      at: ea4e10bc92af056bb4b3797063565094853fe4ba595f03fd6d4a8a0fc30ca195
-      bt: a41852ab8ac16bc91220ddd5b2fd1dacf3bebb624715cf2c3dc53f5dd172da9b
-      ct: 0449683ea39f4822da71f08082f051f005ecf6b846ab99e48c6ab9ac5aaa75be
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 345b9e2ba4e58d18156fadd9a4e592b23c08e447cb1d3d413b5cbebc9ddc161d
-    imports_resolved_ast: 04e8f8dfa028514252e6ba75c8404ae0f72068fd82a7a13bda66319bd9f94a7d
-    canonicalized_ast: 04e8f8dfa028514252e6ba75c8404ae0f72068fd82a7a13bda66319bd9f94a7d
-    type_inferenced_ast: cd658feb37a4d359f2082a408102b15f541985ddaa4f1ddca36191ef1bc37909
+  - output: []
+    initial_ast: df29046329d8b12827f7885dfafee8a88abb17450a6fef94f5c192d582c170a9
diff --git a/tests/expectations/compiler/compiler/integers/i8/eq.leo.out b/tests/expectations/compiler/compiler/integers/i8/eq.leo.out
index 692c88d057..3e1f5189a4 100644
--- a/tests/expectations/compiler/compiler/integers/i8/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/eq.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 33
-      num_constraints: 33
-      at: 424965aff58c62dd2bf38daa6426a3edcc19aa86bff3842fe4e73f743d37e1cb
-      bt: 03d1b6a8fdf9f73f595cf97261f1bae81000c89364c7af58f4f7f04aba7bac30
-      ct: 2aae7d6631260dcaafbfe9709ade84e75f5172a9baad48e108e7264d5fc17cf6
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e6a4b56d08ce550ccc3df10f722a416fa4a57958dab0197f2e0471de9a88b29d
-    imports_resolved_ast: 840d5bfba048bd015e84f2273bc270f87a104c63c2fd66aab01de6b2c341dd9f
-    canonicalized_ast: 840d5bfba048bd015e84f2273bc270f87a104c63c2fd66aab01de6b2c341dd9f
-    type_inferenced_ast: 247a519856e8c61041c87456e97e152a8a667ea6f122432947d15b1fc52eb234
+  - output: []
+    initial_ast: cb0fef3c670b24effcfe01867ad5997394daf09593f2e90f721070dcd88dbd6a
diff --git a/tests/expectations/compiler/compiler/integers/i8/ge.leo.out b/tests/expectations/compiler/compiler/integers/i8/ge.leo.out
index ae7a558ff8..6e13348762 100644
--- a/tests/expectations/compiler/compiler/integers/i8/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/ge.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: 0c041f98ae4465c405aa6cf9dfb23157cee029c4ba12162385a49d230eaea769
-      bt: a55f11270f22104142bcee90897c9d9a8463b2fa9043957f85d82725f4bb075e
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: i8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: dd7874cd24a72b38a28274fc5c73a4887f01709224d3ec649a5b84d01b22d1e4
-    imports_resolved_ast: 2a21bf97279f45e1a86c89f2b63e88cbb4c02fcc918575483e40108a3d9357e2
-    canonicalized_ast: 2a21bf97279f45e1a86c89f2b63e88cbb4c02fcc918575483e40108a3d9357e2
-    type_inferenced_ast: 32bb7c5638a3f2ee19092539806c9b9844fb3289943fdd3f2515b7085a984941
+  - output: []
+    initial_ast: 308b765395012cf54485fea5aaf0d0c30709e893283637674269b795ec950923
diff --git a/tests/expectations/compiler/compiler/integers/i8/gt.leo.out b/tests/expectations/compiler/compiler/integers/i8/gt.leo.out
index 0cf2ce2900..7a6b1a9034 100644
--- a/tests/expectations/compiler/compiler/integers/i8/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/gt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: fd43cbc2bdaa1e99408e9ca7bd13774576b88c884f64a153fbd8ba2a710c0b42
-      bt: 4a959c05229442ca476ef20cfe1988fab90d5ca1b8f1c75f75719d475030c086
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: i8_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: af8f08b489137ec841ff8fc8d2b9eacc8806b868334f5a1c591e435abc0e67aa
-    imports_resolved_ast: 1ba06738c37881bd0ed5f0ff669f4b8f8e83f848ee7f968b49cf55d975749476
-    canonicalized_ast: 1ba06738c37881bd0ed5f0ff669f4b8f8e83f848ee7f968b49cf55d975749476
-    type_inferenced_ast: 669bbd4e98f4a9ce88b8fec523b5a3286e3d10136728cd629c230087eff91699
+  - output: []
+    initial_ast: 7c3a35f6d43020992906b2987c7bf36afc0f7294551609cf8bf4d08a084933d9
diff --git a/tests/expectations/compiler/compiler/integers/i8/le.leo.out b/tests/expectations/compiler/compiler/integers/i8/le.leo.out
index 8d32fa0cb1..405d958c83 100644
--- a/tests/expectations/compiler/compiler/integers/i8/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/le.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: 5a23ebca65ed09a730f98babb863f4b6c166d80b0e97790788b5b2c1ed0e3f8a
-      bt: 13756f3827f4f5f9c3d57ac57364366b9716cd3474416861f9aa9fe7a79206d0
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: i8_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: ed656b4e9bea2e3fb358b5883b46624f0526c00f9ece18978830ec62244d7282
-    imports_resolved_ast: 07d47da4eb919089fa7859a2ffc9168cfb86cb39f567ad69b74401ce5373ff22
-    canonicalized_ast: 07d47da4eb919089fa7859a2ffc9168cfb86cb39f567ad69b74401ce5373ff22
-    type_inferenced_ast: be24c6ed70f0fe23a4312796d93657bcda2f9ed86d7b66280660b5c1f755fbc6
+  - output: []
+    initial_ast: e7cf5556592135d0f297a2e0f00c975b7687698a336319b50957a1e6012ecf84
diff --git a/tests/expectations/compiler/compiler/integers/i8/lt.leo.out b/tests/expectations/compiler/compiler/integers/i8/lt.leo.out
index a1229d6701..cf56740893 100644
--- a/tests/expectations/compiler/compiler/integers/i8/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: b93e8bf8fef6bb33a2552fc46f20f842010f187164d846f84b2a8618628c59a9
-      bt: 2edb58dffc1fb55bd54dd589b8fb4cf15292f14cc2e9d478bb372b57c958ead9
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: i8_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 57e9e6349d8d717b6a7a4244131b7858498a32af6133045833cb036eba847a18
-    imports_resolved_ast: b4863dc8da140ce4b7b69b31f69efc5dd399b0cd3f04a08c80aa59ea24aefa65
-    canonicalized_ast: b4863dc8da140ce4b7b69b31f69efc5dd399b0cd3f04a08c80aa59ea24aefa65
-    type_inferenced_ast: 987d0de4baca01d6198547ac730cca2bbc1ac60369930334ef1b58730ecd1596
+  - output: []
+    initial_ast: be23f46d9d959cf0fcc74fc8bc3ef332f4e85b544982986b72a74ff3af9428b8
diff --git a/tests/expectations/compiler/compiler/integers/i8/max.leo.out b/tests/expectations/compiler/compiler/integers/i8/max.leo.out
index 13e66d5095..16a7276e6e 100644
--- a/tests/expectations/compiler/compiler/integers/i8/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 25d63424a3ab2adc456da660fadc7751422808e146af3b30f86c390ba9a4abad
-    imports_resolved_ast: 437aae9f1989d3d75257373bdbf859297872cdc9f4bb98b1a0ec4dfd4fbc3eca
-    canonicalized_ast: 437aae9f1989d3d75257373bdbf859297872cdc9f4bb98b1a0ec4dfd4fbc3eca
-    type_inferenced_ast: 0442f083e24cb828bdf5ca6f729525fe30fcb750114698b3597219d04b845f6c
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 410dbb9797616020aa72144d062706b3ac336bc4888db56693fa752a813dd7cc
+    initial_ast: a9c5129daa4615455b1b0a136ff26c510cd1de168016d784579e72d0e15c8fcd
diff --git a/tests/expectations/compiler/compiler/integers/i8/min.leo.out b/tests/expectations/compiler/compiler/integers/i8/min.leo.out
index f3cf4e0736..db3db394ea 100644
--- a/tests/expectations/compiler/compiler/integers/i8/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e01cfedfcfce4840c7fc091bdae84fd21218793a938ff0998bff61bd93a15566
-    imports_resolved_ast: d82f81c5c6097be667d6e97838f54022fd380171d1885726b73ccc482aeed771
-    canonicalized_ast: d82f81c5c6097be667d6e97838f54022fd380171d1885726b73ccc482aeed771
-    type_inferenced_ast: 77b9802ac870a9e1ecfc58ff21f4d3a1ad6fdc394d04320d78a190fa01ad1424
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 0311796b4aaecb087aa102152e237a3046ea6247df2826b604621c243ee75cbe
+    initial_ast: b72e21d2d5a92ea78c20e3a8846b8822eefac1605e4cd6917ea20bea5042f85e
diff --git a/tests/expectations/compiler/compiler/integers/i8/mul.leo.out b/tests/expectations/compiler/compiler/integers/i8/mul.leo.out
index a21ab1570a..b8af18d44b 100644
--- a/tests/expectations/compiler/compiler/integers/i8/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1536
-      num_constraints: 1537
-      at: 245902065d66fcdaff6db49bdd20f72f3e3e85ef6afcf2e12435ee63df39b543
-      bt: 0b017985fe9a0650c67351f1cc247871e9cc9e8c907f2cb47791c5ae1a5b324a
-      ct: 3fb41ccb74d402bc413944e9eb543a7333552052b7781eb257d2b861659d5a09
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b51ab5ebb70364329843ae0b793b46f41c5981347209dbfcf46e6be3bc97f193
-    imports_resolved_ast: e70bbff331d9deb9cd09a4e9342786de747f49566e4e64a30036a8ffe1a67d9b
-    canonicalized_ast: e70bbff331d9deb9cd09a4e9342786de747f49566e4e64a30036a8ffe1a67d9b
-    type_inferenced_ast: 9b9c70282c2d461eb2de1d3be1ba540e5ec98bee42d575a5fb04a2d39ed6f4ad
+  - output: []
+    initial_ast: 2658ce56907ebd80cea3db992eadc797eba68c41ec626dac01f32639bf4eb01b
diff --git a/tests/expectations/compiler/compiler/integers/i8/ne.leo.out b/tests/expectations/compiler/compiler/integers/i8/ne.leo.out
index 5c3855742d..683978a1b0 100644
--- a/tests/expectations/compiler/compiler/integers/i8/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/ne.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 33
-      num_constraints: 33
-      at: 5e88cd940df2c48a53e64a9b8589045ef766371daa5cc885df982902d9fcc754
-      bt: 10b52342f8c44eb9b3335b4df9ca4136de3ad35d5b580b2ab32ae5e10bcdf3b4
-      ct: 2aae7d6631260dcaafbfe9709ade84e75f5172a9baad48e108e7264d5fc17cf6
-    output:
-      - input_file: i8_ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: daf8c45002fe12b37fb3ce55808520fbb23508ad53a6def0d6cf7a8bd6d002b6
-    imports_resolved_ast: 457a2f6ce2dcd3875ec9f5ac87377584602dd2c3febf616f6b1fbb563c7c8601
-    canonicalized_ast: 457a2f6ce2dcd3875ec9f5ac87377584602dd2c3febf616f6b1fbb563c7c8601
-    type_inferenced_ast: d54385972b23b7f27997fb4b884438e38f7864872ff991738c5ded36a3d500c0
+  - output: []
+    initial_ast: d4166d094d27116439254b21da8fd34134b28363484ab9496913e0b8c2b47b12
diff --git a/tests/expectations/compiler/compiler/integers/i8/negate.leo.out b/tests/expectations/compiler/compiler/integers/i8/negate.leo.out
index 43f4bb64cc..3de6a4bfd6 100644
--- a/tests/expectations/compiler/compiler/integers/i8/negate.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/negate.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 45
-      num_constraints: 45
-      at: e308c63d5f53aa3c65315a1d38ba5ee664cce7bb22aaeaab07a37a9006d909cc
-      bt: 43214e3563d9bc921ffc9079215a945f8450cf3c02506bd6e23144b2e18944d3
-      ct: a2352ad3a95bc4b0d0ca56ac5b1bcec0cc3b62077d2c3d883f90f8bf014a8e28
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 2ad2a084de3eb1e2e45be405c285545637e572227e2d26ce1d2c32994a1a7f7e
-    imports_resolved_ast: ecad7e4ecd6f2b56d706b0bcaa3e04d2b900e5adbac353380f655c908cd89b1c
-    canonicalized_ast: ecad7e4ecd6f2b56d706b0bcaa3e04d2b900e5adbac353380f655c908cd89b1c
-    type_inferenced_ast: 80913f4f26afdcd3528ff62cc12aee3edd59da03267610eff6eb58af6917b116
+  - output: []
+    initial_ast: df5ed0b1077084a4c8706a71cf7441611b2fc0741b2657235c2e84dfd1a0e58a
diff --git a/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out
index 0b1e21ab88..6a46e82850 100644
--- a/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 913d33c251dfcfdf76a29f03135d40200a56c5881e4d6f7a4cccb3062cf8b893
-    imports_resolved_ast: 72ac36a979acf6121edb5b9bc6880040b1431141d75d556c3cd331545b6e36d9
-    canonicalized_ast: 72ac36a979acf6121edb5b9bc6880040b1431141d75d556c3cd331545b6e36d9
-    type_inferenced_ast: 91554f916f0b90c9dac482baf5d231ded7cfd8b6f39a34c4d155d2dc75b98684
+  - output: []
+    initial_ast: c1c7dd442e6093c06c97113a134f2f0bea10430c0f3ed935714989208ab6dc3a
diff --git a/tests/expectations/compiler/compiler/integers/i8/sub.leo.out b/tests/expectations/compiler/compiler/integers/i8/sub.leo.out
index 29ff6d353d..4644ad9b1f 100644
--- a/tests/expectations/compiler/compiler/integers/i8/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 98
-      num_constraints: 99
-      at: f5fc42455c37ae32df3b6d311ff2204dce57fa397f524fe0854ad9ffb3ff5c36
-      bt: 35a61219fd7bf101cf1a1a66ad2f71df661d6dc9dda2ed9df12c7650164559aa
-      ct: 85ae6ad5b3f62dc914806dac5751645342d399c583d6b6b00cd9e67f738aab30
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 1701e9efce35d3c8d5c260fc06ee05f9e9011429a3ca777c69f9eee138403788
-    imports_resolved_ast: 4ce6bc5633da9bf193c973472f46b664796db93fad92f6194fe02ae2ab970e38
-    canonicalized_ast: 4ce6bc5633da9bf193c973472f46b664796db93fad92f6194fe02ae2ab970e38
-    type_inferenced_ast: 363d775ae39491ff442144b82e002b530dd791dec8aeca68cd336e7df226c994
+  - output: []
+    initial_ast: e13464b8a4a1622f47fffd20c6f8c39c7812bd0831aba01178153b55d41ea199
diff --git a/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out
index fb5f1bf54a..e8bb406301 100644
--- a/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 56
-      num_constraints: 64
-      at: a15ec92a38acf1a47952df144e5299f49dbde96fbe1a3f3b2af4bbca483d65aa
-      bt: 90a2489533355ee3e27d5cf485612441ec10e21923eb78e6be21633ce11fa8f1
-      ct: 4c2d67fc6e1c4ad44f323c1b958ed94313153573aa72a3c0f0d25b17b54e63bc
-    output:
-      - input_file: i8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: i8_rev.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: bacfa33d64c30639dd6abd40373ffe996b5e1785e7851ea4e2f4235988ba7f91
-    imports_resolved_ast: c023a7253e799ee3c560ad3fd690f5127e05abea162399e62e91dfb2cf6c59f0
-    canonicalized_ast: c023a7253e799ee3c560ad3fd690f5127e05abea162399e62e91dfb2cf6c59f0
-    type_inferenced_ast: ecb6499c73ec12cfeba4bad3fee6f28dde1bc13968fba93cd866b1a5e707910c
+  - output: []
+    initial_ast: e53bd8e89b63f9f232687f6b0523a28dcc51e6837a96406b3012cdd436ce53c2
diff --git a/tests/expectations/compiler/compiler/integers/u128/add.leo.out b/tests/expectations/compiler/compiler/integers/u128/add.leo.out
index c8b8338d90..0a5a032c8d 100644
--- a/tests/expectations/compiler/compiler/integers/u128/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 769
-      num_constraints: 770
-      at: 46a7cb5b4abbe0c2a583d206d68549c1d2dacbc295a7e98ab603b1e589a748ed
-      bt: 3bd68a594ade714a6dce154fa8fe1b206c3339d591863157d5d4a30e82be8c38
-      ct: ee4814a6df109d34265d062047ac22141174bab478caf254c5623f917c5d7a66
-    output:
-      - input_file: u128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 9b7b20b367685ee5aa3ca96973f7c821e6ab14a2e79a7dc69c3587dbb88d6f64
-    imports_resolved_ast: af0df924fe3d9d026b854d2d678a4ba67b28f97d909935138d8c018f47d80eb3
-    canonicalized_ast: af0df924fe3d9d026b854d2d678a4ba67b28f97d909935138d8c018f47d80eb3
-    type_inferenced_ast: b030bf99398b5d39993276f5eb66c55ff48b9b7607d38bbd1a12c3ed6419e1c6
+  - output: []
+    initial_ast: e4e1d70546dfe483ecf16d57945e3febbd19da7fc3f64c2d158e8c70b887c0b2
diff --git a/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out
index 3a695cbb46..58526f9682 100644
--- a/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 766
-      num_constraints: 766
-      at: fc8f29e5d4a184ccde7548e9a88adf215d9745a7a1f38cb41e6046c00f684f92
-      bt: a6020f3baa81181dab1735218a3d3c8a2504b7f30c6c73c0c12e8edf0aa403b6
-      ct: 22bcd53d2a96f7cf838f37fb01781267764156a778d5b2df80572f5030de4b0f
-    output:
-      - input_file: u128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 0674f01d00a200dae0a9715f9c97af6f29bc204910e910fee5f69597e58d26b1
-    imports_resolved_ast: 16069ab3e1d37f1348a5271da190894f1060f8bd8ebaf74f70d9fb6968f1c58b
-    canonicalized_ast: 16069ab3e1d37f1348a5271da190894f1060f8bd8ebaf74f70d9fb6968f1c58b
-    type_inferenced_ast: 1bf2d30bb188ba4b10f172a14cb9ff8fea8cdd7f1265af131290550882227bfb
+  - output: []
+    initial_ast: 4fd6da0d06eb2982da519d0b662e08662158d637ce21ef6982d05612570734ad
diff --git a/tests/expectations/compiler/compiler/integers/u128/div.leo.out b/tests/expectations/compiler/compiler/integers/u128/div.leo.out
index ff29f31d5b..45d55405c9 100644
--- a/tests/expectations/compiler/compiler/integers/u128/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 263418
-      num_constraints: 329465
-      at: 7f9291f6c2c9d381cb6d96c1b958eb025a7fa82d19065612225198341d8ed37d
-      bt: e26d177238ab12a9e8091dfb18f68e0e82d410b1ebce7c8633bd0a4973f5db2f
-      ct: f36c23bcc522e47f2efe7c42ec8f9bccfb980c46c71d03f69222eb87a3aa6dd5
-    output:
-      - input_file: u128.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 5fba362f8b5d842a1bcdf6834aea9a805a0713c259fdf9e76d092260771b0a25
-    imports_resolved_ast: c23b18f6660e905ce6d027227c90d65f6946fa0b62c79f644f9a334048c9d191
-    canonicalized_ast: c23b18f6660e905ce6d027227c90d65f6946fa0b62c79f644f9a334048c9d191
-    type_inferenced_ast: e145f79deee94546f4bbcf5551bb8c4f840aa3c1be80ca9e6f8322172e844b8f
+  - output: []
+    initial_ast: 6d70edf319a5036a4004d3c3c6e8b01608b7e882d91f335b7c0dec725185641a
diff --git a/tests/expectations/compiler/compiler/integers/u128/eq.leo.out b/tests/expectations/compiler/compiler/integers/u128/eq.leo.out
index a91fa330b5..220192867c 100644
--- a/tests/expectations/compiler/compiler/integers/u128/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/eq.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 513
-      num_constraints: 513
-      at: 75b34d698fc2359df51943102062181aa5ee62b84a221747dfd7f8868bf48efd
-      bt: c1e085f0d8047bc5b5f574ca9de7d79a0ce3b3235e3bfb83ff15aecf05ad1323
-      ct: c224fec21cf5a2b24eb94033a20aeb4729d3d0cf596339145cb49ea6a44cc5d8
-    output:
-      - input_file: u128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u128_n.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 7e298cd53b82bc176170e4184b2685fe4691ac4ef9528d905dde51d30176c847
-    imports_resolved_ast: 7965609f015e6a805e672ad0db18473eaa549b7913920b44301cb2ef2f02a2e4
-    canonicalized_ast: 7965609f015e6a805e672ad0db18473eaa549b7913920b44301cb2ef2f02a2e4
-    type_inferenced_ast: d9b1351f10292c7a571771b87ad8c23be1e7035b562b27cb27dcbba368ecc420
+  - output: []
+    initial_ast: e47f3796c64fdda060e19aa678de8af0a2956d41b9c88efc95276749bdb40c74
diff --git a/tests/expectations/compiler/compiler/integers/u128/ge.leo.out b/tests/expectations/compiler/compiler/integers/u128/ge.leo.out
index 59ae1fd4a8..1fdfc30b04 100644
--- a/tests/expectations/compiler/compiler/integers/u128/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/ge.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: 8c535817cf7f33927b88bddc0b246636aea9421a249b5025229c513521a43cdd
-      bt: 75543c2d7e977fd59df93d598b3ba1ab92b7e6048a823fb41969668e29286a6b
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: u128_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u128_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 660c6545550a427357e53f3eb431b3fd00ba56805a292db4b885566e0a9ae291
-    imports_resolved_ast: 4ca01ccb2adfd67233b564e7bc855507cb3c16d02a9e004838ac9eee0f20ba58
-    canonicalized_ast: 4ca01ccb2adfd67233b564e7bc855507cb3c16d02a9e004838ac9eee0f20ba58
-    type_inferenced_ast: d3c99277661b51d5cfc1a26066ff73b229e7f98d639c4fd2a7e2d8011ab7690e
+  - output: []
+    initial_ast: 827e5cc46b0fdd4d217c046e57af283a631f03a257452b34b97aca1b87aa4a73
diff --git a/tests/expectations/compiler/compiler/integers/u128/gt.leo.out b/tests/expectations/compiler/compiler/integers/u128/gt.leo.out
index 308672e637..93d703009f 100644
--- a/tests/expectations/compiler/compiler/integers/u128/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/gt.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: f53fbab433e2588176ab0a5677a6d546a108e5a98abe79ccb5abbc57a4181afd
-      bt: 2005303715fb1fda8dbf03970acb45982b78b7c61034b172e9ea3cd363a013f8
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: u128_g.in
-        output:
-          registers: {}
-      - input_file: u128_f.in
-        output:
-          registers: {}
-    initial_ast: 62ee109937e47902a4fa812eeacc696b98e7373df4b8ce3317d01f4ffb3c24a4
-    imports_resolved_ast: d45638e147280111c9359ca325e87fb326abda1baa05a0b225093557a91fbd3e
-    canonicalized_ast: bbd0fcc1f0afd3bc549297855e66750f7175fad199b152b2b5886aa92d5a0586
-    type_inferenced_ast: 3215a73af0d0bf0841f9b4c9f40c3f7ea9de7ce307d65a817ebd142504009211
+  - output: []
+    initial_ast: 00c14ce5b3ad1b954774fcfb0b46599f0b07c10bae389607ff9fbc761a4597f8
diff --git a/tests/expectations/compiler/compiler/integers/u128/input.leo.out b/tests/expectations/compiler/compiler/integers/u128/input.leo.out
index a1ab21673f..180d58de1e 100644
--- a/tests/expectations/compiler/compiler/integers/u128/input.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/input.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 511
-      num_constraints: 511
-      at: f130bde196ac7e190b505a42dfb30c41772c4c7eafe9e7203be9222892b767ce
-      bt: 7ac37b347f82644239128aa66e9caf34375b1fd860069659581477883d92fb7a
-      ct: 3e4c7833e73f9ee37e42c796e8af7a6d417a012b776b348abedbfd317110858d
-    output:
-      - input_file: u128_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: ea9e5d6a8808d92535ffac52d1a141ad666dce59882fb828ac70359ba1dce0e6
-    imports_resolved_ast: 6af0b10e36879f68c3a591dcd154ca4fd3c34181869e3ceb70a8200a43ecbef0
-    canonicalized_ast: 6af0b10e36879f68c3a591dcd154ca4fd3c34181869e3ceb70a8200a43ecbef0
-    type_inferenced_ast: ab45f3e4a396b26a883fe639ca3e83fd18ca4d4d8bb5ed6613386911cb0142bf
+  - output: []
+    initial_ast: 8328bcf07884bc33ed6c05c740859f6d6e9b86ff3a195509e11dbd6efc629c7c
diff --git a/tests/expectations/compiler/compiler/integers/u128/le.leo.out b/tests/expectations/compiler/compiler/integers/u128/le.leo.out
index 5471e49dfa..aad82e572f 100644
--- a/tests/expectations/compiler/compiler/integers/u128/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/le.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: 3898b682c2301fc8f7812b25fafec37b2382eede8f6e86d20bf9468c8b7e4a74
-      bt: 8e0a2864aa6383434f6d7843e06d6594b85a65b2009c612f72b3d8c6f07fb4ef
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: u128_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u128_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u128_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: b1bd25758e4e2b6ea97586011f4e923a7d5c50664842cf9bf3e24bb849274de0
-    imports_resolved_ast: b334e1a5b09e3be41ccec5a5fcf6ec3fde3dc0d7965b66c7de3a771a605ee373
-    canonicalized_ast: b334e1a5b09e3be41ccec5a5fcf6ec3fde3dc0d7965b66c7de3a771a605ee373
-    type_inferenced_ast: 2ba654c7d74e2f653b2854efe13b5e7dc572e182bdcb6fb4b43837b5fe502be7
+  - output: []
+    initial_ast: dc5a1d60acec0e8a0bd8ac4da8dbf50314802ba4abc75b69e5a8036b880e1ea7
diff --git a/tests/expectations/compiler/compiler/integers/u128/lt.leo.out b/tests/expectations/compiler/compiler/integers/u128/lt.leo.out
index a009088ffe..75cbcba481 100644
--- a/tests/expectations/compiler/compiler/integers/u128/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 897
-      num_constraints: 897
-      at: 8bc0a661fdc05173ef7b37762e7f6fdd9e5788a8fa17b7b7d485b8ffbbdeb7c5
-      bt: 1669da8e0d67919ecf7e28a3727b73be52d08f9af5feb640a8cd6f2d302caa07
-      ct: 8d7309bdb692a71de6c9efc246984ce389534e8fc31222a94d5217720c2d20e9
-    output:
-      - input_file: u128_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u128_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 77fe51df8797790eae187e8148d63ff028626c068b1418753b8d0f9ac9d9d305
-    imports_resolved_ast: 08fbad98798801d5e1c2c3bcbf799632243fe84d783cb1231b708c3afdfe34e5
-    canonicalized_ast: 08fbad98798801d5e1c2c3bcbf799632243fe84d783cb1231b708c3afdfe34e5
-    type_inferenced_ast: 60d15e2cf39b36111b67cc2029b04df16bd86b10a3a1e95710f470d379626529
+  - output: []
+    initial_ast: 34662c2875224a405b09632db583066629a6340e32362b6c149a2daec519f181
diff --git a/tests/expectations/compiler/compiler/integers/u128/max.leo.out b/tests/expectations/compiler/compiler/integers/u128/max.leo.out
index 14505209df..270d85d614 100644
--- a/tests/expectations/compiler/compiler/integers/u128/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: eb227b151672407f704b79a5eb43c2943c1c635f787fc2226c8ddf424c1339d8
-    imports_resolved_ast: 0a433cdaaec92f2a215f9345fae964824e62c2f915dc560a11a3bc0d29a77ee5
-    canonicalized_ast: 0a433cdaaec92f2a215f9345fae964824e62c2f915dc560a11a3bc0d29a77ee5
-    type_inferenced_ast: 13b58a12ecaa4e3e28bee6649165fb75395a75361b78281ec39dbe37e92fabcd
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: de4df163543532b2a5655c9a606d9dc849c780388f962681780e5f042111a96c
+    initial_ast: 10323d073f4ec9377c4d86c68ffdc47fdac23b32f5bed9ed6122e5f434cf1b49
diff --git a/tests/expectations/compiler/compiler/integers/u128/min.leo.out b/tests/expectations/compiler/compiler/integers/u128/min.leo.out
index 4c69dc0c27..cf1796bd93 100644
--- a/tests/expectations/compiler/compiler/integers/u128/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: f6be756715bc9ea547080ad69c55f9f6b7de11ab40db8c4fa03d5974ed3db1c2
-    imports_resolved_ast: 231e8b93cf45b332d74f151caa1be9524f99c77621f228d24aa57688cdfcfad3
-    canonicalized_ast: 231e8b93cf45b332d74f151caa1be9524f99c77621f228d24aa57688cdfcfad3
-    type_inferenced_ast: 3540842873d10739138ca67145c0c7e38a8164c3ef44b1e8b7eb5fe06e2e817b
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 482381cc60608d33d825ce6ca5840ae9f15fcfa78d12c16538efe1601893b830
+    initial_ast: 96c126f61d94ec819d20e472720e773bf698b2f9b1d0e5367d42be68a28ced0b
diff --git a/tests/expectations/compiler/compiler/integers/u128/mul.leo.out b/tests/expectations/compiler/compiler/integers/u128/mul.leo.out
index 2ad892fceb..d35fe29cf0 100644
--- a/tests/expectations/compiler/compiler/integers/u128/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 50431
-      num_constraints: 66944
-      at: 76a413f70472403c5adeed7a79d4c2a43f5b24850b4874fff1f6a323d4396a65
-      bt: 011ebf5dd53ae194c7135690f3bc6307a362ea10ba113e19ae7195be6ab375a9
-      ct: 147b92b75d75f78bed11d65294d9ae2479b8ab32f98521755557fd54076f3c07
-    output:
-      - input_file: mul.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 74424868643e146a9a7da2f40c1213bb6a1c9217f2eee06168dd837c3af9072d
-    imports_resolved_ast: 943a99afcee736d5837a6b4d2cbed6cc158f2c2411974e3f24317b80e0a84548
-    canonicalized_ast: 943a99afcee736d5837a6b4d2cbed6cc158f2c2411974e3f24317b80e0a84548
-    type_inferenced_ast: bf4501b02fffb9337f2203df7be183ebed41a97f62bb85f8e42488088efb88d8
+  - output: []
+    initial_ast: 113f8c2b15904292632fa1b1595a5dd1988001bfaf0ba8a4b3a1d4cb9535fbc6
diff --git a/tests/expectations/compiler/compiler/integers/u128/ne.leo.out b/tests/expectations/compiler/compiler/integers/u128/ne.leo.out
index 749611b5ae..8a04d21735 100644
--- a/tests/expectations/compiler/compiler/integers/u128/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/ne.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 513
-      num_constraints: 513
-      at: 8f9d3ef916a970cb762ca6f3829a8b4897dc65d493a2ea2eb4fa812a2062fe67
-      bt: edc1de9388a8bb2c659c9b4e9deecd8406826abcfe220d295bf7d85a550c0c43
-      ct: c224fec21cf5a2b24eb94033a20aeb4729d3d0cf596339145cb49ea6a44cc5d8
-    output:
-      - input_file: ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 756c95964899f11b8ba25d9fc9184da0824003b55e707d6959cfb00c25142cf4
-    imports_resolved_ast: c6a9ea778403fc7ee7d54ceb7f3b4d5d2e11160c176d1f016e24b102b87b9a47
-    canonicalized_ast: c6a9ea778403fc7ee7d54ceb7f3b4d5d2e11160c176d1f016e24b102b87b9a47
-    type_inferenced_ast: 38a271ec105e7dfc1458ad6558e4be02422273c7a87a93d2577aa3b304ad89c3
+  - output: []
+    initial_ast: 6b1eb3a25cf39d2a2288f937298c6e57ae65f58b8e957afc1d65bb8c0f9896fd
diff --git a/tests/expectations/compiler/compiler/integers/u128/sub.leo.out b/tests/expectations/compiler/compiler/integers/u128/sub.leo.out
index 5399650951..6b9e44f617 100644
--- a/tests/expectations/compiler/compiler/integers/u128/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 769
-      num_constraints: 770
-      at: 46a7cb5b4abbe0c2a583d206d68549c1d2dacbc295a7e98ab603b1e589a748ed
-      bt: 3bd68a594ade714a6dce154fa8fe1b206c3339d591863157d5d4a30e82be8c38
-      ct: 950ff5f999ac2edfb80654ff5270b048ac8a19131c655af6d145533a9ef97c6f
-    output:
-      - input_file: u128_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 44f37cac8d65351e3350836574d0cdf62be693dc4f9bf9a0c6c622603364dbb3
-    imports_resolved_ast: 7c4ab45ad51bbd08a5824c48d3a44d0efa966586a7a09b0715bd80d0bfc3a44c
-    canonicalized_ast: 7c4ab45ad51bbd08a5824c48d3a44d0efa966586a7a09b0715bd80d0bfc3a44c
-    type_inferenced_ast: ae84abeb3382bea3b041194d35adb56ca6199ae066cabb1169de33d689a10d6a
+  - output: []
+    initial_ast: 0321e2d1eba2f636836f78a2d0e729cc025e9f3ea67542574c804c4622845502
diff --git a/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out
index 5c77ad246f..ed17054c7a 100644
--- a/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 896
-      num_constraints: 1024
-      at: 0830a3e788b536b36f271fadaadcc919281b2171d4e18814385b74f6820cb5c9
-      bt: 1fb9bfc22c01a54c08602e7f3883c19b00de1070aa9bad9e9234e322f9043711
-      ct: ee9facabe4c76f5eb89984d3c5cb15f92eaa0cc3b4bc4fdff261aeb36ad0101b
-    output:
-      - input_file: u128_t.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u128_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4165085e599baa84b9b1eab39f48a2a870d339e23c28775713e4d69ccb6f9ee6
-    imports_resolved_ast: 73bf6bdbcdcb1668cd2539c4ecaa8e92976a9edb5671966b84ea3de4706ea52e
-    canonicalized_ast: 73bf6bdbcdcb1668cd2539c4ecaa8e92976a9edb5671966b84ea3de4706ea52e
-    type_inferenced_ast: d1e40191e76382d82487658e2d1d7d93ba843c604ef9d1d6092dc6dfbdb1e317
+  - output: []
+    initial_ast: 500b0ccb3fa320efa606c3aed4e96dd33e7c1858177b06562ed629b6e7be9a7a
diff --git a/tests/expectations/compiler/compiler/integers/u16/add.leo.out b/tests/expectations/compiler/compiler/integers/u16/add.leo.out
index 15d4a6a33b..deddb513b5 100644
--- a/tests/expectations/compiler/compiler/integers/u16/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 96
-      num_constraints: 97
-      at: 370387ad947bfe3a763fa62847b00f95580ec1c1b754cf600e06b313a84044ec
-      bt: c404ca4ebed24418ea98c0994a710e335e65d373114e9e1be5ba5354ced20806
-      ct: 7413addd13f168a5677d482e41bd131e5773eca1ab5c5bd62829ed0b67fd3508
-    output:
-      - input_file: u16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: f79eeec4e78aa0675bc12c0e2482139bb7c9d95aec35fd7a250bb6b234b5a0b0
-    imports_resolved_ast: 4d3039157113027b778d9a0d4b09baae3291349b476e7a1d7d7a66429441340b
-    canonicalized_ast: 4d3039157113027b778d9a0d4b09baae3291349b476e7a1d7d7a66429441340b
-    type_inferenced_ast: d2e57655ceb2825e0989c1b6382d38819ec0157c9eac1002353c2045dca02c0d
+  - output: []
+    initial_ast: 20246e906b0724847c1f313e849ca183da6f2cb8f327ad52f6cad54eb612d9cb
diff --git a/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out
index 4589e0bcfc..9221d3a27d 100644
--- a/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 94
-      num_constraints: 94
-      at: 6ed4469920fbabddf709f8603a84e89ce62e33de0c1728efada4b412dbc9efb6
-      bt: 7a2ed9c91a2df8eed7704b5a71f92b9e20beeade151f02135169ab5f4ca69b6a
-      ct: 09526721ae1dd7355e4608df2b3eabc5c7007bceb8c6b99389aa8160c63a8982
-    output:
-      - input_file: u16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 9d18d94f146bec8b9b8b03b7d7ec21b4510237458979936431efcaa3e8079cc6
-    imports_resolved_ast: 399ff15a5562388e1af27ce952edd6a7f900f27dd86bd6861606392e28991c63
-    canonicalized_ast: 399ff15a5562388e1af27ce952edd6a7f900f27dd86bd6861606392e28991c63
-    type_inferenced_ast: 5b2788d5ba93bb094490cb0709954f9bd274767cc7f691f323d1a4e9f3d954ee
+  - output: []
+    initial_ast: 7a6de12e3bdc5a4d52aa194c98be269e6e0f00f46d8bac6de4837bc236ac806a
diff --git a/tests/expectations/compiler/compiler/integers/u16/div.leo.out b/tests/expectations/compiler/compiler/integers/u16/div.leo.out
index 9f164e2730..3d6b662389 100644
--- a/tests/expectations/compiler/compiler/integers/u16/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 4188
-      num_constraints: 5275
-      at: f1b7abc9150b53dfc10ee7e67e8c985a07f4e0169cd1e8ed234c67c14019f669
-      bt: ce2d469f0b5ace885987081e8dca6a93f663d3f90317850debc36b4fa3ebed96
-      ct: 5ecb4125316e7086ed355d51b635965c19ce3f234575dd3e521c187714c00dda
-    output:
-      - input_file: u16.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 50559110a60077e06f95e68e6e48e5280d6447fc6835d22f345956620a286c57
-    imports_resolved_ast: bb124e9c505f12e815d2257c7ccd42447932a9ebae18298f95d2622175aadfdc
-    canonicalized_ast: bb124e9c505f12e815d2257c7ccd42447932a9ebae18298f95d2622175aadfdc
-    type_inferenced_ast: 1dc63a737d4ba281805a2664e90b71f9a1cd9c72856fa1125625ed73faf18445
+  - output: []
+    initial_ast: c7f8663c2e35a240f8cd40af952012e44860be93cf691e97c2720cab99e29944
diff --git a/tests/expectations/compiler/compiler/integers/u16/eq.leo.out b/tests/expectations/compiler/compiler/integers/u16/eq.leo.out
index d27130cd9a..4c84cde633 100644
--- a/tests/expectations/compiler/compiler/integers/u16/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/eq.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 65
-      num_constraints: 65
-      at: 8c8b795ef4142f2651625b90b3624d24de5138c3fb0981288a8cc5e12bf31f82
-      bt: eba2113bdda3d667d9e8c87f545fe4e2a0143b18a3fff0c1aaa46dd376ed1735
-      ct: f037d279ccea3ca689e05801ec3ba0053b5ce66a1763d4620262ea9b69873008
-    output:
-      - input_file: u16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u16_n.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 511ffd314f687f04e0212876a8c7f712c1cb364ebca375ba076837981a20e322
-    imports_resolved_ast: be45ca00f58e1949cb8453a3ff1a3ebadc0bc656d82df9669fce484c4e5303ef
-    canonicalized_ast: be45ca00f58e1949cb8453a3ff1a3ebadc0bc656d82df9669fce484c4e5303ef
-    type_inferenced_ast: 5982b3acfccd67d0e5c4323b7ca7fe0be03825835e7b9062f81549188b0fa4a2
+  - output: []
+    initial_ast: 3bba994afe74ff41813d814792c6bea23ce00b52eaf9c24f999d2a97d6333a63
diff --git a/tests/expectations/compiler/compiler/integers/u16/ge.leo.out b/tests/expectations/compiler/compiler/integers/u16/ge.leo.out
index 03580c118b..590072055a 100644
--- a/tests/expectations/compiler/compiler/integers/u16/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/ge.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: c3a94f401722187113083aa4cc5bf90ec46ae91b4ac1d0ba51d765590fe51410
-      bt: 43d500d0bdcdf8461bd9605a2665bc17410cb0c7b1c743142aad3a41e74fcbe5
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: u16_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u16_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 8b3b3cc60fb6d0620150ba2cb374a4a5045b31b1ddc2471329cb5dc40055d912
-    imports_resolved_ast: 81e933921cb076d646a083df2aac7237bae183c6e4509cec7c3792325a6b3a82
-    canonicalized_ast: 81e933921cb076d646a083df2aac7237bae183c6e4509cec7c3792325a6b3a82
-    type_inferenced_ast: 513ece2c6c7f3c6f8518ce274f506f5afdc6bdb8dd181c61b1acbd6b59172e15
+  - output: []
+    initial_ast: bb07a170668679fe07c1a41c4c7edd601b55d9659bacbb41e55adef5d347fdeb
diff --git a/tests/expectations/compiler/compiler/integers/u16/gt.leo.out b/tests/expectations/compiler/compiler/integers/u16/gt.leo.out
index 6d6e957540..719a03340e 100644
--- a/tests/expectations/compiler/compiler/integers/u16/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/gt.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: 800702d0776e95fee2689e79fcfe570db9fbd128310fc88565e72d322bea0407
-      bt: 417dc25c14bf36db410808a30f2263083728f1158cbf74a81bd8d8b5cba878d9
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: u16_g.in
-        output:
-          registers: {}
-      - input_file: u16_f.in
-        output:
-          registers: {}
-    initial_ast: b39c3452491e3b282bbfec9ef7412d66eb793221f4f449c4a3f458b380da18d4
-    imports_resolved_ast: 7acecb35625cbe71ee3aeffeea7e4a259d83f8bf5ce1112eb21e3629fe0d6289
-    canonicalized_ast: fc89f366f169a3c6fcd0720047dd1efc9f9ed992d42a409749d590dac6f58ce8
-    type_inferenced_ast: ea12126ff6c63d5cd3a0b4d655edd4a91d52324763cf1d7ef58c5d8f35e17587
+  - output: []
+    initial_ast: e8fdcd4e4c84eb09ee54fe8bf47696445ba16c4c8c64760bff691e0dceba1f39
diff --git a/tests/expectations/compiler/compiler/integers/u16/input.leo.out b/tests/expectations/compiler/compiler/integers/u16/input.leo.out
index 57e561d89e..efc04f0d2c 100644
--- a/tests/expectations/compiler/compiler/integers/u16/input.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/input.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 63
-      num_constraints: 63
-      at: 781fbf42db29f7fa9c21d99e21d8f011ec22b33ad26d3f80438687aafd462285
-      bt: abee7b67c55170fc3341444203a9a70e68690dce751aa36d3e91f1cf7ceef73d
-      ct: 51c18ee4216feeb01d0b0d661dfeb294e7e100873586edf79be89c8b54d9e168
-    output:
-      - input_file: u16_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 7834dad6d671b8945052c45c7b90d5a72d5edab4ccaada223b5dfe0a6e14b583
-    imports_resolved_ast: 2cbb0dd559b4c55e63a8c8e6a91a8b5f8723d390bae391557ce627cceb6bf876
-    canonicalized_ast: 2cbb0dd559b4c55e63a8c8e6a91a8b5f8723d390bae391557ce627cceb6bf876
-    type_inferenced_ast: 90e9bee789e09f49239f940a1f68b469e8b9df47ea845b28a5e2872060d31a31
+  - output: []
+    initial_ast: 96295fc5f93b5bc0744f6bf8f780c117a2391e75572a78233b19dd35bef7d599
diff --git a/tests/expectations/compiler/compiler/integers/u16/le.leo.out b/tests/expectations/compiler/compiler/integers/u16/le.leo.out
index 4f55f62823..19fddf1540 100644
--- a/tests/expectations/compiler/compiler/integers/u16/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/le.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: ae8d8223fa654f971c969e68e926621d014e80b200e28a3bcb53f7e0760af811
-      bt: 7549aaa9e0eaa389b14dbf7a0c15122a1cd9707f492b8bedee98ae8f09bd9142
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: u16_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u16_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u16_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 4a0ca295466a7cd891ae2b06411655143bb4149036422a0bf176d541dd1bfe09
-    imports_resolved_ast: e3672ef384fcfea8e23dde83571fdfe3fd23fc2838899c79169a93d6828d08e6
-    canonicalized_ast: e3672ef384fcfea8e23dde83571fdfe3fd23fc2838899c79169a93d6828d08e6
-    type_inferenced_ast: e9cfbad7c5ee1ecba6a5153663f83548378987688766258d17ba512a55b66608
+  - output: []
+    initial_ast: b285cc3429a247bb616cec8b1cef77f4f2da042898fa66f80952496b09b3f9db
diff --git a/tests/expectations/compiler/compiler/integers/u16/lt.leo.out b/tests/expectations/compiler/compiler/integers/u16/lt.leo.out
index 8253ad1d8b..88381d678c 100644
--- a/tests/expectations/compiler/compiler/integers/u16/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 113
-      num_constraints: 113
-      at: f7f35cbd164c83cc4421fe89d14a349b70962c362186e237daff824054459d17
-      bt: 1bbe7b7f496597bd94e86ea0452146e8360ba0b2b2d922a81cfc51b4b5fa4fda
-      ct: 92784334fb47e5a53eb972ec42d95f97470117bb6839cf2d46e8fcbd38a662f9
-    output:
-      - input_file: u16_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u16_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 821c71172d244937d8475e5420e63013499c5cc11352098feb6645861767daa4
-    imports_resolved_ast: 8582a4a0a823bbb4fe8a6c74f0c63c9f52c1f09439b9b3eb8baa3583725263f7
-    canonicalized_ast: 8582a4a0a823bbb4fe8a6c74f0c63c9f52c1f09439b9b3eb8baa3583725263f7
-    type_inferenced_ast: 1d53f4da39376ec8a97864d73ba52469452d4d6aea6d2defbaed5b0cd0d828eb
+  - output: []
+    initial_ast: af24f294c4659e6cf55e60715a623d72cb16bf207bcd18f6adf42f5cde4e9cf3
diff --git a/tests/expectations/compiler/compiler/integers/u16/max.leo.out b/tests/expectations/compiler/compiler/integers/u16/max.leo.out
index fdb19d61b7..970b6339e5 100644
--- a/tests/expectations/compiler/compiler/integers/u16/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e207b15051f3420736160b76494a820405bd0e5f5af2f3b3992e6081c09238f3
-    imports_resolved_ast: b2ba20c603e8c6ccb9e0ed61c1e41d5100df7f61f983b6d97a005892ad1b4a74
-    canonicalized_ast: b2ba20c603e8c6ccb9e0ed61c1e41d5100df7f61f983b6d97a005892ad1b4a74
-    type_inferenced_ast: 35964070f2d2caee13c897c1b56539ee5c6804345ea9f61cbe4ab602652cbe0f
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: d91a6dfa2b7af5e96464d67ed42b7a8a64aab01ae160ff563ee5b104aab7e16c
+    initial_ast: 4be08dda6a676fcba8564f45f36d500c6e74260726c3aa97a18760915b04cb1b
diff --git a/tests/expectations/compiler/compiler/integers/u16/min.leo.out b/tests/expectations/compiler/compiler/integers/u16/min.leo.out
index 6e88e4f272..8445630cbf 100644
--- a/tests/expectations/compiler/compiler/integers/u16/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4915247fc348948d057f58eaee07daf48006051a5f6e76cb606e44256a393dee
-    imports_resolved_ast: d9f5d88829ba2700fe2670480099224e9f6177b3c5106a440ffc8bfea094a0ec
-    canonicalized_ast: d9f5d88829ba2700fe2670480099224e9f6177b3c5106a440ffc8bfea094a0ec
-    type_inferenced_ast: 2451ab13c6c8d8a571ed4034768d14a9be0c68cf232b7e11216f03c6e22dd263
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: f435330451c9aa46b1fde2c4f6721e9aaedbc923fa9c87e9fdf786985c441028
+    initial_ast: 8786a78aa202d6d684930a22b5fbd0f3a9a2db81e3a8776a8de4496d69ef2443
diff --git a/tests/expectations/compiler/compiler/integers/u16/mul.leo.out b/tests/expectations/compiler/compiler/integers/u16/mul.leo.out
index f63656137f..7c00cc3f70 100644
--- a/tests/expectations/compiler/compiler/integers/u16/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 899
-      num_constraints: 1172
-      at: 26bd7cae34fa05bfe268e134e02dad80d3978fdbcf60cecc47f41102c659c539
-      bt: f660e7fad189d6e454e78216e0128e07d47145da1eeb6b53ed5a73cdf4fe9888
-      ct: 267549c071634baac2f681f050ede9777ca6d302d8a0ca04c60f6f60e497d64e
-    output:
-      - input_file: mul.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 2d29c30157f229fcc4fbe1d303a34be4f1b4425bcc2b3eaa655c486dee6fe9ca
-    imports_resolved_ast: 78819567e8432e58a0bd0035ec78aecd173fa702d0f8c05c7ec957ee66924d5f
-    canonicalized_ast: 78819567e8432e58a0bd0035ec78aecd173fa702d0f8c05c7ec957ee66924d5f
-    type_inferenced_ast: 4a9a5349f53026d9a66c7382cfa852ce34683399f55a5a3868728eed31b28764
+  - output: []
+    initial_ast: 1f76a40705982a61b4d014e7bc91b4da748c41a48fd0f66c388c88eb33eeebaa
diff --git a/tests/expectations/compiler/compiler/integers/u16/ne.leo.out b/tests/expectations/compiler/compiler/integers/u16/ne.leo.out
index 5d94bfa0ea..555f937eae 100644
--- a/tests/expectations/compiler/compiler/integers/u16/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/ne.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 65
-      num_constraints: 65
-      at: 83a4d089927a9811a9d4ed5b3ee2e50e395cd598de865653be04a2c51904b072
-      bt: 30bc7cfbc53a2e928ca0310b6041f1f1548ad7c1197ffc9301b46522122e5561
-      ct: f037d279ccea3ca689e05801ec3ba0053b5ce66a1763d4620262ea9b69873008
-    output:
-      - input_file: ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: ac7868e2b7e8513f2828a722ced2780d8b416f3d568855c9186d4ddfaf98335a
-    imports_resolved_ast: f376edea71aff6a897b2c2fbb5667573fa8e494941b5c46e2bfce932c80012ec
-    canonicalized_ast: f376edea71aff6a897b2c2fbb5667573fa8e494941b5c46e2bfce932c80012ec
-    type_inferenced_ast: b3f5fd266262dc698f668420135d953c7d1cc313a45ed0fc365c5919926e14c4
+  - output: []
+    initial_ast: 5eac340764ff835dd1b4aa7aec32faaf2ce37e2c0edf799575b206ccaa9eb667
diff --git a/tests/expectations/compiler/compiler/integers/u16/sub.leo.out b/tests/expectations/compiler/compiler/integers/u16/sub.leo.out
index 28905bf2c2..829bc89eef 100644
--- a/tests/expectations/compiler/compiler/integers/u16/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 96
-      num_constraints: 97
-      at: 370387ad947bfe3a763fa62847b00f95580ec1c1b754cf600e06b313a84044ec
-      bt: c404ca4ebed24418ea98c0994a710e335e65d373114e9e1be5ba5354ced20806
-      ct: 81a951fd0bc0072abf02978c9c6547c090936985ea19b50e3c148595d4870599
-    output:
-      - input_file: u16_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: fdc491eef77e08748aedf642306e58898b8e008eef5d0ea0a76913a127056f01
-    imports_resolved_ast: 92f4a474f4cfe43d40c8251b0f4588ac444d6bf054deb9e3c7c4ccfb0c3b9072
-    canonicalized_ast: 92f4a474f4cfe43d40c8251b0f4588ac444d6bf054deb9e3c7c4ccfb0c3b9072
-    type_inferenced_ast: 6e740118a0d730fc19fc4cca691b75cefca288ebf799d82c3d82050f0f66103a
+  - output: []
+    initial_ast: 2112ddaa6ca4f2b78137f7d5ae6834c00303bb61fd8c7f6a520f34fbd73ffcdd
diff --git a/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out
index 7a3d823545..cb0185861e 100644
--- a/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 112
-      num_constraints: 128
-      at: b0a107f586de648c8446ae3246117de3b20ba9c0249d261f234106809d112f0a
-      bt: 0e5faacb5d80488eeda9e7fa79ddd96e54c010e0e98571449f79cad816cc18a2
-      ct: 2b3428d7c7335edc32ab219fe11c92e215d70a52c89434de349f4951561d5795
-    output:
-      - input_file: u16_t.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u16_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 278531860c20879b7dc6b322c96effb93cc4f01ebe350b4a067dc6377d457d2d
-    imports_resolved_ast: 00cb40515557697ee25dc22dcd6a5431f7c60709449e855f6b58e5b2e79f4376
-    canonicalized_ast: 00cb40515557697ee25dc22dcd6a5431f7c60709449e855f6b58e5b2e79f4376
-    type_inferenced_ast: ca1b6a42940b5cca27fe6d027ad28f32ceb7188ca59030bd87db7a63a3427a10
+  - output: []
+    initial_ast: 7038765e541644c1cc2bcd420e5c1da92bca5f7a0e9796785d3f80e6923dfb84
diff --git a/tests/expectations/compiler/compiler/integers/u32/add.leo.out b/tests/expectations/compiler/compiler/integers/u32/add.leo.out
index ab8e4d27dc..fe74d4c4b4 100644
--- a/tests/expectations/compiler/compiler/integers/u32/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 192
-      num_constraints: 193
-      at: 6cb7221b25d9868ec3dfc97292d22e7b9b7e7571ffd39a14523c2dcd6ee63c60
-      bt: db97ec2b7f2b40889263b26fc6f01de19f78a4b007371ad2f54869e9a31d21db
-      ct: 2773a172ee849b2e45b68f0c367651fc5a0715e9415d2d97601d41e540d713d0
-    output:
-      - input_file: u32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: a52b50732b49d6dcfb8ee52f657c5febdf07dbc9762b8ed21361ed62d55403b4
-    imports_resolved_ast: fdb1d563f912d4e9cdd1affd057c1d0d3312e4e9ced2ef620b81c2e261f8a890
-    canonicalized_ast: fdb1d563f912d4e9cdd1affd057c1d0d3312e4e9ced2ef620b81c2e261f8a890
-    type_inferenced_ast: b57238c71b588f20b657f18b451899603e675e685624c8bcee5f7f8be0cf2b6a
+  - output: []
+    initial_ast: 6f17e86164961b0f5dd63f426dfe5a1c7097b7042ce9c80d9cd3e2b3c7918ab2
diff --git a/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out
index cd63ec33ec..5f89074d30 100644
--- a/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 190
-      num_constraints: 190
-      at: a1a80b7c355e1fa32c2136c4dc7a0fd0670affbdda869a9161a3a69f396c6b9a
-      bt: fbf306d0d13bf3d40926ad7adc07f122cb8d065e7e5d55f3416ac30d7ebe7a7c
-      ct: 97e2acff1b76912c52107342393ec04a09af81353a25f7ce330b8492f41381cf
-    output:
-      - input_file: u32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 74a001c94eea3e68e9e6c52b8fe5988e8c86c0d87225e3ad4e9af046f1239bec
-    imports_resolved_ast: b347a6e5d952ed3a8556a2340ec6d330a01e88ab3e052224565b5c4729b2c12c
-    canonicalized_ast: b347a6e5d952ed3a8556a2340ec6d330a01e88ab3e052224565b5c4729b2c12c
-    type_inferenced_ast: 3ed675b31f4db0528d81109c52f66ad9f64892340a9db2e1d26f0056a211fb33
+  - output: []
+    initial_ast: d7cb42b47e5175b91dc490ff52a54d4275d984418ea0d516c648ce5357b224ed
diff --git a/tests/expectations/compiler/compiler/integers/u32/div.leo.out b/tests/expectations/compiler/compiler/integers/u32/div.leo.out
index 3937d45865..8e5b46b637 100644
--- a/tests/expectations/compiler/compiler/integers/u32/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 16572
-      num_constraints: 20795
-      at: 4f6450d5e7991f179adb08e1b026e453c4c6abd66f38ea4a175a888b3c1bdbf1
-      bt: 3f6fd055b4a8dacc1138d93848e7ea7424a5bc64af98ad3ee1e6e5ff4719e3c3
-      ct: a5941a2d70ce52e20004890f9a7198b0f22c93803e9d159824e716ff2ed2d223
-    output:
-      - input_file: u32.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 5c3e29bd5c67718c4bb2bf64e09652eb65236768baf71e25fd34dc98a588dd1d
-    imports_resolved_ast: f9d3cd6fdf166877a087fae58fdeae686309a20672abbdeb07a138c261d5b882
-    canonicalized_ast: f9d3cd6fdf166877a087fae58fdeae686309a20672abbdeb07a138c261d5b882
-    type_inferenced_ast: 50b4c4fadd5a252be2f5d5edc4606c5dead11bff0eb8fd6c3626d5c5f1c052ae
+  - output: []
+    initial_ast: f0756849f355e001af5182cb5b788cc796745499258548e421e5187e177f275f
diff --git a/tests/expectations/compiler/compiler/integers/u32/eq.leo.out b/tests/expectations/compiler/compiler/integers/u32/eq.leo.out
index 4c767e708a..51b1f3ba60 100644
--- a/tests/expectations/compiler/compiler/integers/u32/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/eq.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 129
-      num_constraints: 129
-      at: 4ce4f2bf481c4f7e47396527999e129066d1f157413884f91ced3d2b525a3187
-      bt: e63628fc48d1e71ea44830c010e442f577239e29f7ffada0d8df34c28e67f107
-      ct: 9f4c72431c0c7c03e216195a071c971c53deed8e3bfce450bffb3a6fad7418d5
-    output:
-      - input_file: u32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u32_n.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 38ebb13b7854ccfed3be886b213cb6077fb8327122b028ff126fc7de6c935c1d
-    imports_resolved_ast: 7d7d29be9012cd73cd4fe56bb9bdc8a5db1f3b8520081fa3b87817fe02500fcf
-    canonicalized_ast: 7d7d29be9012cd73cd4fe56bb9bdc8a5db1f3b8520081fa3b87817fe02500fcf
-    type_inferenced_ast: c577750bf071ef1c6fdf8626999f75d0c460452123a891c8b7365c7d90281b46
+  - output: []
+    initial_ast: 727e4ea81a78093866181fe291c97cc7dd006287a09f808402cb6c79d5ce1654
diff --git a/tests/expectations/compiler/compiler/integers/u32/ge.leo.out b/tests/expectations/compiler/compiler/integers/u32/ge.leo.out
index aa6803e6bc..0b0ca3453f 100644
--- a/tests/expectations/compiler/compiler/integers/u32/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/ge.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: b09f4d28fdd36c49a340f1d95f86886acc00f8e584a50dd3c98bf6adc63bb13d
-      bt: 37e95d209b9ca56b6ed5debe1d21d2c72e48d6a0898a59833bdf3daf2ce1c96b
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: u32_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u32_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d2eed17b08af601ae711735783d783389d3740932fd0c79a6357197d0399836d
-    imports_resolved_ast: a4698be1c2d017ee15fce6f555d0638658f9392a0fea31ccf5a2e25b3fc4f754
-    canonicalized_ast: a4698be1c2d017ee15fce6f555d0638658f9392a0fea31ccf5a2e25b3fc4f754
-    type_inferenced_ast: 3b3bfc77c223e94b2bdc0a7075d18dad1765c848a529a410eeee9b108e0e9f35
+  - output: []
+    initial_ast: a5febe72565e2a143d4f2069cc6e5f3a75d3ccdf2e7f4a4af66d3600b9be26fe
diff --git a/tests/expectations/compiler/compiler/integers/u32/gt.leo.out b/tests/expectations/compiler/compiler/integers/u32/gt.leo.out
index 49eaf7f1db..56c9a06248 100644
--- a/tests/expectations/compiler/compiler/integers/u32/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/gt.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: 63019ae9d78e708c481c3ed306a9fb7e5a4ddc8db20d1a2a48e2e161aca53542
-      bt: 3a99f6fa32ac0358a66ac53d0cef7af442097730b5f56ec8f8d9974108f25215
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: u32_g.in
-        output:
-          registers: {}
-      - input_file: u32_f.in
-        output:
-          registers: {}
-    initial_ast: ed78ebbea162628506777785af500aee6f82538b038ea68315d60e3cb2f12720
-    imports_resolved_ast: 87843691eefe68588dc895849ccf18e9e96ef17bfe7a2e72ee156119f63a6bfe
-    canonicalized_ast: 3cd791a17869998c0112be9e9c60b08b2f0b79de53184ac1829943576fe7cccd
-    type_inferenced_ast: 9aa9e214da0364e81140dff3c699225336ea543d75ae719408664a77f29965f9
+  - output: []
+    initial_ast: 958df6542b0120796fceb88eedf0a64bb50f695d0e11550c6902a40a35c98d9a
diff --git a/tests/expectations/compiler/compiler/integers/u32/input.leo.out b/tests/expectations/compiler/compiler/integers/u32/input.leo.out
index be339ca516..feee9a1647 100644
--- a/tests/expectations/compiler/compiler/integers/u32/input.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/input.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 127
-      num_constraints: 127
-      at: 051151c1ab89f2c0ff0fe5d336668c3fcd6dc4744d1f5b8e135dcb7bf6a6195c
-      bt: 6b92443726163ac0fc32f7c9edace0ec8369e793d24105d93d121cb0bd5c3128
-      ct: 7cb2d3f0ccfb9a2e747c6a05bdb52812c4539c836ff62c4e555fac13ef2084d4
-    output:
-      - input_file: u32_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 07f29a46a134b05cad073cf812f4c7df17e013e67c5b1bab70e1b2928da78754
-    imports_resolved_ast: fe0e6a3656f8235b3c0c6cc738104cd67e8c33cea6b561b47360d5ddbb6e70ca
-    canonicalized_ast: fe0e6a3656f8235b3c0c6cc738104cd67e8c33cea6b561b47360d5ddbb6e70ca
-    type_inferenced_ast: e34118a02471d95e5ba3ed14ec4267e2b16251c99d6964f5cfaea0d39c198ab2
+  - output: []
+    initial_ast: 193c6dd893f78d99cfba6afa37e9c868ff428135498e5879725ba40b6d71d156
diff --git a/tests/expectations/compiler/compiler/integers/u32/le.leo.out b/tests/expectations/compiler/compiler/integers/u32/le.leo.out
index 1e9bd5688a..fd4de44b8a 100644
--- a/tests/expectations/compiler/compiler/integers/u32/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/le.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: be1f0e82bb31df7cf90717f08c3dc7f68f997c41433d5971d2d0f250faff6847
-      bt: 6e596324acc04a48f980f6248f44cbf54a25671a41051bbffc087505edbf031f
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: u32_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u32_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u32_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 1574604f93d7ccc5c02dff7a24d454e57dec810a902bd47a45d2408eec1f164a
-    imports_resolved_ast: 39cbb60b95039197a314a33ca4d4d3c3721e5de0ce1f10dfdc3094f3f88465f9
-    canonicalized_ast: 39cbb60b95039197a314a33ca4d4d3c3721e5de0ce1f10dfdc3094f3f88465f9
-    type_inferenced_ast: 26a2f5ff920d84fe5b7a76aa2a4deb10ff3cb016549d523751fcb1ed0b92df2a
+  - output: []
+    initial_ast: 3fa3d0d0cf219277d2a244dfe54616d9874fe5db85ee575cd588f2cb941f9b3b
diff --git a/tests/expectations/compiler/compiler/integers/u32/lt.leo.out b/tests/expectations/compiler/compiler/integers/u32/lt.leo.out
index f10bcebf9b..a3c8ed8417 100644
--- a/tests/expectations/compiler/compiler/integers/u32/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 225
-      num_constraints: 225
-      at: aa2fc0bfe167bccae6c9eca820227eb4b981007c89579a32d3b5ec4a8268f30d
-      bt: 953b00df7ba097904b71a60403e38d69eece1a6e0b6791b13214cb6ea803fbb3
-      ct: d7067f500143a40e015fd1f4447a4ea5b9ee6ebdf007e08be51772a8a2b672c3
-    output:
-      - input_file: u32_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u32_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 175428db299a1c5c782ac4670e01ad9eb53783aa615908efd022b16cbd9ce231
-    imports_resolved_ast: 98163c6253763da35e63bba319ad5e3b12f2fad32d6a35efdbc455c534e1b3bc
-    canonicalized_ast: 98163c6253763da35e63bba319ad5e3b12f2fad32d6a35efdbc455c534e1b3bc
-    type_inferenced_ast: d03bdfad533b32ed3a0db5ea5b3313b728bf7b6c5ffbdd650fb952cee3baa5a9
+  - output: []
+    initial_ast: e92898b452586210d8301fa2ce92916f7aa93799b591cc47dac0dc800b71107b
diff --git a/tests/expectations/compiler/compiler/integers/u32/max.leo.out b/tests/expectations/compiler/compiler/integers/u32/max.leo.out
index f7f9d386bc..6900378df3 100644
--- a/tests/expectations/compiler/compiler/integers/u32/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 128bf7414c73a6c6a83f589c15f1da4aa337a263424f6d4aef3eef986cf0c509
-    imports_resolved_ast: 20d3add1ab493bfd4330b98c553b713aca849506c042757b4d00b0e96a2053e4
-    canonicalized_ast: 20d3add1ab493bfd4330b98c553b713aca849506c042757b4d00b0e96a2053e4
-    type_inferenced_ast: 36bc5df4003967c444c27d01efdd1816d3b82c2287764c61871eb63bd548388a
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 63d7a40e7daa847fe549f5aaf8dafc71cb8b03b479a32cc69b77bcaf7ec6940e
+    initial_ast: bf00293b98ccf28f27e12e3db5ee701211b8fa46c2dc3f0251f8e128bc8e93b1
diff --git a/tests/expectations/compiler/compiler/integers/u32/min.leo.out b/tests/expectations/compiler/compiler/integers/u32/min.leo.out
index ee6ea35d07..8520a07186 100644
--- a/tests/expectations/compiler/compiler/integers/u32/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b61059ff0a4e51ecb206c5bc0c46f73bdc9fd93d3ed45ed80de2499437492c81
-    imports_resolved_ast: a8cd7763364e84978872d4c479cb8fc71a33797e4543788712c2bd16b078617d
-    canonicalized_ast: a8cd7763364e84978872d4c479cb8fc71a33797e4543788712c2bd16b078617d
-    type_inferenced_ast: 0e19387bcdc9b09baa690b75a4447d6494c81f3a01f675e769513624be7f962a
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: d0f3c0af6be0e36435a02c64a5bb78ca1d50bb432b0cdc9baafea052ec9e7548
+    initial_ast: 435a0e066320de81f39e8f2950d461a74dfbaad5900e55caa0a8c5c29dced363
diff --git a/tests/expectations/compiler/compiler/integers/u32/mul.leo.out b/tests/expectations/compiler/compiler/integers/u32/mul.leo.out
index 6dda73e9c7..86f1f5b54c 100644
--- a/tests/expectations/compiler/compiler/integers/u32/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 3332
-      num_constraints: 4389
-      at: 2edbd98e47b4ed8cd7d7c761594353aa4ae9ca443e4d1e1f43c1e89e61955a13
-      bt: 127cc198f6c432cd8add8297902708b759e48ff05fb8c042a356cb5bd81524a8
-      ct: e4cb5fbafce0c6aae444c1ddf3f1883ca3df62c790a4baa8a3755bd75bb42f49
-    output:
-      - input_file: mul.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 7be7cfd76dc22fcb15d769ca30853daf28681c53878d86f4afc8fc339189e5ce
-    imports_resolved_ast: a47f8c1498bcd1b085bc59fa6a606b5fc8f5fa760c2294fba5b6d62ca9eb2825
-    canonicalized_ast: a47f8c1498bcd1b085bc59fa6a606b5fc8f5fa760c2294fba5b6d62ca9eb2825
-    type_inferenced_ast: 7860be4040238272a8b30cc25406e06c4374d5192fe37f8cdd10352171eebbc7
+  - output: []
+    initial_ast: b4f789d7742023756857cd3da5560976f63adac5d0ff178cdf74397e8f597915
diff --git a/tests/expectations/compiler/compiler/integers/u32/ne.leo.out b/tests/expectations/compiler/compiler/integers/u32/ne.leo.out
index 7f23506333..3b4489fbf1 100644
--- a/tests/expectations/compiler/compiler/integers/u32/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/ne.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 129
-      num_constraints: 129
-      at: 6cde17fb079861287679ad93d9ed9125cfc21000431bfeaf5a2054360ce51ef7
-      bt: 1178e67ab79eac96592f17313168c4300d53e89ab571025054d53d19dfdfd1b8
-      ct: 9f4c72431c0c7c03e216195a071c971c53deed8e3bfce450bffb3a6fad7418d5
-    output:
-      - input_file: ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 41ee9bc72d07290bd247a8a1c9c9c2814f1329e9d35d3b3f4d312b545928bc76
-    imports_resolved_ast: 84d21ca318be95ce5602e1f37de370d58a9d33502d5353c0082c6363236e2a44
-    canonicalized_ast: 84d21ca318be95ce5602e1f37de370d58a9d33502d5353c0082c6363236e2a44
-    type_inferenced_ast: 42cf867a3a9b04c1949c17cfeae8837f2e8685457b713fe3d3dd32b0196b4df9
+  - output: []
+    initial_ast: ad34b77b28d1ce6696e7696d14bb8c5ebb6bb194d67a7006b405e8566ff5aa2d
diff --git a/tests/expectations/compiler/compiler/integers/u32/sub.leo.out b/tests/expectations/compiler/compiler/integers/u32/sub.leo.out
index 5431f6d871..1363261ff5 100644
--- a/tests/expectations/compiler/compiler/integers/u32/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 192
-      num_constraints: 193
-      at: 6cb7221b25d9868ec3dfc97292d22e7b9b7e7571ffd39a14523c2dcd6ee63c60
-      bt: db97ec2b7f2b40889263b26fc6f01de19f78a4b007371ad2f54869e9a31d21db
-      ct: 0a2d17cb1ee78051a702abbb771d34100ff951ae893e69981ee2507b5aba6671
-    output:
-      - input_file: u32_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 64c092c5fda243b9d461a33f4e913a7f25e517f92bb8014d282498a9905c65c0
-    imports_resolved_ast: a2642df69ce7da50cfe2fec26152b542422ee492a4b5890403adc137212c05b1
-    canonicalized_ast: a2642df69ce7da50cfe2fec26152b542422ee492a4b5890403adc137212c05b1
-    type_inferenced_ast: 919ed1742b5c4c05052f75421931df67d281ecf06e29c41b3cf5d8cdbdcaa385
+  - output: []
+    initial_ast: c8c2b4028587a62f1404c9298e16883c2b3326f5132d6b6472157f658f247172
diff --git a/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out
index 49dbb9817e..1eb27114b0 100644
--- a/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 224
-      num_constraints: 256
-      at: 45301188494f0c65b2e88eac9117ba7367e772ea34e9b8f34bf3d49dbd1dd067
-      bt: 35d9c47cfd4fc137760d0ee411c0b097541cab7aae2b0a9ea83b368328fe5c23
-      ct: 032da4c7df957d9ca89b5395be6e1c84cab7d19a78abe1b02bb37b26ca65b0e4
-    output:
-      - input_file: u32_t.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u32_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4f0e1b56ef89d6870fd11dac53913bda36cbf279a6dd3e33a62f402a69b8af6b
-    imports_resolved_ast: e04cc9d209932f818a0167cace2171a56b046454adc48f9dd54909d06d27bdfa
-    canonicalized_ast: e04cc9d209932f818a0167cace2171a56b046454adc48f9dd54909d06d27bdfa
-    type_inferenced_ast: 4c3195a4199f99a4b1028a0de7c2f07f9676fc89b00e0a4c61889bcf1c10a0bc
+  - output: []
+    initial_ast: faaa3b7c11b7ceeb8a2f7a23ab0d1db17d933758e1a6c42925f7e21d9cb313db
diff --git a/tests/expectations/compiler/compiler/integers/u64/add.leo.out b/tests/expectations/compiler/compiler/integers/u64/add.leo.out
index 7e4bdbe7f8..600d8ca010 100644
--- a/tests/expectations/compiler/compiler/integers/u64/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 384
-      num_constraints: 385
-      at: 03f552addf49f5f1c8402d8af8dd733983efa7fd3436d677d89d74a1c6548962
-      bt: 8cbfb6559664a4d73354d718f19247484a98da79ddf83350c1a070cb14fda399
-      ct: 0715661d18c8621f5c33eee669d8d659ee3a767d6ef515102191cdc19577ac02
-    output:
-      - input_file: u64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 74daf6a83fb1fec83518eefbeec0b953b6caace4130fb2a75b54b88cf8f2c393
-    imports_resolved_ast: f5909afa991c29700a197c0b35759eb39ce589e610bc327303dd6b4bddc768f4
-    canonicalized_ast: f5909afa991c29700a197c0b35759eb39ce589e610bc327303dd6b4bddc768f4
-    type_inferenced_ast: b7563ff4ce1918c92f2c342b450af35c39e35e39fccd56eee101a65b110a0f43
+  - output: []
+    initial_ast: 437ed1d3a2f85fc715a4094f9336df301ee7fe1ba9d63e06a1662c97c3f07345
diff --git a/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out
index 72544aaebe..93b9c8f2f1 100644
--- a/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 382
-      num_constraints: 382
-      at: 9d064db37e95194967d924cd23aecd5ddd20a17c31a48470f0b624f5937ff750
-      bt: 21d30b45426d69b866ddb826df03348580bcd064b2586cd615e3c270d7b85397
-      ct: bd9112f8b3135d07d5b5a2491f17add20c7ca9d7881df20e3ff47918d208e75d
-    output:
-      - input_file: u64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 72b03d294f1f9e3d28a7546301e2e55427549c827a61c42a911fc183bb76a566
-    imports_resolved_ast: 3eeeb21da98b1429de4bdf093ed3af22493bfe20af8cfcebc5ec0950f779cea6
-    canonicalized_ast: 3eeeb21da98b1429de4bdf093ed3af22493bfe20af8cfcebc5ec0950f779cea6
-    type_inferenced_ast: d647afb0addf3a7b4cac81e56c13bc4573cdf8930ee3d38fd59c552ba33e58b4
+  - output: []
+    initial_ast: 893b3eed927bec646c1eb8add5aae68a13ece875ae1869d404281e73f5358c2c
diff --git a/tests/expectations/compiler/compiler/integers/u64/div.leo.out b/tests/expectations/compiler/compiler/integers/u64/div.leo.out
index e0aac7933b..b0b681f7f7 100644
--- a/tests/expectations/compiler/compiler/integers/u64/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 65916
-      num_constraints: 82555
-      at: 071831a1f073f5ba74377785488634267645562682b9dbeaafd1f65e39bf17d3
-      bt: bcde87dd40262305d4c32a5949fa939d1b83f6ae51143eba7c147eab61314987
-      ct: 7c81f1ec1d5e9746863df8f4128342df3b6ad3abe2397c2274a0c3fc45750094
-    output:
-      - input_file: u64.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 7297486adc4a5495f8267cf1a66ccf0ff0388c7aac6fd3f17cc23a0aea8eb1f3
-    imports_resolved_ast: f7ac5dfb5f27b960e7056bc908aca0e14629f05cc2aa383078e72d28fd2be749
-    canonicalized_ast: f7ac5dfb5f27b960e7056bc908aca0e14629f05cc2aa383078e72d28fd2be749
-    type_inferenced_ast: c8fecbab3d51900356e34ce1c73e1cccd6cd587c11d3a272db37a432943b3bcb
+  - output: []
+    initial_ast: b1506f24dec921f4767cad398fb94c42ad773be1a034427e8377a4ffca6fd5cd
diff --git a/tests/expectations/compiler/compiler/integers/u64/eq.leo.out b/tests/expectations/compiler/compiler/integers/u64/eq.leo.out
index 826a2b3916..1f57096b72 100644
--- a/tests/expectations/compiler/compiler/integers/u64/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/eq.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 257
-      num_constraints: 257
-      at: 30dc67aa22cadc6e5ec8c73e0096443263121e29adf46bb33ed310b07765ff6e
-      bt: 1aaee32179419b6185d75c5745bd13c7c8ba869bad0132405ef1b28915bfe5d9
-      ct: 8edd5528a862bbd5590cfbd0d52871e395cf73e3a22c70839571b36506fbe3a7
-    output:
-      - input_file: u64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u64_n.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 4a94672c1c6414bc336bfe0261f053cf34cc945416a765b18fb8820ac49f37b6
-    imports_resolved_ast: 69ea39e60137c5b7564c6fc308e180357bd7a505f58bbea6746a5ea141e3c7a6
-    canonicalized_ast: 69ea39e60137c5b7564c6fc308e180357bd7a505f58bbea6746a5ea141e3c7a6
-    type_inferenced_ast: e6540925324f99db091717123047521d5c81e9be735b6b7f5b2bb84a9fb45933
+  - output: []
+    initial_ast: 0895f12f7a9102ae711b05156078d0c06db88469c1134f1afaae1571f6d55dd6
diff --git a/tests/expectations/compiler/compiler/integers/u64/ge.leo.out b/tests/expectations/compiler/compiler/integers/u64/ge.leo.out
index dd462f8869..221d863135 100644
--- a/tests/expectations/compiler/compiler/integers/u64/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/ge.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 43b83eacdd7b17b700c040da76128375494a8f013882c2cd401cf5c9ceeef74a
-      bt: bd9dd7ede35a39f80c5b4b97dca300dcd37110f2270cb25d8935d964db04e2ab
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: u64_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u64_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d1c7b45df4e2596bf7e1df7cdf0f0259ade8350c77f3d1fcac314e63f9532cae
-    imports_resolved_ast: 38b4fe80a54ca2aded15f141935232a259f241afec9e96604e6964960962c3cc
-    canonicalized_ast: 38b4fe80a54ca2aded15f141935232a259f241afec9e96604e6964960962c3cc
-    type_inferenced_ast: 0cac035a12c203fc59289aadc56cf841c1ea9ebee80a7022ebad5768ef7942d8
+  - output: []
+    initial_ast: 540d8224f3c5b190acec728377d6da5c4e3697e905f445664ed0cb5ff5e798af
diff --git a/tests/expectations/compiler/compiler/integers/u64/gt.leo.out b/tests/expectations/compiler/compiler/integers/u64/gt.leo.out
index 62dc603510..7170c994e5 100644
--- a/tests/expectations/compiler/compiler/integers/u64/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/gt.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 961c527f11c9cd68f1dff327e550127f82fc974a4b92c1dedc47a2f7426590a9
-      bt: fcf7dc96d2a270e2f93cf6e19151e06c10a1b5361d5ac92a8cb2a2ba36c19067
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: u64_g.in
-        output:
-          registers: {}
-      - input_file: u64_f.in
-        output:
-          registers: {}
-    initial_ast: 21f935f990502a478cfefdd692b2129bdf0d7e31c11ea5d0e7082202f60a0051
-    imports_resolved_ast: 8c02a4b5cca8b1a1eb6f7f2680b217a693df27a02b526cdc8de8fa421a07721f
-    canonicalized_ast: afa0657700e18ac9c75562ef1301306bd90fbf400680695448b8931753cc7203
-    type_inferenced_ast: 0bf026eba986e1aad8aa705a68645cfcb534695aafca1d6bad2c13c98c6b0ebe
+  - output: []
+    initial_ast: 73dbff1fcaf6c4c9a988d07b0e9031c1ca8fe21c0c86291e9e1ed5d87e0aac81
diff --git a/tests/expectations/compiler/compiler/integers/u64/input.leo.out b/tests/expectations/compiler/compiler/integers/u64/input.leo.out
index 36d1ae20ec..7de46a4581 100644
--- a/tests/expectations/compiler/compiler/integers/u64/input.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/input.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 255
-      num_constraints: 255
-      at: 68080cb19b62be7f91ee2118affb7b55ea272e15e17581869385053a5c6d3623
-      bt: 2c1d031e57e285b1277f2c37853fc7fdff23711e1147d7b26ed74d3acd28ceff
-      ct: 0b136215b60005ed17aa4eea76bc4e2b0349c0fecf57dc06f5dba31981f270d0
-    output:
-      - input_file: u64_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b0ab784c28925322db771416fc9e16c0acd7cc3baef519248990e639b26274e8
-    imports_resolved_ast: d9fd6c0a2b4899d316ec48d959cddce52a152a18e241db659880e521be7d1a04
-    canonicalized_ast: d9fd6c0a2b4899d316ec48d959cddce52a152a18e241db659880e521be7d1a04
-    type_inferenced_ast: 05dda9e96f32ab389abdc60c6c38990a71977269a0d2526cd304edadbdeecd26
+  - output: []
+    initial_ast: 5fd45f994936c606f15040d148732ec079b8cbc63e6aea0bbb27c31a366708c0
diff --git a/tests/expectations/compiler/compiler/integers/u64/le.leo.out b/tests/expectations/compiler/compiler/integers/u64/le.leo.out
index 0023c36d9f..1dac3dfbcf 100644
--- a/tests/expectations/compiler/compiler/integers/u64/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/le.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: d8041c17d69554c3c06ad3d72f58df129a6df56184fd121c815b1ddfe0951d52
-      bt: 20b7ff1d5fb8aeb0ff37cde558c4da0c1949885789a23bdf21a415cefb159e16
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: u64_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u64_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u64_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: c7efb0c07b71a8801f85f7df849f5376e733493a85155f6b730c3903bad6bdc0
-    imports_resolved_ast: c388adf2a2df71e60b621d60a787a5d150d420937b8a946ea32aea35ad13c42a
-    canonicalized_ast: c388adf2a2df71e60b621d60a787a5d150d420937b8a946ea32aea35ad13c42a
-    type_inferenced_ast: b3fc669c4fb8c69a76c7343d9bfa449785fd02e971a589c83e5fa90a68699758
+  - output: []
+    initial_ast: b19797e2966b3d5047b194ae9eae5c15ca5ad0ff05d1cba63c0c3c0cd4cd42b2
diff --git a/tests/expectations/compiler/compiler/integers/u64/lt.leo.out b/tests/expectations/compiler/compiler/integers/u64/lt.leo.out
index f986e9c99b..99539ac262 100644
--- a/tests/expectations/compiler/compiler/integers/u64/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 449
-      num_constraints: 449
-      at: 6fad339784c0e41ffb56fc6d4b5949563cf1a7e53e91cf1c643df2dd798c9cf8
-      bt: ac1a1706eaf7c384375eebf95d38ab272e9c27745c6a9f5feed56e6ecbe28e8b
-      ct: 7b765314986bd8a51a62dabdef866c5fe05ad9bf392fb0e25b7ce3b9969f81e1
-    output:
-      - input_file: u64_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u64_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 75ad5d1b417881b7360ee4b7cebd439d2023a1ae340979efc7ffb837b163535f
-    imports_resolved_ast: fb6b63c8c0a8c3a3a82aa7d5dfd90d89c8894a4d5c59b7e0398fcd7b07621820
-    canonicalized_ast: fb6b63c8c0a8c3a3a82aa7d5dfd90d89c8894a4d5c59b7e0398fcd7b07621820
-    type_inferenced_ast: 2e6f98b3180acfe2fc33ec13ee9124c71327d5a405b5cdc963bc25af6a1864ff
+  - output: []
+    initial_ast: 78b9ceb15f3ef12d2be77b98a7a9a2ed83227e1f739560f6a368a5f0b71e34dc
diff --git a/tests/expectations/compiler/compiler/integers/u64/max.leo.out b/tests/expectations/compiler/compiler/integers/u64/max.leo.out
index d4068f3164..2b0f8accba 100644
--- a/tests/expectations/compiler/compiler/integers/u64/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: c6a0d1f1009f0dc28d007fe8ec6ba61d6fe1c04f77c4c52967a28c7b5747dece
-    imports_resolved_ast: 8e67ae0807cd28cabb28cab120867d365efe257820cdf04a546c2881651fb6ae
-    canonicalized_ast: 8e67ae0807cd28cabb28cab120867d365efe257820cdf04a546c2881651fb6ae
-    type_inferenced_ast: c1d2688fb2aff96cd1f453d99ec25ec5d3eb9095c808f0bacec801441db3682e
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 3146857c971edf0326be3bb9d266027558a6f854f53c4b1a94bf6dba446c450a
+    initial_ast: 76b10d09f6049c38db792578749ac12624df59643d5410fece1827f0dffe131a
diff --git a/tests/expectations/compiler/compiler/integers/u64/min.leo.out b/tests/expectations/compiler/compiler/integers/u64/min.leo.out
index 1a8decc2fd..2c8ce96d83 100644
--- a/tests/expectations/compiler/compiler/integers/u64/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: f34a524e2cec491c0d60165b27ab146691f8927a80dd0f6159fff3a7d40dd58c
-    imports_resolved_ast: 763c908358698b44d11bb07f10394d0147f88922152cf9ab49d47a0d3e6d1607
-    canonicalized_ast: 763c908358698b44d11bb07f10394d0147f88922152cf9ab49d47a0d3e6d1607
-    type_inferenced_ast: e1fa4f37743d55a7d2cf7878cb8f7b992b96d930663ab97b37296f634302ba4d
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: 921afae3bb2b83a281597adcb8d56bb1199219c6bb40edd2c1059c35a2470e33
+    initial_ast: b58456503b17ad59d52c414d43ce8d5e73dc9907c042bee953fcfc202c0d2dc1
diff --git a/tests/expectations/compiler/compiler/integers/u64/mul.leo.out b/tests/expectations/compiler/compiler/integers/u64/mul.leo.out
index 96b0c0df95..19c7b42e67 100644
--- a/tests/expectations/compiler/compiler/integers/u64/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 12805
-      num_constraints: 16966
-      at: 94607d20548e2b4a046e0f3eb55624da27ec73bcaeee0e8258b3d2e2e607b2fd
-      bt: 8063dc2ec3957d32cb243785803b1fe280885ae5bbb7b50ae5dd71b4a5b404dd
-      ct: 5c2a423f5d488da02561837d1ae9e5b86ede29cd64555ebc88229ab4ef9d8fa2
-    output:
-      - input_file: mul.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: 93b07389794d0edb296395efa061df80b9ce351ed69987471f0f1da9e097f096
-    imports_resolved_ast: 79d9462ab401939e0571fb1228b2b76c674dccb67386a438e2b6f5814021094f
-    canonicalized_ast: 79d9462ab401939e0571fb1228b2b76c674dccb67386a438e2b6f5814021094f
-    type_inferenced_ast: adc72cbc67e15adb9b67f2bb6fe5ae03b90c96c1f51d25ec04583446d3a61263
+  - output: []
+    initial_ast: eb1c470f2407c45abc32d8f98385af6f9e8b61a22f42f7d9cc479d770018551c
diff --git a/tests/expectations/compiler/compiler/integers/u64/ne.leo.out b/tests/expectations/compiler/compiler/integers/u64/ne.leo.out
index 50e4aac66f..482d6b8418 100644
--- a/tests/expectations/compiler/compiler/integers/u64/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/ne.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 257
-      num_constraints: 257
-      at: 2ba8d0827cc16bb5d0076549483425de1dd0da9b3fb06fd790c256ec8d1df36b
-      bt: 7abc1550aed02405fe1d0951da294ee11583b4215ddc3889429f16ac75604766
-      ct: 8edd5528a862bbd5590cfbd0d52871e395cf73e3a22c70839571b36506fbe3a7
-    output:
-      - input_file: ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: d952fffbe52c394c86b74f01668d5d4372d9d31825115e5f2a38583c23a31d46
-    imports_resolved_ast: a09217f5e793c9f246bcbb20a6a02e057233866184dc9b419c149243d09338ad
-    canonicalized_ast: a09217f5e793c9f246bcbb20a6a02e057233866184dc9b419c149243d09338ad
-    type_inferenced_ast: 9433acc9abcc2c3a02ccfa85bf6f210d5d51b73af8e3c1a5df2bbfcd5ad6ba07
+  - output: []
+    initial_ast: 44322879e83f008bdf3d9b98a5f6ed1341760c49175bf7670ef826b6057100a3
diff --git a/tests/expectations/compiler/compiler/integers/u64/sub.leo.out b/tests/expectations/compiler/compiler/integers/u64/sub.leo.out
index 439cb5590f..963ba1cc68 100644
--- a/tests/expectations/compiler/compiler/integers/u64/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 384
-      num_constraints: 385
-      at: 03f552addf49f5f1c8402d8af8dd733983efa7fd3436d677d89d74a1c6548962
-      bt: 8cbfb6559664a4d73354d718f19247484a98da79ddf83350c1a070cb14fda399
-      ct: 4906d35acd2d4c5fda24a10932dbccfb9c814de0b6160b29fa57540935c864ee
-    output:
-      - input_file: u64_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 564b3efd115fea542eee12aedf9b683df9d8a6a40de0e86eaf31bef9f6dfc454
-    imports_resolved_ast: f3c095565a1cc8b5a845112ff58443a4d7fd8a9677903c579ba0d49adab4f783
-    canonicalized_ast: f3c095565a1cc8b5a845112ff58443a4d7fd8a9677903c579ba0d49adab4f783
-    type_inferenced_ast: 01f09b5842c095085233dae2389a7e7267e5864bd99d281dabf37d4dc4a5452e
+  - output: []
+    initial_ast: 598a8893e0e64ce6a7c3e66c6a6164dcaf856c414954d6835d2b494f48dcc7d0
diff --git a/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out
index 52fafe32cb..36d670c657 100644
--- a/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 448
-      num_constraints: 512
-      at: e36c9bfd01fbf30c1f31d53e2b19d1a83989e86701ba58838688174b9ad804d7
-      bt: edadcd06780bd97cb60d245565ce94697ee12b4d71ce9148f1546f1c4390b668
-      ct: f1bb709127145aae7603feda04afbc3e401fdf290c1d549be8d2d4b21ece9b58
-    output:
-      - input_file: u64_t.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u64_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: eabfeb3de99bcb6bd08e9f55860665581bc8fd3be32dad46e3c869027014b9ca
-    imports_resolved_ast: cf510921197365d88ba4104d2518543c86b837403c362d93bd6f8ec3f2ad692c
-    canonicalized_ast: cf510921197365d88ba4104d2518543c86b837403c362d93bd6f8ec3f2ad692c
-    type_inferenced_ast: f7ea7c65cfee617728d9f75b27fb6dc2d52f1507f0f68a0ca5506bb5dc8455e0
+  - output: []
+    initial_ast: df0761dcdb949293dc6932a4399e135116199acd46b8ee25efb5707c36e93fe2
diff --git a/tests/expectations/compiler/compiler/integers/u8/add.leo.out b/tests/expectations/compiler/compiler/integers/u8/add.leo.out
index 0abbc7face..0be1ac6dc9 100644
--- a/tests/expectations/compiler/compiler/integers/u8/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/add.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 48
-      num_constraints: 49
-      at: 69fb3c4168c95acd03a37f194310a3c4650940b98570ed2354b4cf40a46c3cdc
-      bt: 0864b812eb8b0fd3cb3173bde347790cd9975d1117accb115141afe0444cea3c
-      ct: 463f6e3dc8e5ed795eb81d0b200c7f8d7ee4294ef49dc7469646067364331ccf
-    output:
-      - input_file: u8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 97c77a538e0875b6170467c30868fe28de216ee65671789e7c59d0b7db01c52d
-    imports_resolved_ast: 25587f1b3e0cd82d0cf036f150c7c75a93f6ff954a4ba931ac59c09de29c74c7
-    canonicalized_ast: 25587f1b3e0cd82d0cf036f150c7c75a93f6ff954a4ba931ac59c09de29c74c7
-    type_inferenced_ast: 5cad04bdbc4b47964a6453156ada2e4804fe60b8dea01e9566eb80d2dac9ef7e
+  - output: []
+    initial_ast: b7dd798a6c169b0e90da360b86a56644bca050365f6d3f59f20f6b58df88b336
diff --git a/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out
index 6490af8336..fb1f8c811d 100644
--- a/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 46
-      num_constraints: 46
-      at: 829f4510ef3fb07e4ffecffe519507a8c6790309f86f349e2b8c5c42cc09e1c9
-      bt: 10f68596bcedd566b8eecf0bd255093865e9652e35d141d868fcba35ed67b24a
-      ct: 547830d9a13714ce4f3490f83aeafb5faa68aac46614867b7c19beb99eb908ff
-    output:
-      - input_file: u8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: eb3a78e20694d00cdbf382c97b3eb276893a42899b53c6888c8392b6f7a59693
-    imports_resolved_ast: b1791834728c85b5148ba07d8b7bb963d998b20326f4d88335f437754bc6522f
-    canonicalized_ast: b1791834728c85b5148ba07d8b7bb963d998b20326f4d88335f437754bc6522f
-    type_inferenced_ast: e703b8569f14716aaf7663d74a11a5fef8cbe6f69761255d890963fe8c9ef642
+  - output: []
+    initial_ast: 76a1c4602ef15ad8772a327096699610368d8084a893eaa598eb29ac09e5333a
diff --git a/tests/expectations/compiler/compiler/integers/u8/div.leo.out b/tests/expectations/compiler/compiler/integers/u8/div.leo.out
index ed7428b703..9ecedb4f94 100644
--- a/tests/expectations/compiler/compiler/integers/u8/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/div.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1068
-      num_constraints: 1355
-      at: 8ed58147507a99812dafb5a57a6c403d92d4454ea232cc7ee8b7f387a1435aa4
-      bt: 9e0ee614664ff1c133eff0a1bdb47f8521967aacb928ff34195d0639aec895d6
-      ct: 0b81ff43876b3dbc83461a76cfd1c6ff5513f2a5597441d526a472bd74b66ad1
-    output:
-      - input_file: u8.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 353d0de785c5c5e979321681a8a719368395fc3d36efbcf1ddcdaa15d90d8fbb
-    imports_resolved_ast: 269a5e2ecfde1c660be7dd9a5f2e34ca4fe764f9c1af7160a50a5e1d036a96e5
-    canonicalized_ast: 269a5e2ecfde1c660be7dd9a5f2e34ca4fe764f9c1af7160a50a5e1d036a96e5
-    type_inferenced_ast: 0d6a5bae567c923fb7980fa00fd0965a133fb0af147057d09fcf6938b8eb3da5
+  - output: []
+    initial_ast: 01ffcd880e5569626d16ac43de9db56cd4ee17a01e570d45815277b003fbb01e
diff --git a/tests/expectations/compiler/compiler/integers/u8/eq.leo.out b/tests/expectations/compiler/compiler/integers/u8/eq.leo.out
index cc2fe41e2c..e047bc0c7b 100644
--- a/tests/expectations/compiler/compiler/integers/u8/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/eq.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 33
-      num_constraints: 33
-      at: 424965aff58c62dd2bf38daa6426a3edcc19aa86bff3842fe4e73f743d37e1cb
-      bt: 03d1b6a8fdf9f73f595cf97261f1bae81000c89364c7af58f4f7f04aba7bac30
-      ct: 2aae7d6631260dcaafbfe9709ade84e75f5172a9baad48e108e7264d5fc17cf6
-    output:
-      - input_file: u8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u8_n.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 1da7f004fe5ba37ef2cfc16325fc0ff30745757df4a1d337b53559bd9158d53b
-    imports_resolved_ast: cac8a9a234155224142e55a9f1fca16c4a0e0498b8c3dbda35512f954c70b095
-    canonicalized_ast: cac8a9a234155224142e55a9f1fca16c4a0e0498b8c3dbda35512f954c70b095
-    type_inferenced_ast: 8248fb4107d2c0f37c2458c67ae3d3a57b2d6f45994bf9f4cc6137295f925559
+  - output: []
+    initial_ast: 8a55d90966d19eae8d35e12c03868d2fb2331b36c799253cd225c3dd92db3fd0
diff --git a/tests/expectations/compiler/compiler/integers/u8/ge.leo.out b/tests/expectations/compiler/compiler/integers/u8/ge.leo.out
index e1ca123a41..c64d50b196 100644
--- a/tests/expectations/compiler/compiler/integers/u8/ge.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/ge.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: bc8380502907fbf4dc375e6ffc6ff09063dfb74d4bf1deb5c0a822f892e73acb
-      bt: 6af90ba76909462a3da873fbb2276b4020df6b3318671bd44aef4572df6326fc
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: u8_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u8_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 7ccbdd2c696f8ef745fb597f28da7776ce6397557a55cce7875ffa584cb98319
-    imports_resolved_ast: cf683c76804e9133c053eb848da517816922210fecba770164ac2350023b6493
-    canonicalized_ast: cf683c76804e9133c053eb848da517816922210fecba770164ac2350023b6493
-    type_inferenced_ast: 52119cce05b19c899fba72a47d8a354de18e8d34873faade48086ec04484167e
+  - output: []
+    initial_ast: 201c2596f189ca81cbb8c1155f13fa5d6764bac8c4a24f1ea01ef80e26882336
diff --git a/tests/expectations/compiler/compiler/integers/u8/gt.leo.out b/tests/expectations/compiler/compiler/integers/u8/gt.leo.out
index 4ff0b03dd2..2a5e853be3 100644
--- a/tests/expectations/compiler/compiler/integers/u8/gt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/gt.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: 38f7f88206d5c28524fd286b4d4eff928bc29bf167f9ccdb1459377fcdee677f
-      bt: 0edd7a2aa1dabdeb3cd270d78086cb74dfc5f4c957e6f2ce7546daed614a3579
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: u8_g.in
-        output:
-          registers: {}
-      - input_file: u8_f.in
-        output:
-          registers: {}
-    initial_ast: 02f8d23972f248da4f05b022156662fd001f27a1e95c1cffbd039e77dc154182
-    imports_resolved_ast: f2e7b8ed72874d28535abe9c404900a141863d700299d935e90371bb25620a7d
-    canonicalized_ast: 32d92c4ce571405ee470ffe5144bd1d37bb4d8a824db127679a26ecbe89c55ef
-    type_inferenced_ast: 358dd7772450775cd0df5b399ef190759592a332687791b743941b1584282976
+  - output: []
+    initial_ast: 55b84c4ce6405061af1bf44a6345ec4298fc7f875e145168e9618d90b0b2e60b
diff --git a/tests/expectations/compiler/compiler/integers/u8/input.leo.out b/tests/expectations/compiler/compiler/integers/u8/input.leo.out
index 481d72d357..49d31f48a8 100644
--- a/tests/expectations/compiler/compiler/integers/u8/input.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/input.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 31
-      num_constraints: 31
-      at: 8111e478f64beb722ec96fbd80076cb73b735813b20e8f2ed6e3c21febceaae7
-      bt: c2cfac5aa6e125cb6cde720b0598fef7933c4aa62926fe99405bf1c2829dd4ce
-      ct: a3fa97a403ebea95a47d7ded7c01cee45af74afbfa876c203e4e96f6054b8815
-    output:
-      - input_file: u8_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: a7b4baaf9a0b7724f8690fa4d99446f5462d77a6bf8afbe5eb6aef0a568339df
-    imports_resolved_ast: d863d278f175f20538a62705969dd2251aa0c9a984e19c8f45ce4a6bfe672993
-    canonicalized_ast: d863d278f175f20538a62705969dd2251aa0c9a984e19c8f45ce4a6bfe672993
-    type_inferenced_ast: 92c3e102f3682b9fff12cce4e1a727ecd40dc1976e6cac30ed338acd5d769db5
+  - output: []
+    initial_ast: 2971694636a287d6a66a187f42999757c51581a6f843b036c03b6b9850dbdcf2
diff --git a/tests/expectations/compiler/compiler/integers/u8/le.leo.out b/tests/expectations/compiler/compiler/integers/u8/le.leo.out
index 01a943a62f..befd16b823 100644
--- a/tests/expectations/compiler/compiler/integers/u8/le.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/le.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: 4f2c1500ec12fc38d3a05a67cab6066e0bedda66bdd2a9b81b58189a4e2efb44
-      bt: 7166372193964d2e6e881f4178c1a8fd80afe2c60584af277e73e606f4ac4efd
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: u8_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u8_e.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u8_l.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: ac434b4f2f75af3d496a8621613aa820a2989a1b95facb515b317cad4bb6c907
-    imports_resolved_ast: 9a8a7df1f29f72d202a8979a8b0b94a7921f7e5d1b530f40a0de6a03d7877d43
-    canonicalized_ast: 9a8a7df1f29f72d202a8979a8b0b94a7921f7e5d1b530f40a0de6a03d7877d43
-    type_inferenced_ast: 783644b65165f1c8e1c2f1f96bcba4590824185e1cb2f7105d0b668767184d23
+  - output: []
+    initial_ast: 6bd48110a2d4e17a18288fd55e786fe97b3917010460b0b7aa53a9b44f043ab8
diff --git a/tests/expectations/compiler/compiler/integers/u8/lt.leo.out b/tests/expectations/compiler/compiler/integers/u8/lt.leo.out
index 997655f927..503be04dcd 100644
--- a/tests/expectations/compiler/compiler/integers/u8/lt.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/lt.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 57
-      num_constraints: 57
-      at: 6a0450b269677ab3f038f68befed6b3dd7e4471cba20c9b3cbb1987d11623de2
-      bt: 1c92f5790ff308be2d3a812b0b14b7445192b9b9fb271cabd8a18dc925deb34d
-      ct: 5a4c4f077603c1f7c4b31cf17fee281ab3cb7d2a9571be40a2f3a88577759477
-    output:
-      - input_file: u8_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-      - input_file: u8_g.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: a5e05843a5307c02d2238abae923e7b2a5f545f39e28a6a8fdb66a8f95f32bad
-    imports_resolved_ast: ff2de8a9e24f0e4309434cc6b1f5ef60b584a14cacea52543765f5ffc0db88a8
-    canonicalized_ast: ff2de8a9e24f0e4309434cc6b1f5ef60b584a14cacea52543765f5ffc0db88a8
-    type_inferenced_ast: 439c2bd3917b78bc1feed3e623312bbe67311ae27e648b1c98150db84686d84b
+  - output: []
+    initial_ast: b3cb8023026edca17fbbf197d6c795cbf54f0d800402160764fc62299eb5a861
diff --git a/tests/expectations/compiler/compiler/integers/u8/max.leo.out b/tests/expectations/compiler/compiler/integers/u8/max.leo.out
index 335439a2ed..2ddaa337b2 100644
--- a/tests/expectations/compiler/compiler/integers/u8/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/max.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: b297ced05c553f5fec69ef9a0e6e08fcef4f94402e27ba6f6f1de4c16433d9eb
-    imports_resolved_ast: 069dc2c67a9767e0b4462efa353b522ffa7a88fd861c4919efa6917b4c5ef936
-    canonicalized_ast: 069dc2c67a9767e0b4462efa353b522ffa7a88fd861c4919efa6917b4c5ef936
-    type_inferenced_ast: bc002a682138f5f6e6005280cd769487b7820bc66b28404020b4d1253bd73c2e
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: c3128d4168ccf40434ee016640442ebcf432d82822e1a5c02c3dbc93ef3609b4
+    initial_ast: e9bb9fcf10aedbf41b2e30dfc49d3b274c8d1eb5c733893a697cd8a3eae57f4c
diff --git a/tests/expectations/compiler/compiler/integers/u8/min.leo.out b/tests/expectations/compiler/compiler/integers/u8/min.leo.out
index f65fa46b9e..2af2e1b05f 100644
--- a/tests/expectations/compiler/compiler/integers/u8/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/min.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: "../input/dummy.in"
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 3529427883942d28e1af8057ad0fcfd69d114498e0736cc6d905006992eee6d6
-    imports_resolved_ast: 372838d84cbf3562bbba01a58dd911fba4147beffd575c8ce62bceee4096ac8e
-    canonicalized_ast: 372838d84cbf3562bbba01a58dd911fba4147beffd575c8ce62bceee4096ac8e
-    type_inferenced_ast: 8b47a8708fcb5336632583cf69b2961467b647d56c8e79998113ea26bd93f280
+  - output:
+      - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
+        symbol_table: a5b4343a7bfd9550b401ef492e3b82b1d9aa7dd26800247fe337c8e94902f30b
+    initial_ast: faa7e6927f29cbcd34cb3498e1a08e7bf9641ea833bb4a3f92d4682a0fe13215
diff --git a/tests/expectations/compiler/compiler/integers/u8/mul.leo.out b/tests/expectations/compiler/compiler/integers/u8/mul.leo.out
index aac4b8edb6..ce7c0fb770 100644
--- a/tests/expectations/compiler/compiler/integers/u8/mul.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/mul.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 258
-      num_constraints: 331
-      at: 9db6e7fa73b98bf7623bed5997bf61d51f348aaf43d9249b629a866a9085f08b
-      bt: a9bb86254052a3c5b275213180e89108aea721369a9d32cbd837a1cb974d76b3
-      ct: 4dc6b4ca7c3bcedbbe8abbaee96615345e08b304dd65b217319ece1224721b57
-    output:
-      - input_file: mul.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "false"
-    initial_ast: a818dfc4b929b180c62afa75e73ec0b5f631033b7de720135b0801c5ed3ff212
-    imports_resolved_ast: 4cc311a2233bc6b83430b82107cea31f7d88db6bdcc64d3e40ca2af3efec44cd
-    canonicalized_ast: 4cc311a2233bc6b83430b82107cea31f7d88db6bdcc64d3e40ca2af3efec44cd
-    type_inferenced_ast: 6805b7f6a30975ef3ccb5f4f2e5779596c2ab9b30334bb697f0f7e12720d863a
+  - output: []
+    initial_ast: c2c0afa3fa10147ba3eb20c98fd5f5159977944992325c3a0300289510911c4e
diff --git a/tests/expectations/compiler/compiler/integers/u8/ne.leo.out b/tests/expectations/compiler/compiler/integers/u8/ne.leo.out
index 70fac39089..f515f0ca04 100644
--- a/tests/expectations/compiler/compiler/integers/u8/ne.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/ne.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 33
-      num_constraints: 33
-      at: 5e88cd940df2c48a53e64a9b8589045ef766371daa5cc885df982902d9fcc754
-      bt: 10b52342f8c44eb9b3335b4df9ca4136de3ad35d5b580b2ab32ae5e10bcdf3b4
-      ct: 2aae7d6631260dcaafbfe9709ade84e75f5172a9baad48e108e7264d5fc17cf6
-    output:
-      - input_file: ne.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 40dde7c7b88c62369fe2158367a437068a868915ce396073a1175da002fb5ac9
-    imports_resolved_ast: 04a8f0a644627674badf15ae8905b1c900b69c55737349a2b5a47c8fac8ad34e
-    canonicalized_ast: 04a8f0a644627674badf15ae8905b1c900b69c55737349a2b5a47c8fac8ad34e
-    type_inferenced_ast: 986c782450aee517ce53b71f1bb9dc907dc97833775f3186c4f6d341ae5239b3
+  - output: []
+    initial_ast: d4fd7ef16af8dab231510e78cba7be176f619f7646ce5867211fc0982e7c245a
diff --git a/tests/expectations/compiler/compiler/integers/u8/sub.leo.out b/tests/expectations/compiler/compiler/integers/u8/sub.leo.out
index e99b60db50..d8bad719cc 100644
--- a/tests/expectations/compiler/compiler/integers/u8/sub.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/sub.leo.out
@@ -2,21 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 48
-      num_constraints: 49
-      at: 69fb3c4168c95acd03a37f194310a3c4650940b98570ed2354b4cf40a46c3cdc
-      bt: 0864b812eb8b0fd3cb3173bde347790cd9975d1117accb115141afe0444cea3c
-      ct: a09cd762cf1db927d99cef196452f092d030aa05851fe466816535ac34c6188f
-    output:
-      - input_file: u8_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 051c84b52dceb79e65c1a5fc22d30b6d2fee3bcfcd8d85f4e970a60b2e2af5fd
-    imports_resolved_ast: 07a06d99c1a0f0b9100df40055d258fd32184da01c2d356b0f2cac06c4add473
-    canonicalized_ast: 07a06d99c1a0f0b9100df40055d258fd32184da01c2d356b0f2cac06c4add473
-    type_inferenced_ast: d377a1e1ecdcb6cefaa6ae6079234fa362cfc230fb5bc5ab6e5565f6d8a7a0d4
+  - output: []
+    initial_ast: 2f52e4feba81598590c41cc2d8d101669bf358f32b80716e9442997d3beb5bf5
diff --git a/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out
index fbd9d03602..538889d0a4 100644
--- a/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 56
-      num_constraints: 64
-      at: a15ec92a38acf1a47952df144e5299f49dbde96fbe1a3f3b2af4bbca483d65aa
-      bt: 90a2489533355ee3e27d5cf485612441ec10e21923eb78e6be21633ce11fa8f1
-      ct: 4c2d67fc6e1c4ad44f323c1b958ed94313153573aa72a3c0f0d25b17b54e63bc
-    output:
-      - input_file: u8_t.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-      - input_file: u8_f.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: e0b1b08b93eaec607f3735c788f30058329bd4bb15efec806171a3bebb265976
-    imports_resolved_ast: 1d50ae50f76d8527c0ddb7183d655383921fe004090fc8ce52e802cfc2ba00b6
-    canonicalized_ast: 1d50ae50f76d8527c0ddb7183d655383921fe004090fc8ce52e802cfc2ba00b6
-    type_inferenced_ast: b107739e5df350edad2dcdb15097dcc4aee6050b4ab7a0fcbe0c84a08cb1421b
+  - output: []
+    initial_ast: 7ffb1efa76a0e4371fe6c32c29cdd8c1e988897bea54a6ae20de2dcc1cafaaee
diff --git a/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out b/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out
index 5051deb575..5e3f66bceb 100644
--- a/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out
+++ b/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 11c4f9dfabef7c660d1448c1ddd5c76f66f1d03a57ba7fedc6b894b8fe519bb9
-    imports_resolved_ast: 17d02102f980bb5123a32ec3eeff98cfaee9228ff105aab1c9dfefce3baa49e1
-    canonicalized_ast: 6d331afd62ed22b97d0e913672e51ac0e09dc70ea75d4a83813161cc6785bc29
-    type_inferenced_ast: 82b10117379a1f134de5818a8a38f2eda0ecb5614f7dc4b63644e6622079314a
+  - output:
+      - initial_input_ast: 534a7a2cf337da1dc9ea3d25dacec6390f4cdbf6b5961b481564abc44fff1442
+        symbol_table: 2be98cbd0ca649dc4eff1c7fae5082c22f94a0b32feb09af85dc574cf8f2085c
+    initial_ast: d8e18f72fb09eb8a87f8dbc977e86e2bfdea862f76a91352e4edcbe40d3254de
diff --git a/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out b/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out
index 13e6a2a339..d877751bea 100644
--- a/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out
+++ b/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 5dc3ac5170f9554ce4448310e70b9abac0876e4b5dd656318a6b424f808e5487
-    imports_resolved_ast: 4fe18bdfd46543518839b697d9d0cc0fc2a011b5a27802ca2ac3bdffc1a5c00e
-    canonicalized_ast: 4fe18bdfd46543518839b697d9d0cc0fc2a011b5a27802ca2ac3bdffc1a5c00e
-    type_inferenced_ast: 7bbbdea7d312861a78ee26db28abf07e960f3dcffdcdc15595aafecfd37c29e6
+  - output:
+      - initial_input_ast: 534a7a2cf337da1dc9ea3d25dacec6390f4cdbf6b5961b481564abc44fff1442
+        symbol_table: 6b646fc79abca7d9ef29d5d12fdfa3d2988d01a2332507ef512d34af7f2d1786
+    initial_ast: 0ee6dbfb6d2780de8853573772fac4f757bd7c33feef0e2e7e8d7518107a9e70
diff --git a/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out b/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out
index c4de0e6bdc..3a4a8e0981 100644
--- a/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out
+++ b/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 1
-      num_constraints: 1
-      at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f
-      bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c
-      ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05
-    output:
-      - input_file: input/dummy.in
-        output:
-          registers:
-            r0:
-              type: bool
-              value: "true"
-    initial_ast: 7923219f25031e73498fd8d02abacedc84a1ca8769b81e065350e532e659112f
-    imports_resolved_ast: 3ed3bd5438a7905fef650c8a18ff469a22445e1b208655e4d3f1b8a12848637a
-    canonicalized_ast: 3ed3bd5438a7905fef650c8a18ff469a22445e1b208655e4d3f1b8a12848637a
-    type_inferenced_ast: 6b3e24a3bd780b0b3770f26c6622019e2816d603b250a6b2dcb11b66e5837da9
+  - output:
+      - initial_input_ast: 534a7a2cf337da1dc9ea3d25dacec6390f4cdbf6b5961b481564abc44fff1442
+        symbol_table: 7ab514d7a4bc29d3591f2a08de47b4e1abef689ec058a5dbcdbb2169cf56a2a0
+    initial_ast: 4db2058d770eaf4a82ca62b0220db4cff2564824e3b4ec6691ba3109cab8d729
diff --git a/tests/expectations/compiler/compiler/statements/chain.leo.out b/tests/expectations/compiler/compiler/statements/chain.leo.out
index 3476813794..ee8d7e4613 100644
--- a/tests/expectations/compiler/compiler/statements/chain.leo.out
+++ b/tests/expectations/compiler/compiler/statements/chain.leo.out
@@ -2,33 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 319
-      num_constraints: 415
-      at: 910d51dc69b7ed7e2dfe1a786fad9b226b2ff30c7678f397cb8d8850fd76442e
-      bt: 3ae01a0af5534bca6ad67bd2609a5370a4982c7f6d17fb8c285054c3d08f9c4f
-      ct: 67836f65a02c595fcbf6d6a6d223a15e138d99a542390693ac4f582d073869e6
-    output:
-      - input_file: inputs/u32_3.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "true"
-      - input_file: inputs/u32_5.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "false"
-      - input_file: inputs/u32_6.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "false"
-    initial_ast: ec6a48b5066fa04b9566e7e1f94855a7e009fefcaecfaedec3ceeec64a18f32f
-    imports_resolved_ast: dd98b4c69f6b4046df3130f58c7ced0e9c21f836fe47ea3815e0c7f418ffeca0
-    canonicalized_ast: dd98b4c69f6b4046df3130f58c7ced0e9c21f836fe47ea3815e0c7f418ffeca0
-    type_inferenced_ast: 1f0dc10a5af00b03e341fa1dae1846eba984a93d9d8c168930113849516a6793
+  - output: []
+    initial_ast: ca28969f0e7348704f99e270e780ed63207f968ff3efef38c5454ea2e26c65e2
diff --git a/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out b/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out
index 95c3159763..1aa39288cd 100644
--- a/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out
+++ b/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 63
-      num_constraints: 63
-      at: 37a483a8d794b0cd2f37b20c69eb00e2d9a3d950319dd18ead861dd505d84ce9
-      bt: 6c9fd7d4b3947c363bdb576b2c2c827c3ebfe4c3b56eda2abb8a37e436b69638
-      ct: c0d39de2b3b1c321288b265a4f0e72c13da3b07b0f5d61d14b66215440c56a42
-    output:
-      - input_file: inputs/u32_3.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "true"
-      - input_file: inputs/u32_5.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "false"
-    initial_ast: cb4c1112be42539e31f34ed8ada108b9575c761d7b57307b79a6177642e95308
-    imports_resolved_ast: d65805dc189a5450a75dd79759a9a6ce43f4d108fca70580b20c10e584be756a
-    canonicalized_ast: d65805dc189a5450a75dd79759a9a6ce43f4d108fca70580b20c10e584be756a
-    type_inferenced_ast: f67d00bfba55175a25538efbdf4d69b92e9bf0b7a5eece8fe68cb5f65eca75af
+  - output: []
+    initial_ast: 353aad16b91bc1304bfa0b0de1334de5271ebe7f7a4917d4c929a39b3f803a6a
diff --git a/tests/expectations/compiler/compiler/statements/mutate.leo.out b/tests/expectations/compiler/compiler/statements/mutate.leo.out
index 438de28d47..23bad5fef5 100644
--- a/tests/expectations/compiler/compiler/statements/mutate.leo.out
+++ b/tests/expectations/compiler/compiler/statements/mutate.leo.out
@@ -2,27 +2,5 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 253
-      num_constraints: 317
-      at: 30a9d7ef92bc14334cf2058df46dd513d99b7d21712c6c8bedfce9c48bc0f402
-      bt: eaddc0804e3047ae886466758455accba906f9ae990696f12c17a3237a9c9688
-      ct: e60851ccedd572c63dbcec5e0d84ddf45d76423dcf08fe0c9761fe17ce2bdd4e
-    output:
-      - input_file: inputs/u32_3.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "true"
-      - input_file: inputs/u32_5.in
-        output:
-          registers:
-            a:
-              type: bool
-              value: "true"
-    initial_ast: d722883f9776a8c48a3fbdb3c0d4d5ac19e98b8fb65c271ddd6ae083302f89f6
-    imports_resolved_ast: 2f2284ae5a057a98169fecbb259d18c20a75c24ee3a7c5a9a36e6c55e8ee93a2
-    canonicalized_ast: 2f2284ae5a057a98169fecbb259d18c20a75c24ee3a7c5a9a36e6c55e8ee93a2
-    type_inferenced_ast: 1e52ee413ca698f781faa8371be198afe6e7aabf21bdf82fe583ad7b0c556216
+  - output: []
+    initial_ast: 280ba0581e5ce03f6ae356a8840ace73e004f7c857b978313d1006b518eeab1c
diff --git a/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out b/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out
index 1af92cb994..0a4cf83b9c 100644
--- a/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out
+++ b/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out
@@ -2,21 +2,7 @@
 namespace: Compile
 expectation: Pass
 outputs:
-  - circuit:
-      num_public_variables: 0
-      num_private_variables: 25
-      num_constraints: 33
-      at: 00318b0f80b01b9e2d5a8154a536deb1545f04abd493a84071ef13dce1a9d92d
-      bt: 799ee4dc07f6320b8c3dcbd5ebdf6de8a4cf5af8b1edc45dbe5621c8a34fa38d
-      ct: 7b6ec9eacd65cfa47dfe7e73eb7c8fa4be804a9fb878fddf59fe5d06e7c04489
-    output:
-      - input_file: inputs/ternary_explicit_and_implicit.in
-        output:
-          registers:
-            a:
-              type: u8
-              value: "3"
-    initial_ast: 2fe02053af3b0036f939e7eb256fb54a52c193780c9a276f2ba5a5065e80eda0
-    imports_resolved_ast: ed770362776ddd99e3212e5b5de24932130ff48d925f66f2ecfb655c558f15b7
-    canonicalized_ast: ed770362776ddd99e3212e5b5de24932130ff48d925f66f2ecfb655c558f15b7
-    type_inferenced_ast: 4e9f786837db65d8ab0aaa2c9a5d4363617b8bf47083daff7a8dafa397e1d513
+  - output:
+      - initial_input_ast: f8e632870ce0044f507e280f5d6ee8715eb152d556245bc42680ba217581ceec
+        symbol_table: 447cf0023743b719c1bbf7a5f1d72d41a2066e4772231e5ebe419098479be8fa
+    initial_ast: 060826d16d66f656a31c83dc7a9652ca364048f241b228621a71caa29388f6ce
diff --git a/tests/expectations/parser/parser/inputs/input_const.leo.out b/tests/expectations/parser/parser/inputs/input_const.leo.out
index 90e76b3c73..d3a88e2d92 100644
--- a/tests/expectations/parser/parser/inputs/input_const.leo.out
+++ b/tests/expectations/parser/parser/inputs/input_const.leo.out
@@ -131,6 +131,38 @@ outputs:
               col_stop: 17
               path: ""
               content: "const e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
+          - mode: Constant
+            type_:
+              IntegerType: I8
+            name: "{\"name\":\"f\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"const f: i8    = -2;\\\"}\"}"
+            value:
+              Unary:
+                inner:
+                  Value:
+                    Implicit:
+                      - "2"
+                      - span:
+                          line_start: 9
+                          line_stop: 9
+                          col_start: 19
+                          col_stop: 20
+                          path: ""
+                          content: "const f: i8    = -2;"
+                op: Negate
+                span:
+                  line_start: 9
+                  line_stop: 9
+                  col_start: 18
+                  col_stop: 20
+                  path: ""
+                  content: "const f: i8    = -2;"
+            span:
+              line_start: 9
+              line_stop: 9
+              col_start: 10
+              col_stop: 12
+              path: ""
+              content: "const f: i8    = -2;"
         span:
           line_start: 3
           line_stop: 3
@@ -142,21 +174,21 @@ outputs:
         definitions:
           - mode: Private
             type_: Boolean
-            name: "{\"name\":\"r0\",\"span\":\"{\\\"line_start\\\":11,\\\"line_stop\\\":11,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r0: bool  = true;\\\"}\"}"
+            name: "{\"name\":\"r0\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r0: bool  = true;\\\"}\"}"
             value:
               Value:
                 Boolean:
                   - "true"
                   - span:
-                      line_start: 11
-                      line_stop: 11
+                      line_start: 12
+                      line_stop: 12
                       col_start: 13
                       col_stop: 17
                       path: ""
                       content: "r0: bool  = true;"
             span:
-              line_start: 11
-              line_stop: 11
+              line_start: 12
+              line_stop: 12
               col_start: 5
               col_stop: 9
               path: ""
@@ -164,49 +196,49 @@ outputs:
           - mode: Private
             type_:
               IntegerType: U8
-            name: "{\"name\":\"r1\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r1: u8    = 2;\\\"}\"}"
+            name: "{\"name\":\"r1\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r1: u8    = 2;\\\"}\"}"
             value:
               Value:
                 Implicit:
                   - "2"
-                  - span:
-                      line_start: 12
-                      line_stop: 12
-                      col_start: 13
-                      col_stop: 14
-                      path: ""
-                      content: "r1: u8    = 2;"
-            span:
-              line_start: 12
-              line_stop: 12
-              col_start: 5
-              col_stop: 7
-              path: ""
-              content: "r1: u8    = 2;"
-          - mode: Private
-            type_: Field
-            name: "{\"name\":\"r2\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r2: field = 0;\\\"}\"}"
-            value:
-              Value:
-                Implicit:
-                  - "0"
                   - span:
                       line_start: 13
                       line_stop: 13
                       col_start: 13
                       col_stop: 14
                       path: ""
-                      content: "r2: field = 0;"
+                      content: "r1: u8    = 2;"
             span:
               line_start: 13
               line_stop: 13
               col_start: 5
+              col_stop: 7
+              path: ""
+              content: "r1: u8    = 2;"
+          - mode: Private
+            type_: Field
+            name: "{\"name\":\"r2\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r2: field = 0;\\\"}\"}"
+            value:
+              Value:
+                Implicit:
+                  - "0"
+                  - span:
+                      line_start: 14
+                      line_stop: 14
+                      col_start: 13
+                      col_stop: 14
+                      path: ""
+                      content: "r2: field = 0;"
+            span:
+              line_start: 14
+              line_stop: 14
+              col_start: 5
               col_stop: 10
               path: ""
               content: "r2: field = 0;"
           - mode: Private
             type_: Group
-            name: "{\"name\":\"r3\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r3: group = (0, 1)group;\\\"}\"}"
+            name: "{\"name\":\"r3\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r3: group = (0, 1)group;\\\"}\"}"
             value:
               Value:
                 Group:
@@ -215,8 +247,8 @@ outputs:
                       Number:
                         - "0"
                         - span:
-                            line_start: 14
-                            line_stop: 14
+                            line_start: 15
+                            line_stop: 15
                             col_start: 14
                             col_stop: 15
                             path: ""
@@ -225,50 +257,82 @@ outputs:
                       Number:
                         - "1"
                         - span:
-                            line_start: 14
-                            line_stop: 14
+                            line_start: 15
+                            line_stop: 15
                             col_start: 17
                             col_stop: 18
                             path: ""
                             content: "r3: group = (0, 1)group;"
                     span:
-                      line_start: 14
-                      line_stop: 14
+                      line_start: 15
+                      line_stop: 15
                       col_start: 13
                       col_stop: 24
                       path: ""
                       content: "r3: group = (0, 1)group;"
             span:
-              line_start: 14
-              line_stop: 14
+              line_start: 15
+              line_stop: 15
               col_start: 5
               col_stop: 10
               path: ""
               content: "r3: group = (0, 1)group;"
           - mode: Private
             type_: Address
-            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;\\\"}\"}"
+            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":16,\\\"line_stop\\\":16,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;\\\"}\"}"
             value:
               Value:
                 Address:
                   - aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8
                   - span:
-                      line_start: 15
-                      line_stop: 15
+                      line_start: 16
+                      line_stop: 16
                       col_start: 15
                       col_stop: 78
                       path: ""
                       content: "r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
             span:
-              line_start: 15
-              line_stop: 15
+              line_start: 16
+              line_stop: 16
               col_start: 5
               col_stop: 12
               path: ""
               content: "r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
+          - mode: Private
+            type_:
+              IntegerType: I8
+            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":17,\\\"line_stop\\\":17,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: i8 = -1;\\\"}\"}"
+            value:
+              Unary:
+                inner:
+                  Value:
+                    Implicit:
+                      - "1"
+                      - span:
+                          line_start: 17
+                          line_stop: 17
+                          col_start: 11
+                          col_stop: 12
+                          path: ""
+                          content: "r4: i8 = -1;"
+                op: Negate
+                span:
+                  line_start: 17
+                  line_stop: 17
+                  col_start: 10
+                  col_stop: 12
+                  path: ""
+                  content: "r4: i8 = -1;"
+            span:
+              line_start: 17
+              line_stop: 17
+              col_start: 5
+              col_stop: 7
+              path: ""
+              content: "r4: i8 = -1;"
         span:
-          line_start: 10
-          line_stop: 10
+          line_start: 11
+          line_stop: 11
           col_start: 2
           col_stop: 11
           path: ""
diff --git a/tests/expectations/parser/parser/inputs/input_constant.leo.out b/tests/expectations/parser/parser/inputs/input_constant.leo.out
index 5eacee2871..43feb842cd 100644
--- a/tests/expectations/parser/parser/inputs/input_constant.leo.out
+++ b/tests/expectations/parser/parser/inputs/input_constant.leo.out
@@ -131,6 +131,38 @@ outputs:
               col_stop: 20
               path: ""
               content: "constant e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
+          - mode: Constant
+            type_:
+              IntegerType: I8
+            name: "{\"name\":\"f\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"constant f: i8    = -2;\\\"}\"}"
+            value:
+              Unary:
+                inner:
+                  Value:
+                    Implicit:
+                      - "2"
+                      - span:
+                          line_start: 9
+                          line_stop: 9
+                          col_start: 22
+                          col_stop: 23
+                          path: ""
+                          content: "constant f: i8    = -2;"
+                op: Negate
+                span:
+                  line_start: 9
+                  line_stop: 9
+                  col_start: 21
+                  col_stop: 23
+                  path: ""
+                  content: "constant f: i8    = -2;"
+            span:
+              line_start: 9
+              line_stop: 9
+              col_start: 13
+              col_stop: 15
+              path: ""
+              content: "constant f: i8    = -2;"
         span:
           line_start: 3
           line_stop: 3
@@ -142,21 +174,21 @@ outputs:
         definitions:
           - mode: Private
             type_: Boolean
-            name: "{\"name\":\"r0\",\"span\":\"{\\\"line_start\\\":11,\\\"line_stop\\\":11,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r0: bool  = true;\\\"}\"}"
+            name: "{\"name\":\"r0\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r0: bool  = true;\\\"}\"}"
             value:
               Value:
                 Boolean:
                   - "true"
                   - span:
-                      line_start: 11
-                      line_stop: 11
+                      line_start: 12
+                      line_stop: 12
                       col_start: 13
                       col_stop: 17
                       path: ""
                       content: "r0: bool  = true;"
             span:
-              line_start: 11
-              line_stop: 11
+              line_start: 12
+              line_stop: 12
               col_start: 5
               col_stop: 9
               path: ""
@@ -164,49 +196,49 @@ outputs:
           - mode: Private
             type_:
               IntegerType: U8
-            name: "{\"name\":\"r1\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r1: u8    = 2;\\\"}\"}"
+            name: "{\"name\":\"r1\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r1: u8    = 2;\\\"}\"}"
             value:
               Value:
                 Implicit:
                   - "2"
-                  - span:
-                      line_start: 12
-                      line_stop: 12
-                      col_start: 13
-                      col_stop: 14
-                      path: ""
-                      content: "r1: u8    = 2;"
-            span:
-              line_start: 12
-              line_stop: 12
-              col_start: 5
-              col_stop: 7
-              path: ""
-              content: "r1: u8    = 2;"
-          - mode: Private
-            type_: Field
-            name: "{\"name\":\"r2\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r2: field = 0;\\\"}\"}"
-            value:
-              Value:
-                Implicit:
-                  - "0"
                   - span:
                       line_start: 13
                       line_stop: 13
                       col_start: 13
                       col_stop: 14
                       path: ""
-                      content: "r2: field = 0;"
+                      content: "r1: u8    = 2;"
             span:
               line_start: 13
               line_stop: 13
               col_start: 5
+              col_stop: 7
+              path: ""
+              content: "r1: u8    = 2;"
+          - mode: Private
+            type_: Field
+            name: "{\"name\":\"r2\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r2: field = 0;\\\"}\"}"
+            value:
+              Value:
+                Implicit:
+                  - "0"
+                  - span:
+                      line_start: 14
+                      line_stop: 14
+                      col_start: 13
+                      col_stop: 14
+                      path: ""
+                      content: "r2: field = 0;"
+            span:
+              line_start: 14
+              line_stop: 14
+              col_start: 5
               col_stop: 10
               path: ""
               content: "r2: field = 0;"
           - mode: Private
             type_: Group
-            name: "{\"name\":\"r3\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r3: group = (0, 1)group;\\\"}\"}"
+            name: "{\"name\":\"r3\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r3: group = (0, 1)group;\\\"}\"}"
             value:
               Value:
                 Group:
@@ -215,8 +247,8 @@ outputs:
                       Number:
                         - "0"
                         - span:
-                            line_start: 14
-                            line_stop: 14
+                            line_start: 15
+                            line_stop: 15
                             col_start: 14
                             col_stop: 15
                             path: ""
@@ -225,50 +257,82 @@ outputs:
                       Number:
                         - "1"
                         - span:
-                            line_start: 14
-                            line_stop: 14
+                            line_start: 15
+                            line_stop: 15
                             col_start: 17
                             col_stop: 18
                             path: ""
                             content: "r3: group = (0, 1)group;"
                     span:
-                      line_start: 14
-                      line_stop: 14
+                      line_start: 15
+                      line_stop: 15
                       col_start: 13
                       col_stop: 24
                       path: ""
                       content: "r3: group = (0, 1)group;"
             span:
-              line_start: 14
-              line_stop: 14
+              line_start: 15
+              line_stop: 15
               col_start: 5
               col_stop: 10
               path: ""
               content: "r3: group = (0, 1)group;"
           - mode: Private
             type_: Address
-            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;\\\"}\"}"
+            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":16,\\\"line_stop\\\":16,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;\\\"}\"}"
             value:
               Value:
                 Address:
                   - aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8
                   - span:
-                      line_start: 15
-                      line_stop: 15
+                      line_start: 16
+                      line_stop: 16
                       col_start: 15
                       col_stop: 78
                       path: ""
                       content: "r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
             span:
-              line_start: 15
-              line_stop: 15
+              line_start: 16
+              line_stop: 16
               col_start: 5
               col_stop: 12
               path: ""
               content: "r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
+          - mode: Private
+            type_:
+              IntegerType: I8
+            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":17,\\\"line_stop\\\":17,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: i8 = -1;\\\"}\"}"
+            value:
+              Unary:
+                inner:
+                  Value:
+                    Implicit:
+                      - "1"
+                      - span:
+                          line_start: 17
+                          line_stop: 17
+                          col_start: 11
+                          col_stop: 12
+                          path: ""
+                          content: "r4: i8 = -1;"
+                op: Negate
+                span:
+                  line_start: 17
+                  line_stop: 17
+                  col_start: 10
+                  col_stop: 12
+                  path: ""
+                  content: "r4: i8 = -1;"
+            span:
+              line_start: 17
+              line_stop: 17
+              col_start: 5
+              col_stop: 7
+              path: ""
+              content: "r4: i8 = -1;"
         span:
-          line_start: 10
-          line_stop: 10
+          line_start: 11
+          line_stop: 11
           col_start: 2
           col_stop: 11
           path: ""
diff --git a/tests/expectations/parser/parser/inputs/input_public.leo.out b/tests/expectations/parser/parser/inputs/input_public.leo.out
index 14af8dbc78..093c30888b 100644
--- a/tests/expectations/parser/parser/inputs/input_public.leo.out
+++ b/tests/expectations/parser/parser/inputs/input_public.leo.out
@@ -131,6 +131,38 @@ outputs:
               col_stop: 18
               path: ""
               content: "public e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
+          - mode: Public
+            type_:
+              IntegerType: I8
+            name: "{\"name\":\"f\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"public f: i8    = -2;\\\"}\"}"
+            value:
+              Unary:
+                inner:
+                  Value:
+                    Implicit:
+                      - "2"
+                      - span:
+                          line_start: 9
+                          line_stop: 9
+                          col_start: 20
+                          col_stop: 21
+                          path: ""
+                          content: "public f: i8    = -2;"
+                op: Negate
+                span:
+                  line_start: 9
+                  line_stop: 9
+                  col_start: 19
+                  col_stop: 21
+                  path: ""
+                  content: "public f: i8    = -2;"
+            span:
+              line_start: 9
+              line_stop: 9
+              col_start: 11
+              col_stop: 13
+              path: ""
+              content: "public f: i8    = -2;"
         span:
           line_start: 3
           line_stop: 3
@@ -142,21 +174,21 @@ outputs:
         definitions:
           - mode: Private
             type_: Boolean
-            name: "{\"name\":\"r0\",\"span\":\"{\\\"line_start\\\":11,\\\"line_stop\\\":11,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r0: bool  = true;                 \\\"}\"}"
+            name: "{\"name\":\"r0\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r0: bool  = true;                 \\\"}\"}"
             value:
               Value:
                 Boolean:
                   - "true"
                   - span:
-                      line_start: 11
-                      line_stop: 11
+                      line_start: 12
+                      line_stop: 12
                       col_start: 13
                       col_stop: 17
                       path: ""
                       content: "r0: bool  = true;                 "
             span:
-              line_start: 11
-              line_stop: 11
+              line_start: 12
+              line_stop: 12
               col_start: 5
               col_stop: 9
               path: ""
@@ -164,49 +196,49 @@ outputs:
           - mode: Private
             type_:
               IntegerType: U8
-            name: "{\"name\":\"r1\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r1: u8    = 2;                    \\\"}\"}"
+            name: "{\"name\":\"r1\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r1: u8    = 2;                    \\\"}\"}"
             value:
               Value:
                 Implicit:
                   - "2"
-                  - span:
-                      line_start: 12
-                      line_stop: 12
-                      col_start: 13
-                      col_stop: 14
-                      path: ""
-                      content: "r1: u8    = 2;                    "
-            span:
-              line_start: 12
-              line_stop: 12
-              col_start: 5
-              col_stop: 7
-              path: ""
-              content: "r1: u8    = 2;                    "
-          - mode: Private
-            type_: Field
-            name: "{\"name\":\"r2\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r2: field = 0;                    \\\"}\"}"
-            value:
-              Value:
-                Implicit:
-                  - "0"
                   - span:
                       line_start: 13
                       line_stop: 13
                       col_start: 13
                       col_stop: 14
                       path: ""
-                      content: "r2: field = 0;                    "
+                      content: "r1: u8    = 2;                    "
             span:
               line_start: 13
               line_stop: 13
               col_start: 5
+              col_stop: 7
+              path: ""
+              content: "r1: u8    = 2;                    "
+          - mode: Private
+            type_: Field
+            name: "{\"name\":\"r2\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r2: field = 0;                    \\\"}\"}"
+            value:
+              Value:
+                Implicit:
+                  - "0"
+                  - span:
+                      line_start: 14
+                      line_stop: 14
+                      col_start: 13
+                      col_stop: 14
+                      path: ""
+                      content: "r2: field = 0;                    "
+            span:
+              line_start: 14
+              line_stop: 14
+              col_start: 5
               col_stop: 10
               path: ""
               content: "r2: field = 0;                    "
           - mode: Private
             type_: Group
-            name: "{\"name\":\"r3\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r3: group = (0, 1)group;          \\\"}\"}"
+            name: "{\"name\":\"r3\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r3: group = (0, 1)group;          \\\"}\"}"
             value:
               Value:
                 Group:
@@ -215,8 +247,8 @@ outputs:
                       Number:
                         - "0"
                         - span:
-                            line_start: 14
-                            line_stop: 14
+                            line_start: 15
+                            line_stop: 15
                             col_start: 14
                             col_stop: 15
                             path: ""
@@ -225,50 +257,82 @@ outputs:
                       Number:
                         - "1"
                         - span:
-                            line_start: 14
-                            line_stop: 14
+                            line_start: 15
+                            line_stop: 15
                             col_start: 17
                             col_stop: 18
                             path: ""
                             content: "r3: group = (0, 1)group;          "
                     span:
-                      line_start: 14
-                      line_stop: 14
+                      line_start: 15
+                      line_stop: 15
                       col_start: 13
                       col_stop: 24
                       path: ""
                       content: "r3: group = (0, 1)group;          "
             span:
-              line_start: 14
-              line_stop: 14
+              line_start: 15
+              line_stop: 15
               col_start: 5
               col_stop: 10
               path: ""
               content: "r3: group = (0, 1)group;          "
           - mode: Private
             type_: Address
-            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;\\\"}\"}"
+            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":16,\\\"line_stop\\\":16,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;\\\"}\"}"
             value:
               Value:
                 Address:
                   - aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8
                   - span:
-                      line_start: 15
-                      line_stop: 15
+                      line_start: 16
+                      line_stop: 16
                       col_start: 15
                       col_stop: 78
                       path: ""
                       content: "r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
             span:
-              line_start: 15
-              line_stop: 15
+              line_start: 16
+              line_stop: 16
               col_start: 5
               col_stop: 12
               path: ""
               content: "r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;"
+          - mode: Private
+            type_:
+              IntegerType: I8
+            name: "{\"name\":\"r4\",\"span\":\"{\\\"line_start\\\":17,\\\"line_stop\\\":17,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"r4: i8 = -1;\\\"}\"}"
+            value:
+              Unary:
+                inner:
+                  Value:
+                    Implicit:
+                      - "1"
+                      - span:
+                          line_start: 17
+                          line_stop: 17
+                          col_start: 11
+                          col_stop: 12
+                          path: ""
+                          content: "r4: i8 = -1;"
+                op: Negate
+                span:
+                  line_start: 17
+                  line_stop: 17
+                  col_start: 10
+                  col_stop: 12
+                  path: ""
+                  content: "r4: i8 = -1;"
+            span:
+              line_start: 17
+              line_stop: 17
+              col_start: 5
+              col_stop: 7
+              path: ""
+              content: "r4: i8 = -1;"
         span:
-          line_start: 10
-          line_stop: 10
+          line_start: 11
+          line_stop: 11
           col_start: 2
           col_stop: 11
           path: ""
diff --git a/tests/parser/inputs/input_const.leo b/tests/parser/inputs/input_const.leo
index 7b7f179978..b14814c617 100644
--- a/tests/parser/inputs/input_const.leo
+++ b/tests/parser/inputs/input_const.leo
@@ -9,6 +9,7 @@ const b: u8    = 2;
 const c: field = 0;
 const d: group = (0, 1)group;
 const e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+const f: i8    = -2;
 
 [registers]
 r0: bool  = true;
@@ -16,3 +17,4 @@ r1: u8    = 2;
 r2: field = 0;
 r3: group = (0, 1)group;
 r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+r4: i8 = -1;
diff --git a/tests/parser/inputs/input_constant.leo b/tests/parser/inputs/input_constant.leo
index c14e72a52b..c005665000 100644
--- a/tests/parser/inputs/input_constant.leo
+++ b/tests/parser/inputs/input_constant.leo
@@ -9,6 +9,7 @@ constant b: u8    = 2;
 constant c: field = 0;
 constant d: group = (0, 1)group;
 constant e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+constant f: i8    = -2;
 
 [registers]
 r0: bool  = true;
@@ -16,3 +17,4 @@ r1: u8    = 2;
 r2: field = 0;
 r3: group = (0, 1)group;
 r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+r4: i8 = -1;
diff --git a/tests/parser/inputs/input_constant_public_fail.leo b/tests/parser/inputs/input_constant_public_fail.leo
index 5e892b9795..42f4205f72 100644
--- a/tests/parser/inputs/input_constant_public_fail.leo
+++ b/tests/parser/inputs/input_constant_public_fail.leo
@@ -9,6 +9,7 @@ constant public b: u8    = 2;
 constant public c: field = 0;                    
 constant public d: group = (0, 1)group;          
 constant public e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+constant public f: i8    = -2;
 
 [registers]
 r0: bool  = true;                 
@@ -16,4 +17,4 @@ r1: u8    = 2;
 r2: field = 0;                    
 r3: group = (0, 1)group;          
 r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
-
+r4: i8 = -1;
diff --git a/tests/parser/inputs/input_public.leo b/tests/parser/inputs/input_public.leo
index cc449fe9e1..bf2eeb7a34 100644
--- a/tests/parser/inputs/input_public.leo
+++ b/tests/parser/inputs/input_public.leo
@@ -9,6 +9,7 @@ public b: u8    = 2;
 public c: field = 0;                    
 public d: group = (0, 1)group;          
 public e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+public f: i8    = -2;
 
 [registers]
 r0: bool  = true;                 
@@ -16,4 +17,4 @@ r1: u8    = 2;
 r2: field = 0;                    
 r3: group = (0, 1)group;          
 r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
-
+r4: i8 = -1;
diff --git a/tests/parser/inputs/input_public_constant_fail.leo b/tests/parser/inputs/input_public_constant_fail.leo
index 94325d2ef4..1d7a53ae53 100644
--- a/tests/parser/inputs/input_public_constant_fail.leo
+++ b/tests/parser/inputs/input_public_constant_fail.leo
@@ -9,6 +9,8 @@ public constant b: u8    = 2;
 public constant c: field = 0;
 public constant d: group = (0, 1)group;
 public constant e: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+public constant f: i8    = -2;
+
 
 [registers]
 r0: bool  = true;
@@ -16,4 +18,4 @@ r1: u8    = 2;
 r2: field = 0;
 r3: group = (0, 1)group;
 r4: address = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
-
+r4: i8 = -1;