diff --git a/simple.program b/simple.program
index bd9432f151..0007bcbca0 100644
--- a/simple.program
+++ b/simple.program
@@ -1 +1 @@
-return a / 2
\ No newline at end of file
+x = 5 + 3
\ No newline at end of file
diff --git a/src/aleo_program/constraints.rs b/src/aleo_program/constraints.rs
index 12e8e13310..f4a482a2b0 100644
--- a/src/aleo_program/constraints.rs
+++ b/src/aleo_program/constraints.rs
@@ -13,15 +13,15 @@ fn bool_from_variable<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     variable: Variable,
 ) -> Boolean {
-    // let argument = std::env::args()
-    //     .nth(1)
-    //     .unwrap_or("true".into())
-    //     .parse::<bool>()
-    //     .unwrap();
-    //
-    // println!(" argument passed to command line a = {:?}", argument);
-    let a = true;
-    Boolean::alloc(cs.ns(|| variable.0), || Ok(a)).unwrap()
+    let argument = std::env::args()
+        .nth(1)
+        .unwrap_or("true".into())
+        .parse::<bool>()
+        .unwrap();
+
+    println!(" argument passed to command line a = {:?}", argument);
+    // let a = true;
+    Boolean::alloc_input(cs.ns(|| variable.0), || Ok(argument)).unwrap()
 }
 
 fn u32_from_variable<F: Field, CS: ConstraintSystem<F>>(cs: &mut CS, variable: Variable) -> UInt32 {
@@ -44,7 +44,7 @@ fn get_bool_value<F: Field, CS: ConstraintSystem<F>>(
     match expression {
         BooleanExpression::Variable(variable) => bool_from_variable(cs, variable),
         BooleanExpression::Value(value) => Boolean::Constant(value),
-        _ => unimplemented!(),
+        expression => enforce_boolean_expression(cs, expression),
     }
 }
 
@@ -55,7 +55,7 @@ fn get_u32_value<F: Field, CS: ConstraintSystem<F>>(
     match expression {
         FieldExpression::Variable(variable) => u32_from_variable(cs, variable),
         FieldExpression::Number(number) => UInt32::constant(number),
-        _ => unimplemented!(), // FieldExpression::Add(left, right) =>
+        field => enforce_field_expression(cs, field),
     }
 }
 
@@ -63,41 +63,43 @@ fn enforce_or<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: BooleanExpression,
     right: BooleanExpression,
-) {
+) -> Boolean {
     let left = get_bool_value(cs, left);
     let right = get_bool_value(cs, right);
 
-    let _result = Boolean::or(cs, &left, &right).unwrap();
+    Boolean::or(cs, &left, &right).unwrap()
 }
 
 fn enforce_and<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: BooleanExpression,
     right: BooleanExpression,
-) {
+) -> Boolean {
     let left = get_bool_value(cs, left);
     let right = get_bool_value(cs, right);
 
-    let _result = Boolean::and(cs, &left, &right).unwrap();
+    Boolean::and(cs, &left, &right).unwrap()
 }
 
 fn enforce_bool_equality<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: BooleanExpression,
     right: BooleanExpression,
-) {
+) -> Boolean {
     let left = get_bool_value(cs, left);
     let right = get_bool_value(cs, right);
 
     left.enforce_equal(cs.ns(|| format!("enforce bool equal")), &right)
         .unwrap();
+
+    Boolean::Constant(true)
 }
 
 fn enforce_field_equality<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: FieldExpression,
     right: FieldExpression,
-) {
+) -> Boolean {
     let left = get_u32_value(cs, left);
     let right = get_u32_value(cs, right);
 
@@ -107,25 +109,19 @@ fn enforce_field_equality<F: Field, CS: ConstraintSystem<F>>(
         &Boolean::Constant(true),
     )
     .unwrap();
+
+    Boolean::Constant(true)
 }
 
 fn enforce_boolean_expression<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     expression: BooleanExpression,
-) {
+) -> Boolean {
     match expression {
-        BooleanExpression::Or(left, right) => {
-            enforce_or(cs, *left, *right);
-        }
-        BooleanExpression::And(left, right) => {
-            enforce_and(cs, *left, *right);
-        }
-        BooleanExpression::BoolEq(left, right) => {
-            enforce_bool_equality(cs, *left, *right);
-        }
-        BooleanExpression::FieldEq(left, right) => {
-            enforce_field_equality(cs, *left, *right);
-        }
+        BooleanExpression::Or(left, right) => enforce_or(cs, *left, *right),
+        BooleanExpression::And(left, right) => enforce_and(cs, *left, *right),
+        BooleanExpression::BoolEq(left, right) => enforce_bool_equality(cs, *left, *right),
+        BooleanExpression::FieldEq(left, right) => enforce_field_equality(cs, *left, *right),
         _ => unimplemented!(),
     }
 }
@@ -134,87 +130,93 @@ fn enforce_add<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: FieldExpression,
     right: FieldExpression,
-) {
+) -> UInt32 {
     let left = get_u32_value(cs, left);
     let right = get_u32_value(cs, right);
 
-    let r = left
-        .add(
-            cs.ns(|| format!("enforce {} + {}", left.value.unwrap(), right.value.unwrap())),
-            &right,
-        )
-        .unwrap();
-    println!("result {}", r.value.unwrap());
+    left.add(
+        cs.ns(|| format!("enforce {} + {}", left.value.unwrap(), right.value.unwrap())),
+        &right,
+    )
+    .unwrap()
 }
 
 fn enforce_sub<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: FieldExpression,
     right: FieldExpression,
-) {
+) -> UInt32 {
     let left = get_u32_value(cs, left);
     let right = get_u32_value(cs, right);
 
-    let r = left
-        .sub(
-            cs.ns(|| format!("enforce {} - {}", left.value.unwrap(), right.value.unwrap())),
-            &right,
-        )
-        .unwrap();
-    println!("result {}", r.value.unwrap());
+    left.sub(
+        cs.ns(|| format!("enforce {} - {}", left.value.unwrap(), right.value.unwrap())),
+        &right,
+    )
+    .unwrap()
 }
 
 fn enforce_mul<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: FieldExpression,
     right: FieldExpression,
-) {
+) -> UInt32 {
     let left = get_u32_value(cs, left);
     let right = get_u32_value(cs, right);
 
-    let r = left
-        .mul(
-            cs.ns(|| format!("enforce {} * {}", left.value.unwrap(), right.value.unwrap())),
-            &right,
-        )
-        .unwrap();
-    println!("result {}", r.value.unwrap());
+    left.mul(
+        cs.ns(|| format!("enforce {} * {}", left.value.unwrap(), right.value.unwrap())),
+        &right,
+    )
+    .unwrap()
 }
 
 fn enforce_div<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     left: FieldExpression,
     right: FieldExpression,
-) {
+) -> UInt32 {
     let left = get_u32_value(cs, left);
     let right = get_u32_value(cs, right);
 
-    let r = left
-        .div(
-            cs.ns(|| format!("enforce {} / {}", left.value.unwrap(), right.value.unwrap())),
-            &right,
-        )
-        .unwrap();
-    println!("result {}", r.value.unwrap());
+    left.div(
+        cs.ns(|| format!("enforce {} / {}", left.value.unwrap(), right.value.unwrap())),
+        &right,
+    )
+    .unwrap()
+}
+
+fn enforce_pow<F: Field, CS: ConstraintSystem<F>>(
+    cs: &mut CS,
+    left: FieldExpression,
+    right: FieldExpression,
+) -> UInt32 {
+    let left = get_u32_value(cs, left);
+    let right = get_u32_value(cs, right);
+
+    left.pow(
+        cs.ns(|| {
+            format!(
+                "enforce {} ** {}",
+                left.value.unwrap(),
+                right.value.unwrap()
+            )
+        }),
+        &right,
+    )
+    .unwrap()
 }
 
 fn enforce_field_expression<F: Field, CS: ConstraintSystem<F>>(
     cs: &mut CS,
     expression: FieldExpression,
-) {
+) -> UInt32 {
     match expression {
-        FieldExpression::Add(left, right) => {
-            enforce_add(cs, *left, *right);
-        }
-        FieldExpression::Sub(left, right) => {
-            enforce_sub(cs, *left, *right);
-        }
-        FieldExpression::Mul(left, right) => {
-            enforce_mul(cs, *left, *right);
-        }
-        FieldExpression::Div(left, right) => {
-            enforce_div(cs, *left, *right);
-        }
+        FieldExpression::Add(left, right) => enforce_add(cs, *left, *right),
+        FieldExpression::Sub(left, right) => enforce_sub(cs, *left, *right),
+        FieldExpression::Mul(left, right) => enforce_mul(cs, *left, *right),
+        FieldExpression::Div(left, right) => enforce_div(cs, *left, *right),
+        FieldExpression::Pow(left, right) => enforce_pow(cs, *left, *right),
         _ => unimplemented!(),
     }
 }
@@ -224,15 +226,28 @@ pub fn generate_constraints<F: Field, CS: ConstraintSystem<F>>(cs: &mut CS, prog
         .statements
         .into_iter()
         .for_each(|statement| match statement {
+            Statement::Definition(variable, expression) => match expression {
+                Expression::Boolean(boolean_expression) => {
+                    let res = enforce_boolean_expression(cs, boolean_expression);
+                    println!("boolean result: {}", res.get_value().unwrap());
+                }
+                Expression::FieldElement(field_expression) => {
+                    let res = enforce_field_expression(cs, field_expression);
+                    println!("field result: {}", res.value.unwrap());
+                }
+                _ => unimplemented!(),
+            },
             Statement::Return(statements) => {
                 statements
                     .into_iter()
                     .for_each(|expression| match expression {
                         Expression::Boolean(boolean_expression) => {
-                            enforce_boolean_expression(cs, boolean_expression);
+                            let res = enforce_boolean_expression(cs, boolean_expression);
+                            println!("boolean result: {}", res.get_value().unwrap());
                         }
                         Expression::FieldElement(field_expression) => {
-                            enforce_field_expression(cs, field_expression);
+                            let res = enforce_field_expression(cs, field_expression);
+                            println!("field result: {}", res.value.unwrap());
                         }
                         _ => unimplemented!(),
                     });
diff --git a/src/aleo_program/types_from.rs b/src/aleo_program/types_from.rs
index 90033b4074..7b04a16c61 100644
--- a/src/aleo_program/types_from.rs
+++ b/src/aleo_program/types_from.rs
@@ -220,16 +220,21 @@ impl<'ast> From<ast::Expression<'ast>> for types::Expression {
     }
 }
 
-// impl<'ast> From<ast::AssignStatement<'ast>> for types::StatementNode<'ast> {
-//     fn from(statement: ast::AssignStatement<'ast>) -> Self {
-//         types::Statement::Definition(
-//             types::VariableNode::from(statement.variable),
-//             types::ExpressionNode::from(statement.expression),
-//         )
-//         .span(statement.span)
-//     }
-// }
-//
+impl<'ast> From<ast::Variable<'ast>> for types::Variable {
+    fn from(variable: ast::Variable<'ast>) -> Self {
+        types::Variable(variable.value)
+    }
+}
+
+impl<'ast> From<ast::AssignStatement<'ast>> for types::Statement {
+    fn from(statement: ast::AssignStatement<'ast>) -> Self {
+        types::Statement::Definition(
+            types::Variable::from(statement.variable),
+            types::Expression::from(statement.expression),
+        )
+    }
+}
+
 impl<'ast> From<ast::ReturnStatement<'ast>> for types::Statement {
     fn from(statement: ast::ReturnStatement<'ast>) -> Self {
         types::Statement::Return(