diff --git a/.aztec-sync-commit b/.aztec-sync-commit
index 973bfd1534b..ead8f3147c0 100644
--- a/.aztec-sync-commit
+++ b/.aztec-sync-commit
@@ -1 +1 @@
-82f8cf5eba9deacdab43ad4ef95dbf27dd1c11c7
+208abbb63af4c9a3f25d723fe1c49e82aa461061
diff --git a/Cargo.lock b/Cargo.lock
index 37bf5135468..99c19417267 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -439,6 +439,7 @@ dependencies = [
  "iter-extended",
  "noirc_errors",
  "noirc_frontend",
+ "regex",
 ]
 
 [[package]]
@@ -2655,9 +2656,9 @@ checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "memmap2"
@@ -3822,14 +3823,14 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.1"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2eae68fc220f7cf2532e4494aded17545fce192d59cd996e0fe7887f4ceb575"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.3.3",
- "regex-syntax 0.7.4",
+ "regex-automata 0.4.5",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -3846,10 +3847,16 @@ name = "regex-automata"
 version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39354c10dd07468c2e73926b23bb9c2caca74c5501e38a35da70406f1d923310"
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.7.4",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -3864,6 +3871,12 @@ version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
 
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
 [[package]]
 name = "region"
 version = "3.0.0"
diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
index 11afd44ed6d..ca281d89637 100644
--- a/acvm-repo/acir/codegen/acir.cpp
+++ b/acvm-repo/acir/codegen/acir.cpp
@@ -3,7 +3,7 @@
 #include "serde.hpp"
 #include "bincode.hpp"
 
-namespace Circuit {
+namespace Program {
 
     struct BinaryFieldOp {
 
@@ -152,7 +152,7 @@ namespace Circuit {
     };
 
     struct HeapArray {
-        Circuit::MemoryAddress pointer;
+        Program::MemoryAddress pointer;
         uint64_t size;
 
         friend bool operator==(const HeapArray&, const HeapArray&);
@@ -161,8 +161,8 @@ namespace Circuit {
     };
 
     struct HeapVector {
-        Circuit::MemoryAddress pointer;
-        Circuit::MemoryAddress size;
+        Program::MemoryAddress pointer;
+        Program::MemoryAddress size;
 
         friend bool operator==(const HeapVector&, const HeapVector&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -172,8 +172,8 @@ namespace Circuit {
     struct BlackBoxOp {
 
         struct Sha256 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Sha256&, const Sha256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -181,8 +181,8 @@ namespace Circuit {
         };
 
         struct Blake2s {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -190,8 +190,8 @@ namespace Circuit {
         };
 
         struct Blake3 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -199,8 +199,8 @@ namespace Circuit {
         };
 
         struct Keccak256 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -208,8 +208,8 @@ namespace Circuit {
         };
 
         struct Keccakf1600 {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
+            Program::HeapVector message;
+            Program::HeapArray output;
 
             friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -217,11 +217,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256k1 {
-            Circuit::HeapVector hashed_msg;
-            Circuit::HeapArray public_key_x;
-            Circuit::HeapArray public_key_y;
-            Circuit::HeapArray signature;
-            Circuit::MemoryAddress result;
+            Program::HeapVector hashed_msg;
+            Program::HeapArray public_key_x;
+            Program::HeapArray public_key_y;
+            Program::HeapArray signature;
+            Program::MemoryAddress result;
 
             friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -229,11 +229,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256r1 {
-            Circuit::HeapVector hashed_msg;
-            Circuit::HeapArray public_key_x;
-            Circuit::HeapArray public_key_y;
-            Circuit::HeapArray signature;
-            Circuit::MemoryAddress result;
+            Program::HeapVector hashed_msg;
+            Program::HeapArray public_key_x;
+            Program::HeapArray public_key_y;
+            Program::HeapArray signature;
+            Program::MemoryAddress result;
 
             friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -241,11 +241,11 @@ namespace Circuit {
         };
 
         struct SchnorrVerify {
-            Circuit::MemoryAddress public_key_x;
-            Circuit::MemoryAddress public_key_y;
-            Circuit::HeapVector message;
-            Circuit::HeapVector signature;
-            Circuit::MemoryAddress result;
+            Program::MemoryAddress public_key_x;
+            Program::MemoryAddress public_key_y;
+            Program::HeapVector message;
+            Program::HeapVector signature;
+            Program::MemoryAddress result;
 
             friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -253,9 +253,9 @@ namespace Circuit {
         };
 
         struct PedersenCommitment {
-            Circuit::HeapVector inputs;
-            Circuit::MemoryAddress domain_separator;
-            Circuit::HeapArray output;
+            Program::HeapVector inputs;
+            Program::MemoryAddress domain_separator;
+            Program::HeapArray output;
 
             friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -263,9 +263,9 @@ namespace Circuit {
         };
 
         struct PedersenHash {
-            Circuit::HeapVector inputs;
-            Circuit::MemoryAddress domain_separator;
-            Circuit::MemoryAddress output;
+            Program::HeapVector inputs;
+            Program::MemoryAddress domain_separator;
+            Program::MemoryAddress output;
 
             friend bool operator==(const PedersenHash&, const PedersenHash&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -273,9 +273,9 @@ namespace Circuit {
         };
 
         struct FixedBaseScalarMul {
-            Circuit::MemoryAddress low;
-            Circuit::MemoryAddress high;
-            Circuit::HeapArray result;
+            Program::MemoryAddress low;
+            Program::MemoryAddress high;
+            Program::HeapArray result;
 
             friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -283,11 +283,11 @@ namespace Circuit {
         };
 
         struct EmbeddedCurveAdd {
-            Circuit::MemoryAddress input1_x;
-            Circuit::MemoryAddress input1_y;
-            Circuit::MemoryAddress input2_x;
-            Circuit::MemoryAddress input2_y;
-            Circuit::HeapArray result;
+            Program::MemoryAddress input1_x;
+            Program::MemoryAddress input1_y;
+            Program::MemoryAddress input2_x;
+            Program::MemoryAddress input2_y;
+            Program::HeapArray result;
 
             friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -295,9 +295,9 @@ namespace Circuit {
         };
 
         struct BigIntAdd {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntAdd&, const BigIntAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -305,9 +305,9 @@ namespace Circuit {
         };
 
         struct BigIntSub {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntSub&, const BigIntSub&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -315,9 +315,9 @@ namespace Circuit {
         };
 
         struct BigIntMul {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntMul&, const BigIntMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -325,9 +325,9 @@ namespace Circuit {
         };
 
         struct BigIntDiv {
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
-            Circuit::MemoryAddress output;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntDiv&, const BigIntDiv&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -335,9 +335,9 @@ namespace Circuit {
         };
 
         struct BigIntFromLeBytes {
-            Circuit::HeapVector inputs;
-            Circuit::HeapVector modulus;
-            Circuit::MemoryAddress output;
+            Program::HeapVector inputs;
+            Program::HeapVector modulus;
+            Program::MemoryAddress output;
 
             friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -345,8 +345,8 @@ namespace Circuit {
         };
 
         struct BigIntToLeBytes {
-            Circuit::MemoryAddress input;
-            Circuit::HeapVector output;
+            Program::MemoryAddress input;
+            Program::HeapVector output;
 
             friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -354,9 +354,9 @@ namespace Circuit {
         };
 
         struct Poseidon2Permutation {
-            Circuit::HeapVector message;
-            Circuit::HeapArray output;
-            Circuit::MemoryAddress len;
+            Program::HeapVector message;
+            Program::HeapArray output;
+            Program::MemoryAddress len;
 
             friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -364,9 +364,9 @@ namespace Circuit {
         };
 
         struct Sha256Compression {
-            Circuit::HeapVector input;
-            Circuit::HeapVector hash_values;
-            Circuit::HeapArray output;
+            Program::HeapVector input;
+            Program::HeapVector hash_values;
+            Program::HeapArray output;
 
             friend bool operator==(const Sha256Compression&, const Sha256Compression&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -391,7 +391,7 @@ namespace Circuit {
         };
 
         struct Array {
-            std::vector<Circuit::HeapValueType> value_types;
+            std::vector<Program::HeapValueType> value_types;
             uint64_t size;
 
             friend bool operator==(const Array&, const Array&);
@@ -400,7 +400,7 @@ namespace Circuit {
         };
 
         struct Vector {
-            std::vector<Circuit::HeapValueType> value_types;
+            std::vector<Program::HeapValueType> value_types;
 
             friend bool operator==(const Vector&, const Vector&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -425,7 +425,7 @@ namespace Circuit {
     struct ValueOrArray {
 
         struct MemoryAddress {
-            Circuit::MemoryAddress value;
+            Program::MemoryAddress value;
 
             friend bool operator==(const MemoryAddress&, const MemoryAddress&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -433,7 +433,7 @@ namespace Circuit {
         };
 
         struct HeapArray {
-            Circuit::HeapArray value;
+            Program::HeapArray value;
 
             friend bool operator==(const HeapArray&, const HeapArray&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -441,7 +441,7 @@ namespace Circuit {
         };
 
         struct HeapVector {
-            Circuit::HeapVector value;
+            Program::HeapVector value;
 
             friend bool operator==(const HeapVector&, const HeapVector&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -458,10 +458,10 @@ namespace Circuit {
     struct BrilligOpcode {
 
         struct BinaryFieldOp {
-            Circuit::MemoryAddress destination;
-            Circuit::BinaryFieldOp op;
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
+            Program::MemoryAddress destination;
+            Program::BinaryFieldOp op;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
 
             friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -469,11 +469,11 @@ namespace Circuit {
         };
 
         struct BinaryIntOp {
-            Circuit::MemoryAddress destination;
-            Circuit::BinaryIntOp op;
+            Program::MemoryAddress destination;
+            Program::BinaryIntOp op;
             uint32_t bit_size;
-            Circuit::MemoryAddress lhs;
-            Circuit::MemoryAddress rhs;
+            Program::MemoryAddress lhs;
+            Program::MemoryAddress rhs;
 
             friend bool operator==(const BinaryIntOp&, const BinaryIntOp&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -481,8 +481,8 @@ namespace Circuit {
         };
 
         struct Cast {
-            Circuit::MemoryAddress destination;
-            Circuit::MemoryAddress source;
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source;
             uint32_t bit_size;
 
             friend bool operator==(const Cast&, const Cast&);
@@ -491,7 +491,7 @@ namespace Circuit {
         };
 
         struct JumpIfNot {
-            Circuit::MemoryAddress condition;
+            Program::MemoryAddress condition;
             uint64_t location;
 
             friend bool operator==(const JumpIfNot&, const JumpIfNot&);
@@ -500,7 +500,7 @@ namespace Circuit {
         };
 
         struct JumpIf {
-            Circuit::MemoryAddress condition;
+            Program::MemoryAddress condition;
             uint64_t location;
 
             friend bool operator==(const JumpIf&, const JumpIf&);
@@ -517,7 +517,7 @@ namespace Circuit {
         };
 
         struct CalldataCopy {
-            Circuit::MemoryAddress destination_address;
+            Program::MemoryAddress destination_address;
             uint64_t size;
             uint64_t offset;
 
@@ -535,9 +535,9 @@ namespace Circuit {
         };
 
         struct Const {
-            Circuit::MemoryAddress destination;
+            Program::MemoryAddress destination;
             uint32_t bit_size;
-            Circuit::Value value;
+            Program::Value value;
 
             friend bool operator==(const Const&, const Const&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -552,10 +552,10 @@ namespace Circuit {
 
         struct ForeignCall {
             std::string function;
-            std::vector<Circuit::ValueOrArray> destinations;
-            std::vector<Circuit::HeapValueType> destination_value_types;
-            std::vector<Circuit::ValueOrArray> inputs;
-            std::vector<Circuit::HeapValueType> input_value_types;
+            std::vector<Program::ValueOrArray> destinations;
+            std::vector<Program::HeapValueType> destination_value_types;
+            std::vector<Program::ValueOrArray> inputs;
+            std::vector<Program::HeapValueType> input_value_types;
 
             friend bool operator==(const ForeignCall&, const ForeignCall&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -563,17 +563,28 @@ namespace Circuit {
         };
 
         struct Mov {
-            Circuit::MemoryAddress destination;
-            Circuit::MemoryAddress source;
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source;
 
             friend bool operator==(const Mov&, const Mov&);
             std::vector<uint8_t> bincodeSerialize() const;
             static Mov bincodeDeserialize(std::vector<uint8_t>);
         };
 
+        struct ConditionalMov {
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source_a;
+            Program::MemoryAddress source_b;
+            Program::MemoryAddress condition;
+
+            friend bool operator==(const ConditionalMov&, const ConditionalMov&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static ConditionalMov bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Load {
-            Circuit::MemoryAddress destination;
-            Circuit::MemoryAddress source_pointer;
+            Program::MemoryAddress destination;
+            Program::MemoryAddress source_pointer;
 
             friend bool operator==(const Load&, const Load&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -581,8 +592,8 @@ namespace Circuit {
         };
 
         struct Store {
-            Circuit::MemoryAddress destination_pointer;
-            Circuit::MemoryAddress source;
+            Program::MemoryAddress destination_pointer;
+            Program::MemoryAddress source;
 
             friend bool operator==(const Store&, const Store&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -590,7 +601,7 @@ namespace Circuit {
         };
 
         struct BlackBox {
-            Circuit::BlackBoxOp value;
+            Program::BlackBoxOp value;
 
             friend bool operator==(const BlackBox&, const BlackBox&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -612,7 +623,7 @@ namespace Circuit {
             static Stop bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, Load, Store, BlackBox, Trap, Stop> value;
+        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, ConditionalMov, Load, Store, BlackBox, Trap, Stop> value;
 
         friend bool operator==(const BrilligOpcode&, const BrilligOpcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -628,7 +639,7 @@ namespace Circuit {
     };
 
     struct FunctionInput {
-        Circuit::Witness witness;
+        Program::Witness witness;
         uint32_t num_bits;
 
         friend bool operator==(const FunctionInput&, const FunctionInput&);
@@ -639,9 +650,9 @@ namespace Circuit {
     struct BlackBoxFuncCall {
 
         struct AND {
-            Circuit::FunctionInput lhs;
-            Circuit::FunctionInput rhs;
-            Circuit::Witness output;
+            Program::FunctionInput lhs;
+            Program::FunctionInput rhs;
+            Program::Witness output;
 
             friend bool operator==(const AND&, const AND&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -649,9 +660,9 @@ namespace Circuit {
         };
 
         struct XOR {
-            Circuit::FunctionInput lhs;
-            Circuit::FunctionInput rhs;
-            Circuit::Witness output;
+            Program::FunctionInput lhs;
+            Program::FunctionInput rhs;
+            Program::Witness output;
 
             friend bool operator==(const XOR&, const XOR&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -659,7 +670,7 @@ namespace Circuit {
         };
 
         struct RANGE {
-            Circuit::FunctionInput input;
+            Program::FunctionInput input;
 
             friend bool operator==(const RANGE&, const RANGE&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -667,8 +678,8 @@ namespace Circuit {
         };
 
         struct SHA256 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const SHA256&, const SHA256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -676,8 +687,8 @@ namespace Circuit {
         };
 
         struct Blake2s {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Blake2s&, const Blake2s&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -685,8 +696,8 @@ namespace Circuit {
         };
 
         struct Blake3 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Blake3&, const Blake3&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -694,11 +705,11 @@ namespace Circuit {
         };
 
         struct SchnorrVerify {
-            Circuit::FunctionInput public_key_x;
-            Circuit::FunctionInput public_key_y;
-            std::vector<Circuit::FunctionInput> signature;
-            std::vector<Circuit::FunctionInput> message;
-            Circuit::Witness output;
+            Program::FunctionInput public_key_x;
+            Program::FunctionInput public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> message;
+            Program::Witness output;
 
             friend bool operator==(const SchnorrVerify&, const SchnorrVerify&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -706,9 +717,9 @@ namespace Circuit {
         };
 
         struct PedersenCommitment {
-            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> inputs;
             uint32_t domain_separator;
-            std::array<Circuit::Witness, 2> outputs;
+            std::array<Program::Witness, 2> outputs;
 
             friend bool operator==(const PedersenCommitment&, const PedersenCommitment&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -716,9 +727,9 @@ namespace Circuit {
         };
 
         struct PedersenHash {
-            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> inputs;
             uint32_t domain_separator;
-            Circuit::Witness output;
+            Program::Witness output;
 
             friend bool operator==(const PedersenHash&, const PedersenHash&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -726,11 +737,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256k1 {
-            std::vector<Circuit::FunctionInput> public_key_x;
-            std::vector<Circuit::FunctionInput> public_key_y;
-            std::vector<Circuit::FunctionInput> signature;
-            std::vector<Circuit::FunctionInput> hashed_message;
-            Circuit::Witness output;
+            std::vector<Program::FunctionInput> public_key_x;
+            std::vector<Program::FunctionInput> public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> hashed_message;
+            Program::Witness output;
 
             friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -738,11 +749,11 @@ namespace Circuit {
         };
 
         struct EcdsaSecp256r1 {
-            std::vector<Circuit::FunctionInput> public_key_x;
-            std::vector<Circuit::FunctionInput> public_key_y;
-            std::vector<Circuit::FunctionInput> signature;
-            std::vector<Circuit::FunctionInput> hashed_message;
-            Circuit::Witness output;
+            std::vector<Program::FunctionInput> public_key_x;
+            std::vector<Program::FunctionInput> public_key_y;
+            std::vector<Program::FunctionInput> signature;
+            std::vector<Program::FunctionInput> hashed_message;
+            Program::Witness output;
 
             friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -750,9 +761,9 @@ namespace Circuit {
         };
 
         struct FixedBaseScalarMul {
-            Circuit::FunctionInput low;
-            Circuit::FunctionInput high;
-            std::array<Circuit::Witness, 2> outputs;
+            Program::FunctionInput low;
+            Program::FunctionInput high;
+            std::array<Program::Witness, 2> outputs;
 
             friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -760,11 +771,11 @@ namespace Circuit {
         };
 
         struct EmbeddedCurveAdd {
-            Circuit::FunctionInput input1_x;
-            Circuit::FunctionInput input1_y;
-            Circuit::FunctionInput input2_x;
-            Circuit::FunctionInput input2_y;
-            std::array<Circuit::Witness, 2> outputs;
+            Program::FunctionInput input1_x;
+            Program::FunctionInput input1_y;
+            Program::FunctionInput input2_x;
+            Program::FunctionInput input2_y;
+            std::array<Program::Witness, 2> outputs;
 
             friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -772,8 +783,8 @@ namespace Circuit {
         };
 
         struct Keccak256 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccak256&, const Keccak256&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -781,9 +792,9 @@ namespace Circuit {
         };
 
         struct Keccak256VariableLength {
-            std::vector<Circuit::FunctionInput> inputs;
-            Circuit::FunctionInput var_message_size;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            Program::FunctionInput var_message_size;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccak256VariableLength&, const Keccak256VariableLength&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -791,8 +802,8 @@ namespace Circuit {
         };
 
         struct Keccakf1600 {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Keccakf1600&, const Keccakf1600&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -800,10 +811,10 @@ namespace Circuit {
         };
 
         struct RecursiveAggregation {
-            std::vector<Circuit::FunctionInput> verification_key;
-            std::vector<Circuit::FunctionInput> proof;
-            std::vector<Circuit::FunctionInput> public_inputs;
-            Circuit::FunctionInput key_hash;
+            std::vector<Program::FunctionInput> verification_key;
+            std::vector<Program::FunctionInput> proof;
+            std::vector<Program::FunctionInput> public_inputs;
+            Program::FunctionInput key_hash;
 
             friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -851,7 +862,7 @@ namespace Circuit {
         };
 
         struct BigIntFromLeBytes {
-            std::vector<Circuit::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> inputs;
             std::vector<uint8_t> modulus;
             uint32_t output;
 
@@ -862,7 +873,7 @@ namespace Circuit {
 
         struct BigIntToLeBytes {
             uint32_t input;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -870,8 +881,8 @@ namespace Circuit {
         };
 
         struct Poseidon2Permutation {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::Witness> outputs;
             uint32_t len;
 
             friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&);
@@ -880,9 +891,9 @@ namespace Circuit {
         };
 
         struct Sha256Compression {
-            std::vector<Circuit::FunctionInput> inputs;
-            std::vector<Circuit::FunctionInput> hash_values;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::FunctionInput> inputs;
+            std::vector<Program::FunctionInput> hash_values;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Sha256Compression&, const Sha256Compression&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -905,8 +916,8 @@ namespace Circuit {
     };
 
     struct Expression {
-        std::vector<std::tuple<std::string, Circuit::Witness, Circuit::Witness>> mul_terms;
-        std::vector<std::tuple<std::string, Circuit::Witness>> linear_combinations;
+        std::vector<std::tuple<std::string, Program::Witness, Program::Witness>> mul_terms;
+        std::vector<std::tuple<std::string, Program::Witness>> linear_combinations;
         std::string q_c;
 
         friend bool operator==(const Expression&, const Expression&);
@@ -917,7 +928,7 @@ namespace Circuit {
     struct BrilligInputs {
 
         struct Single {
-            Circuit::Expression value;
+            Program::Expression value;
 
             friend bool operator==(const Single&, const Single&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -925,7 +936,7 @@ namespace Circuit {
         };
 
         struct Array {
-            std::vector<Circuit::Expression> value;
+            std::vector<Program::Expression> value;
 
             friend bool operator==(const Array&, const Array&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -933,7 +944,7 @@ namespace Circuit {
         };
 
         struct MemoryArray {
-            Circuit::BlockId value;
+            Program::BlockId value;
 
             friend bool operator==(const MemoryArray&, const MemoryArray&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -950,7 +961,7 @@ namespace Circuit {
     struct BrilligOutputs {
 
         struct Simple {
-            Circuit::Witness value;
+            Program::Witness value;
 
             friend bool operator==(const Simple&, const Simple&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -958,7 +969,7 @@ namespace Circuit {
         };
 
         struct Array {
-            std::vector<Circuit::Witness> value;
+            std::vector<Program::Witness> value;
 
             friend bool operator==(const Array&, const Array&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -973,10 +984,10 @@ namespace Circuit {
     };
 
     struct Brillig {
-        std::vector<Circuit::BrilligInputs> inputs;
-        std::vector<Circuit::BrilligOutputs> outputs;
-        std::vector<Circuit::BrilligOpcode> bytecode;
-        std::optional<Circuit::Expression> predicate;
+        std::vector<Program::BrilligInputs> inputs;
+        std::vector<Program::BrilligOutputs> outputs;
+        std::vector<Program::BrilligOpcode> bytecode;
+        std::optional<Program::Expression> predicate;
 
         friend bool operator==(const Brillig&, const Brillig&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -986,8 +997,8 @@ namespace Circuit {
     struct Directive {
 
         struct ToLeRadix {
-            Circuit::Expression a;
-            std::vector<Circuit::Witness> b;
+            Program::Expression a;
+            std::vector<Program::Witness> b;
             uint32_t radix;
 
             friend bool operator==(const ToLeRadix&, const ToLeRadix&);
@@ -1003,9 +1014,9 @@ namespace Circuit {
     };
 
     struct MemOp {
-        Circuit::Expression operation;
-        Circuit::Expression index;
-        Circuit::Expression value;
+        Program::Expression operation;
+        Program::Expression index;
+        Program::Expression value;
 
         friend bool operator==(const MemOp&, const MemOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1015,7 +1026,7 @@ namespace Circuit {
     struct Opcode {
 
         struct AssertZero {
-            Circuit::Expression value;
+            Program::Expression value;
 
             friend bool operator==(const AssertZero&, const AssertZero&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1023,7 +1034,7 @@ namespace Circuit {
         };
 
         struct BlackBoxFuncCall {
-            Circuit::BlackBoxFuncCall value;
+            Program::BlackBoxFuncCall value;
 
             friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1031,7 +1042,7 @@ namespace Circuit {
         };
 
         struct Directive {
-            Circuit::Directive value;
+            Program::Directive value;
 
             friend bool operator==(const Directive&, const Directive&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1039,7 +1050,7 @@ namespace Circuit {
         };
 
         struct Brillig {
-            Circuit::Brillig value;
+            Program::Brillig value;
 
             friend bool operator==(const Brillig&, const Brillig&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1047,9 +1058,9 @@ namespace Circuit {
         };
 
         struct MemoryOp {
-            Circuit::BlockId block_id;
-            Circuit::MemOp op;
-            std::optional<Circuit::Expression> predicate;
+            Program::BlockId block_id;
+            Program::MemOp op;
+            std::optional<Program::Expression> predicate;
 
             friend bool operator==(const MemoryOp&, const MemoryOp&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1057,8 +1068,8 @@ namespace Circuit {
         };
 
         struct MemoryInit {
-            Circuit::BlockId block_id;
-            std::vector<Circuit::Witness> init;
+            Program::BlockId block_id;
+            std::vector<Program::Witness> init;
 
             friend bool operator==(const MemoryInit&, const MemoryInit&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1067,8 +1078,8 @@ namespace Circuit {
 
         struct Call {
             uint32_t id;
-            std::vector<Circuit::Witness> inputs;
-            std::vector<Circuit::Witness> outputs;
+            std::vector<Program::Witness> inputs;
+            std::vector<Program::Witness> outputs;
 
             friend bool operator==(const Call&, const Call&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -1132,7 +1143,7 @@ namespace Circuit {
     };
 
     struct PublicInputs {
-        std::vector<Circuit::Witness> value;
+        std::vector<Program::Witness> value;
 
         friend bool operator==(const PublicInputs&, const PublicInputs&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1141,12 +1152,12 @@ namespace Circuit {
 
     struct Circuit {
         uint32_t current_witness_index;
-        std::vector<Circuit::Opcode> opcodes;
-        Circuit::ExpressionWidth expression_width;
-        std::vector<Circuit::Witness> private_parameters;
-        Circuit::PublicInputs public_parameters;
-        Circuit::PublicInputs return_values;
-        std::vector<std::tuple<Circuit::OpcodeLocation, std::string>> assert_messages;
+        std::vector<Program::Opcode> opcodes;
+        Program::ExpressionWidth expression_width;
+        std::vector<Program::Witness> private_parameters;
+        Program::PublicInputs public_parameters;
+        Program::PublicInputs return_values;
+        std::vector<std::tuple<Program::OpcodeLocation, std::string>> assert_messages;
         bool recursive;
 
         friend bool operator==(const Circuit&, const Circuit&);
@@ -1154,10 +1165,18 @@ namespace Circuit {
         static Circuit bincodeDeserialize(std::vector<uint8_t>);
     };
 
-} // end of namespace Circuit
+    struct Program {
+        std::vector<Program::Circuit> functions;
 
+        friend bool operator==(const Program&, const Program&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static Program bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+} // end of namespace Program
 
-namespace Circuit {
+
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -1179,11 +1198,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp>::serialize(const Circuit::BinaryFieldOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp>::serialize(const Program::BinaryFieldOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -1191,15 +1210,15 @@ void serde::Serializable<Circuit::BinaryFieldOp>::serialize(const Circuit::Binar
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp serde::Deserializable<Circuit::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
+Program::BinaryFieldOp serde::Deserializable<Program::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BinaryFieldOp obj;
+    Program::BinaryFieldOp obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Add &lhs, const BinaryFieldOp::Add &rhs) {
         return true;
@@ -1220,21 +1239,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Add>::serialize(const Circuit::BinaryFieldOp::Add &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Add>::serialize(const Program::BinaryFieldOp::Add &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Add serde::Deserializable<Circuit::BinaryFieldOp::Add>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Add obj;
+Program::BinaryFieldOp::Add serde::Deserializable<Program::BinaryFieldOp::Add>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Add obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Sub &lhs, const BinaryFieldOp::Sub &rhs) {
         return true;
@@ -1255,21 +1274,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Sub>::serialize(const Circuit::BinaryFieldOp::Sub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Sub>::serialize(const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Sub serde::Deserializable<Circuit::BinaryFieldOp::Sub>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Sub obj;
+Program::BinaryFieldOp::Sub serde::Deserializable<Program::BinaryFieldOp::Sub>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Sub obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Mul &lhs, const BinaryFieldOp::Mul &rhs) {
         return true;
@@ -1290,21 +1309,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Mul>::serialize(const Circuit::BinaryFieldOp::Mul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Mul>::serialize(const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Mul serde::Deserializable<Circuit::BinaryFieldOp::Mul>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Mul obj;
+Program::BinaryFieldOp::Mul serde::Deserializable<Program::BinaryFieldOp::Mul>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Mul obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Div &lhs, const BinaryFieldOp::Div &rhs) {
         return true;
@@ -1325,21 +1344,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Div>::serialize(const Circuit::BinaryFieldOp::Div &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Div>::serialize(const Program::BinaryFieldOp::Div &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Div serde::Deserializable<Circuit::BinaryFieldOp::Div>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Div obj;
+Program::BinaryFieldOp::Div serde::Deserializable<Program::BinaryFieldOp::Div>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Div obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) {
         return true;
@@ -1360,21 +1379,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::IntegerDiv>::serialize(const Circuit::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::IntegerDiv>::serialize(const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::IntegerDiv serde::Deserializable<Circuit::BinaryFieldOp::IntegerDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::IntegerDiv obj;
+Program::BinaryFieldOp::IntegerDiv serde::Deserializable<Program::BinaryFieldOp::IntegerDiv>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::IntegerDiv obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) {
         return true;
@@ -1395,21 +1414,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::Equals>::serialize(const Circuit::BinaryFieldOp::Equals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::Equals>::serialize(const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::Equals serde::Deserializable<Circuit::BinaryFieldOp::Equals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::Equals obj;
+Program::BinaryFieldOp::Equals serde::Deserializable<Program::BinaryFieldOp::Equals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::Equals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) {
         return true;
@@ -1430,21 +1449,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::LessThan>::serialize(const Circuit::BinaryFieldOp::LessThan &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::LessThan>::serialize(const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::LessThan serde::Deserializable<Circuit::BinaryFieldOp::LessThan>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::LessThan obj;
+Program::BinaryFieldOp::LessThan serde::Deserializable<Program::BinaryFieldOp::LessThan>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::LessThan obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) {
         return true;
@@ -1465,21 +1484,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryFieldOp::LessThanEquals>::serialize(const Circuit::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryFieldOp::LessThanEquals>::serialize(const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryFieldOp::LessThanEquals serde::Deserializable<Circuit::BinaryFieldOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryFieldOp::LessThanEquals obj;
+Program::BinaryFieldOp::LessThanEquals serde::Deserializable<Program::BinaryFieldOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryFieldOp::LessThanEquals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -1501,11 +1520,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp>::serialize(const Circuit::BinaryIntOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp>::serialize(const Program::BinaryIntOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -1513,15 +1532,15 @@ void serde::Serializable<Circuit::BinaryIntOp>::serialize(const Circuit::BinaryI
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp serde::Deserializable<Circuit::BinaryIntOp>::deserialize(Deserializer &deserializer) {
+Program::BinaryIntOp serde::Deserializable<Program::BinaryIntOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BinaryIntOp obj;
+    Program::BinaryIntOp obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Add &lhs, const BinaryIntOp::Add &rhs) {
         return true;
@@ -1542,21 +1561,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Add>::serialize(const Circuit::BinaryIntOp::Add &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Add>::serialize(const Program::BinaryIntOp::Add &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Add serde::Deserializable<Circuit::BinaryIntOp::Add>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Add obj;
+Program::BinaryIntOp::Add serde::Deserializable<Program::BinaryIntOp::Add>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Add obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Sub &lhs, const BinaryIntOp::Sub &rhs) {
         return true;
@@ -1577,21 +1596,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Sub>::serialize(const Circuit::BinaryIntOp::Sub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Sub>::serialize(const Program::BinaryIntOp::Sub &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Sub serde::Deserializable<Circuit::BinaryIntOp::Sub>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Sub obj;
+Program::BinaryIntOp::Sub serde::Deserializable<Program::BinaryIntOp::Sub>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Sub obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Mul &lhs, const BinaryIntOp::Mul &rhs) {
         return true;
@@ -1612,21 +1631,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Mul>::serialize(const Circuit::BinaryIntOp::Mul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Mul>::serialize(const Program::BinaryIntOp::Mul &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Mul serde::Deserializable<Circuit::BinaryIntOp::Mul>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Mul obj;
+Program::BinaryIntOp::Mul serde::Deserializable<Program::BinaryIntOp::Mul>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Mul obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Div &lhs, const BinaryIntOp::Div &rhs) {
         return true;
@@ -1647,21 +1666,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Div>::serialize(const Circuit::BinaryIntOp::Div &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Div>::serialize(const Program::BinaryIntOp::Div &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Div serde::Deserializable<Circuit::BinaryIntOp::Div>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Div obj;
+Program::BinaryIntOp::Div serde::Deserializable<Program::BinaryIntOp::Div>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Div obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Equals &lhs, const BinaryIntOp::Equals &rhs) {
         return true;
@@ -1682,21 +1701,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Equals>::serialize(const Circuit::BinaryIntOp::Equals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Equals>::serialize(const Program::BinaryIntOp::Equals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Equals serde::Deserializable<Circuit::BinaryIntOp::Equals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Equals obj;
+Program::BinaryIntOp::Equals serde::Deserializable<Program::BinaryIntOp::Equals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Equals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::LessThan &lhs, const BinaryIntOp::LessThan &rhs) {
         return true;
@@ -1717,21 +1736,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::LessThan>::serialize(const Circuit::BinaryIntOp::LessThan &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::LessThan>::serialize(const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::LessThan serde::Deserializable<Circuit::BinaryIntOp::LessThan>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::LessThan obj;
+Program::BinaryIntOp::LessThan serde::Deserializable<Program::BinaryIntOp::LessThan>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::LessThan obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, const BinaryIntOp::LessThanEquals &rhs) {
         return true;
@@ -1752,21 +1771,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::LessThanEquals>::serialize(const Circuit::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::LessThanEquals>::serialize(const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::LessThanEquals serde::Deserializable<Circuit::BinaryIntOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::LessThanEquals obj;
+Program::BinaryIntOp::LessThanEquals serde::Deserializable<Program::BinaryIntOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::LessThanEquals obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::And &lhs, const BinaryIntOp::And &rhs) {
         return true;
@@ -1787,21 +1806,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::And>::serialize(const Circuit::BinaryIntOp::And &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::And>::serialize(const Program::BinaryIntOp::And &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::And serde::Deserializable<Circuit::BinaryIntOp::And>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::And obj;
+Program::BinaryIntOp::And serde::Deserializable<Program::BinaryIntOp::And>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::And obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) {
         return true;
@@ -1822,21 +1841,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Or>::serialize(const Circuit::BinaryIntOp::Or &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Or>::serialize(const Program::BinaryIntOp::Or &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Or serde::Deserializable<Circuit::BinaryIntOp::Or>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Or obj;
+Program::BinaryIntOp::Or serde::Deserializable<Program::BinaryIntOp::Or>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Or obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Xor &lhs, const BinaryIntOp::Xor &rhs) {
         return true;
@@ -1857,21 +1876,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Xor>::serialize(const Circuit::BinaryIntOp::Xor &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Xor>::serialize(const Program::BinaryIntOp::Xor &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Xor serde::Deserializable<Circuit::BinaryIntOp::Xor>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Xor obj;
+Program::BinaryIntOp::Xor serde::Deserializable<Program::BinaryIntOp::Xor>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Xor obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Shl &lhs, const BinaryIntOp::Shl &rhs) {
         return true;
@@ -1892,21 +1911,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Shl>::serialize(const Circuit::BinaryIntOp::Shl &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Shl>::serialize(const Program::BinaryIntOp::Shl &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Shl serde::Deserializable<Circuit::BinaryIntOp::Shl>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Shl obj;
+Program::BinaryIntOp::Shl serde::Deserializable<Program::BinaryIntOp::Shl>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Shl obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BinaryIntOp::Shr &lhs, const BinaryIntOp::Shr &rhs) {
         return true;
@@ -1927,21 +1946,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BinaryIntOp::Shr>::serialize(const Circuit::BinaryIntOp::Shr &obj, Serializer &serializer) {
+void serde::Serializable<Program::BinaryIntOp::Shr>::serialize(const Program::BinaryIntOp::Shr &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BinaryIntOp::Shr serde::Deserializable<Circuit::BinaryIntOp::Shr>::deserialize(Deserializer &deserializer) {
-    Circuit::BinaryIntOp::Shr obj;
+Program::BinaryIntOp::Shr serde::Deserializable<Program::BinaryIntOp::Shr>::deserialize(Deserializer &deserializer) {
+    Program::BinaryIntOp::Shr obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall &lhs, const BlackBoxFuncCall &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -1963,11 +1982,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall>::serialize(const Circuit::BlackBoxFuncCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall>::serialize(const Program::BlackBoxFuncCall &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -1975,15 +1994,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall>::serialize(const Circuit::Bl
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall serde::Deserializable<Circuit::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
+Program::BlackBoxFuncCall serde::Deserializable<Program::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BlackBoxFuncCall obj;
+    Program::BlackBoxFuncCall obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::AND &lhs, const BlackBoxFuncCall::AND &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2007,11 +2026,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::AND>::serialize(const Circuit::BlackBoxFuncCall::AND &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::AND>::serialize(const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2019,15 +2038,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::AND>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::AND serde::Deserializable<Circuit::BlackBoxFuncCall::AND>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::AND obj;
+Program::BlackBoxFuncCall::AND serde::Deserializable<Program::BlackBoxFuncCall::AND>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::AND obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::XOR &lhs, const BlackBoxFuncCall::XOR &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2051,11 +2070,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::XOR>::serialize(const Circuit::BlackBoxFuncCall::XOR &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::XOR>::serialize(const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2063,15 +2082,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::XOR>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::XOR serde::Deserializable<Circuit::BlackBoxFuncCall::XOR>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::XOR obj;
+Program::BlackBoxFuncCall::XOR serde::Deserializable<Program::BlackBoxFuncCall::XOR>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::XOR obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, const BlackBoxFuncCall::RANGE &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -2093,23 +2112,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::RANGE>::serialize(const Circuit::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::RANGE>::serialize(const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::RANGE serde::Deserializable<Circuit::BlackBoxFuncCall::RANGE>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::RANGE obj;
+Program::BlackBoxFuncCall::RANGE serde::Deserializable<Program::BlackBoxFuncCall::RANGE>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::RANGE obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::SHA256 &lhs, const BlackBoxFuncCall::SHA256 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2132,25 +2151,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::SHA256>::serialize(const Circuit::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::SHA256>::serialize(const Program::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::SHA256 serde::Deserializable<Circuit::BlackBoxFuncCall::SHA256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::SHA256 obj;
+Program::BlackBoxFuncCall::SHA256 serde::Deserializable<Program::BlackBoxFuncCall::SHA256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::SHA256 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, const BlackBoxFuncCall::Blake2s &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2173,25 +2192,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Blake2s>::serialize(const Circuit::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Blake2s>::serialize(const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Blake2s serde::Deserializable<Circuit::BlackBoxFuncCall::Blake2s>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Blake2s obj;
+Program::BlackBoxFuncCall::Blake2s serde::Deserializable<Program::BlackBoxFuncCall::Blake2s>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Blake2s obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, const BlackBoxFuncCall::Blake3 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2214,25 +2233,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Blake3>::serialize(const Circuit::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Blake3>::serialize(const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Blake3 serde::Deserializable<Circuit::BlackBoxFuncCall::Blake3>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Blake3 obj;
+Program::BlackBoxFuncCall::Blake3 serde::Deserializable<Program::BlackBoxFuncCall::Blake3>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Blake3 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, const BlackBoxFuncCall::SchnorrVerify &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -2258,11 +2277,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::SchnorrVerify>::serialize(const Circuit::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::SchnorrVerify>::serialize(const Program::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
@@ -2272,8 +2291,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::SchnorrVerify>::serialize(co
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Circuit::BlackBoxFuncCall::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::SchnorrVerify obj;
+Program::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Program::BlackBoxFuncCall::SchnorrVerify>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::SchnorrVerify obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
@@ -2282,7 +2301,7 @@ Circuit::BlackBoxFuncCall::SchnorrVerify serde::Deserializable<Circuit::BlackBox
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, const BlackBoxFuncCall::PedersenCommitment &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2306,11 +2325,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::serialize(const Circuit::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::PedersenCommitment>::serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -2318,15 +2337,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::seriali
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::PedersenCommitment serde::Deserializable<Circuit::BlackBoxFuncCall::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::PedersenCommitment obj;
+Program::BlackBoxFuncCall::PedersenCommitment serde::Deserializable<Program::BlackBoxFuncCall::PedersenCommitment>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::PedersenCommitment obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, const BlackBoxFuncCall::PedersenHash &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2350,11 +2369,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenHash>::serialize(const Circuit::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::PedersenHash>::serialize(const Program::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2362,15 +2381,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::PedersenHash>::serialize(con
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::PedersenHash serde::Deserializable<Circuit::BlackBoxFuncCall::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::PedersenHash obj;
+Program::BlackBoxFuncCall::PedersenHash serde::Deserializable<Program::BlackBoxFuncCall::PedersenHash>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::PedersenHash obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -2396,11 +2415,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256k1>::serialize(const Circuit::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::EcdsaSecp256k1>::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
@@ -2410,8 +2429,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256k1>::serialize(c
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxFuncCall::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EcdsaSecp256k1 obj;
+Program::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable<Program::BlackBoxFuncCall::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::EcdsaSecp256k1 obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
@@ -2420,7 +2439,7 @@ Circuit::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBo
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256r1 &lhs, const BlackBoxFuncCall::EcdsaSecp256r1 &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -2446,11 +2465,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256r1>::serialize(const Circuit::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::EcdsaSecp256r1>::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.signature)>::serialize(obj.signature, serializer);
@@ -2460,8 +2479,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::EcdsaSecp256r1>::serialize(c
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxFuncCall::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EcdsaSecp256r1 obj;
+Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Program::BlackBoxFuncCall::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::EcdsaSecp256r1 obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.signature = serde::Deserializable<decltype(obj.signature)>::deserialize(deserializer);
@@ -2470,7 +2489,7 @@ Circuit::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBo
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::FixedBaseScalarMul &lhs, const BlackBoxFuncCall::FixedBaseScalarMul &rhs) {
         if (!(lhs.low == rhs.low)) { return false; }
@@ -2494,11 +2513,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::FixedBaseScalarMul>::serialize(const Circuit::BlackBoxFuncCall::FixedBaseScalarMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::FixedBaseScalarMul>::serialize(const Program::BlackBoxFuncCall::FixedBaseScalarMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
     serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -2506,15 +2525,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::FixedBaseScalarMul>::seriali
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::FixedBaseScalarMul serde::Deserializable<Circuit::BlackBoxFuncCall::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::FixedBaseScalarMul obj;
+Program::BlackBoxFuncCall::FixedBaseScalarMul serde::Deserializable<Program::BlackBoxFuncCall::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::FixedBaseScalarMul obj;
     obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
     obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) {
         if (!(lhs.input1_x == rhs.input1_x)) { return false; }
@@ -2540,11 +2559,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize(const Circuit::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
     serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
     serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
@@ -2554,8 +2573,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::EmbeddedCurveAdd>::serialize
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxFuncCall::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::EmbeddedCurveAdd obj;
+Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Program::BlackBoxFuncCall::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::EmbeddedCurveAdd obj;
     obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
     obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
     obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
@@ -2564,7 +2583,7 @@ Circuit::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable<Circuit::Black
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2587,25 +2606,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Keccak256>::serialize(const Circuit::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Keccak256>::serialize(const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Keccak256 serde::Deserializable<Circuit::BlackBoxFuncCall::Keccak256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Keccak256 obj;
+Program::BlackBoxFuncCall::Keccak256 serde::Deserializable<Program::BlackBoxFuncCall::Keccak256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Keccak256 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccak256VariableLength &lhs, const BlackBoxFuncCall::Keccak256VariableLength &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2629,11 +2648,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Keccak256VariableLength>::serialize(const Circuit::BlackBoxFuncCall::Keccak256VariableLength &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Keccak256VariableLength>::serialize(const Program::BlackBoxFuncCall::Keccak256VariableLength &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.var_message_size)>::serialize(obj.var_message_size, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -2641,15 +2660,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::Keccak256VariableLength>::se
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Keccak256VariableLength serde::Deserializable<Circuit::BlackBoxFuncCall::Keccak256VariableLength>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Keccak256VariableLength obj;
+Program::BlackBoxFuncCall::Keccak256VariableLength serde::Deserializable<Program::BlackBoxFuncCall::Keccak256VariableLength>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Keccak256VariableLength obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.var_message_size = serde::Deserializable<decltype(obj.var_message_size)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, const BlackBoxFuncCall::Keccakf1600 &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2672,25 +2691,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Keccakf1600>::serialize(const Circuit::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Keccakf1600>::serialize(const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Keccakf1600 serde::Deserializable<Circuit::BlackBoxFuncCall::Keccakf1600>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Keccakf1600 obj;
+Program::BlackBoxFuncCall::Keccakf1600 serde::Deserializable<Program::BlackBoxFuncCall::Keccakf1600>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Keccakf1600 obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, const BlackBoxFuncCall::RecursiveAggregation &rhs) {
         if (!(lhs.verification_key == rhs.verification_key)) { return false; }
@@ -2715,11 +2734,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::RecursiveAggregation>::serialize(const Circuit::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::RecursiveAggregation>::serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.verification_key)>::serialize(obj.verification_key, serializer);
     serde::Serializable<decltype(obj.proof)>::serialize(obj.proof, serializer);
     serde::Serializable<decltype(obj.public_inputs)>::serialize(obj.public_inputs, serializer);
@@ -2728,8 +2747,8 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::RecursiveAggregation>::seria
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Circuit::BlackBoxFuncCall::RecursiveAggregation>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::RecursiveAggregation obj;
+Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Program::BlackBoxFuncCall::RecursiveAggregation>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::RecursiveAggregation obj;
     obj.verification_key = serde::Deserializable<decltype(obj.verification_key)>::deserialize(deserializer);
     obj.proof = serde::Deserializable<decltype(obj.proof)>::deserialize(deserializer);
     obj.public_inputs = serde::Deserializable<decltype(obj.public_inputs)>::deserialize(deserializer);
@@ -2737,7 +2756,7 @@ Circuit::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Circuit::B
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, const BlackBoxFuncCall::BigIntAdd &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2761,11 +2780,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntAdd>::serialize(const Circuit::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntAdd>::serialize(const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2773,15 +2792,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntAdd>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntAdd obj;
+Program::BlackBoxFuncCall::BigIntAdd serde::Deserializable<Program::BlackBoxFuncCall::BigIntAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntAdd obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, const BlackBoxFuncCall::BigIntSub &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2805,11 +2824,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntSub>::serialize(const Circuit::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntSub>::serialize(const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2817,15 +2836,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntSub>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntSub serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntSub>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntSub obj;
+Program::BlackBoxFuncCall::BigIntSub serde::Deserializable<Program::BlackBoxFuncCall::BigIntSub>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, const BlackBoxFuncCall::BigIntMul &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2849,11 +2868,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntMul>::serialize(const Circuit::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntMul>::serialize(const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2861,15 +2880,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntMul>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntMul serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntMul obj;
+Program::BlackBoxFuncCall::BigIntMul serde::Deserializable<Program::BlackBoxFuncCall::BigIntMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntMul obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, const BlackBoxFuncCall::BigIntDiv &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -2893,11 +2912,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntDiv>::serialize(const Circuit::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntDiv>::serialize(const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2905,15 +2924,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntDiv>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntDiv serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntDiv obj;
+Program::BlackBoxFuncCall::BigIntDiv serde::Deserializable<Program::BlackBoxFuncCall::BigIntDiv>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntDiv obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, const BlackBoxFuncCall::BigIntFromLeBytes &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -2937,11 +2956,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::serialize(const Circuit::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntFromLeBytes>::serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.modulus)>::serialize(obj.modulus, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -2949,15 +2968,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::serializ
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntFromLeBytes obj;
+Program::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable<Program::BlackBoxFuncCall::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntFromLeBytes obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.modulus = serde::Deserializable<decltype(obj.modulus)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, const BlackBoxFuncCall::BigIntToLeBytes &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -2980,25 +2999,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::BigIntToLeBytes>::serialize(const Circuit::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::BigIntToLeBytes>::serialize(const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable<Circuit::BlackBoxFuncCall::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::BigIntToLeBytes obj;
+Program::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable<Program::BlackBoxFuncCall::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::BigIntToLeBytes obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, const BlackBoxFuncCall::Poseidon2Permutation &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3022,11 +3041,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::serialize(const Circuit::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Poseidon2Permutation>::serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
     serde::Serializable<decltype(obj.len)>::serialize(obj.len, serializer);
@@ -3034,15 +3053,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::seria
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable<Circuit::BlackBoxFuncCall::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Poseidon2Permutation obj;
+Program::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable<Program::BlackBoxFuncCall::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Poseidon2Permutation obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     obj.len = serde::Deserializable<decltype(obj.len)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, const BlackBoxFuncCall::Sha256Compression &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3066,11 +3085,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxFuncCall::Sha256Compression>::serialize(const Circuit::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxFuncCall::Sha256Compression>::serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.hash_values)>::serialize(obj.hash_values, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -3078,15 +3097,15 @@ void serde::Serializable<Circuit::BlackBoxFuncCall::Sha256Compression>::serializ
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxFuncCall::Sha256Compression serde::Deserializable<Circuit::BlackBoxFuncCall::Sha256Compression>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxFuncCall::Sha256Compression obj;
+Program::BlackBoxFuncCall::Sha256Compression serde::Deserializable<Program::BlackBoxFuncCall::Sha256Compression>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxFuncCall::Sha256Compression obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.hash_values = serde::Deserializable<decltype(obj.hash_values)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -3108,11 +3127,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp>::serialize(const Circuit::BlackBoxOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp>::serialize(const Program::BlackBoxOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -3120,15 +3139,15 @@ void serde::Serializable<Circuit::BlackBoxOp>::serialize(const Circuit::BlackBox
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp serde::Deserializable<Circuit::BlackBoxOp>::deserialize(Deserializer &deserializer) {
+Program::BlackBoxOp serde::Deserializable<Program::BlackBoxOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BlackBoxOp obj;
+    Program::BlackBoxOp obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3151,25 +3170,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Sha256>::serialize(const Circuit::BlackBoxOp::Sha256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Sha256>::serialize(const Program::BlackBoxOp::Sha256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Sha256 serde::Deserializable<Circuit::BlackBoxOp::Sha256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Sha256 obj;
+Program::BlackBoxOp::Sha256 serde::Deserializable<Program::BlackBoxOp::Sha256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Sha256 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Blake2s &lhs, const BlackBoxOp::Blake2s &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3192,25 +3211,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Blake2s>::serialize(const Circuit::BlackBoxOp::Blake2s &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Blake2s>::serialize(const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Blake2s serde::Deserializable<Circuit::BlackBoxOp::Blake2s>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Blake2s obj;
+Program::BlackBoxOp::Blake2s serde::Deserializable<Program::BlackBoxOp::Blake2s>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Blake2s obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3233,25 +3252,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Blake3>::serialize(const Circuit::BlackBoxOp::Blake3 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Blake3>::serialize(const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Blake3 serde::Deserializable<Circuit::BlackBoxOp::Blake3>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Blake3 obj;
+Program::BlackBoxOp::Blake3 serde::Deserializable<Program::BlackBoxOp::Blake3>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Blake3 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3274,25 +3293,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Keccak256>::serialize(const Circuit::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Keccak256>::serialize(const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Keccak256 serde::Deserializable<Circuit::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Keccak256 obj;
+Program::BlackBoxOp::Keccak256 serde::Deserializable<Program::BlackBoxOp::Keccak256>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Keccak256 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3315,25 +3334,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Keccakf1600>::serialize(const Circuit::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Keccakf1600>::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Keccakf1600 serde::Deserializable<Circuit::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Keccakf1600 obj;
+Program::BlackBoxOp::Keccakf1600 serde::Deserializable<Program::BlackBoxOp::Keccakf1600>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Keccakf1600 obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) {
         if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
@@ -3359,11 +3378,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256k1>::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
@@ -3373,8 +3392,8 @@ void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EcdsaSecp256k1 obj;
+Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256k1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EcdsaSecp256k1 obj;
     obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
@@ -3383,7 +3402,7 @@ Circuit::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable<Circuit::BlackBoxOp::E
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) {
         if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; }
@@ -3409,11 +3428,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::serialize(const Circuit::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::EcdsaSecp256r1>::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.hashed_msg)>::serialize(obj.hashed_msg, serializer);
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
@@ -3423,8 +3442,8 @@ void serde::Serializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EcdsaSecp256r1 obj;
+Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Program::BlackBoxOp::EcdsaSecp256r1>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EcdsaSecp256r1 obj;
     obj.hashed_msg = serde::Deserializable<decltype(obj.hashed_msg)>::deserialize(deserializer);
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
@@ -3433,7 +3452,7 @@ Circuit::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable<Circuit::BlackBoxOp::E
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) {
         if (!(lhs.public_key_x == rhs.public_key_x)) { return false; }
@@ -3459,11 +3478,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::SchnorrVerify>::serialize(const Circuit::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::SchnorrVerify>::serialize(const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.public_key_x)>::serialize(obj.public_key_x, serializer);
     serde::Serializable<decltype(obj.public_key_y)>::serialize(obj.public_key_y, serializer);
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
@@ -3473,8 +3492,8 @@ void serde::Serializable<Circuit::BlackBoxOp::SchnorrVerify>::serialize(const Ci
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::SchnorrVerify obj;
+Program::BlackBoxOp::SchnorrVerify serde::Deserializable<Program::BlackBoxOp::SchnorrVerify>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::SchnorrVerify obj;
     obj.public_key_x = serde::Deserializable<decltype(obj.public_key_x)>::deserialize(deserializer);
     obj.public_key_y = serde::Deserializable<decltype(obj.public_key_y)>::deserialize(deserializer);
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
@@ -3483,7 +3502,7 @@ Circuit::BlackBoxOp::SchnorrVerify serde::Deserializable<Circuit::BlackBoxOp::Sc
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3507,11 +3526,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(const Circuit::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::PedersenCommitment>::serialize(const Program::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3519,15 +3538,15 @@ void serde::Serializable<Circuit::BlackBoxOp::PedersenCommitment>::serialize(con
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::PedersenCommitment serde::Deserializable<Circuit::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::PedersenCommitment obj;
+Program::BlackBoxOp::PedersenCommitment serde::Deserializable<Program::BlackBoxOp::PedersenCommitment>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::PedersenCommitment obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3551,11 +3570,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Circuit::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::PedersenHash>::serialize(const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.domain_separator)>::serialize(obj.domain_separator, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3563,15 +3582,15 @@ void serde::Serializable<Circuit::BlackBoxOp::PedersenHash>::serialize(const Cir
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::PedersenHash serde::Deserializable<Circuit::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::PedersenHash obj;
+Program::BlackBoxOp::PedersenHash serde::Deserializable<Program::BlackBoxOp::PedersenHash>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::PedersenHash obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.domain_separator = serde::Deserializable<decltype(obj.domain_separator)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, const BlackBoxOp::FixedBaseScalarMul &rhs) {
         if (!(lhs.low == rhs.low)) { return false; }
@@ -3595,11 +3614,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::serialize(const Circuit::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::FixedBaseScalarMul>::serialize(const Program::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.low)>::serialize(obj.low, serializer);
     serde::Serializable<decltype(obj.high)>::serialize(obj.high, serializer);
     serde::Serializable<decltype(obj.result)>::serialize(obj.result, serializer);
@@ -3607,15 +3626,15 @@ void serde::Serializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::serialize(con
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Circuit::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::FixedBaseScalarMul obj;
+Program::BlackBoxOp::FixedBaseScalarMul serde::Deserializable<Program::BlackBoxOp::FixedBaseScalarMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::FixedBaseScalarMul obj;
     obj.low = serde::Deserializable<decltype(obj.low)>::deserialize(deserializer);
     obj.high = serde::Deserializable<decltype(obj.high)>::deserialize(deserializer);
     obj.result = serde::Deserializable<decltype(obj.result)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) {
         if (!(lhs.input1_x == rhs.input1_x)) { return false; }
@@ -3641,11 +3660,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Circuit::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::EmbeddedCurveAdd>::serialize(const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input1_x)>::serialize(obj.input1_x, serializer);
     serde::Serializable<decltype(obj.input1_y)>::serialize(obj.input1_y, serializer);
     serde::Serializable<decltype(obj.input2_x)>::serialize(obj.input2_x, serializer);
@@ -3655,8 +3674,8 @@ void serde::Serializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxOp::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::EmbeddedCurveAdd obj;
+Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Program::BlackBoxOp::EmbeddedCurveAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::EmbeddedCurveAdd obj;
     obj.input1_x = serde::Deserializable<decltype(obj.input1_x)>::deserialize(deserializer);
     obj.input1_y = serde::Deserializable<decltype(obj.input1_y)>::deserialize(deserializer);
     obj.input2_x = serde::Deserializable<decltype(obj.input2_x)>::deserialize(deserializer);
@@ -3665,7 +3684,7 @@ Circuit::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable<Circuit::BlackBoxOp:
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, const BlackBoxOp::BigIntAdd &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3689,11 +3708,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntAdd>::serialize(const Circuit::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntAdd>::serialize(const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3701,15 +3720,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntAdd>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntAdd serde::Deserializable<Circuit::BlackBoxOp::BigIntAdd>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntAdd obj;
+Program::BlackBoxOp::BigIntAdd serde::Deserializable<Program::BlackBoxOp::BigIntAdd>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntAdd obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntSub &lhs, const BlackBoxOp::BigIntSub &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3733,11 +3752,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntSub>::serialize(const Circuit::BlackBoxOp::BigIntSub &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntSub>::serialize(const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3745,15 +3764,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntSub>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntSub serde::Deserializable<Circuit::BlackBoxOp::BigIntSub>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntSub obj;
+Program::BlackBoxOp::BigIntSub serde::Deserializable<Program::BlackBoxOp::BigIntSub>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntSub obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntMul &lhs, const BlackBoxOp::BigIntMul &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3777,11 +3796,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntMul>::serialize(const Circuit::BlackBoxOp::BigIntMul &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntMul>::serialize(const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3789,15 +3808,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntMul>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntMul serde::Deserializable<Circuit::BlackBoxOp::BigIntMul>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntMul obj;
+Program::BlackBoxOp::BigIntMul serde::Deserializable<Program::BlackBoxOp::BigIntMul>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntMul obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, const BlackBoxOp::BigIntDiv &rhs) {
         if (!(lhs.lhs == rhs.lhs)) { return false; }
@@ -3821,11 +3840,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntDiv>::serialize(const Circuit::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntDiv>::serialize(const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
     serde::Serializable<decltype(obj.rhs)>::serialize(obj.rhs, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3833,15 +3852,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntDiv>::serialize(const Circui
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntDiv serde::Deserializable<Circuit::BlackBoxOp::BigIntDiv>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntDiv obj;
+Program::BlackBoxOp::BigIntDiv serde::Deserializable<Program::BlackBoxOp::BigIntDiv>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntDiv obj;
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
     obj.rhs = serde::Deserializable<decltype(obj.rhs)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, const BlackBoxOp::BigIntFromLeBytes &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -3865,11 +3884,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::serialize(const Circuit::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntFromLeBytes>::serialize(const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.modulus)>::serialize(obj.modulus, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -3877,15 +3896,15 @@ void serde::Serializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::serialize(cons
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntFromLeBytes serde::Deserializable<Circuit::BlackBoxOp::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntFromLeBytes obj;
+Program::BlackBoxOp::BigIntFromLeBytes serde::Deserializable<Program::BlackBoxOp::BigIntFromLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntFromLeBytes obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.modulus = serde::Deserializable<decltype(obj.modulus)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, const BlackBoxOp::BigIntToLeBytes &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -3908,25 +3927,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::BigIntToLeBytes>::serialize(const Circuit::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::BigIntToLeBytes>::serialize(const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::BigIntToLeBytes serde::Deserializable<Circuit::BlackBoxOp::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::BigIntToLeBytes obj;
+Program::BlackBoxOp::BigIntToLeBytes serde::Deserializable<Program::BlackBoxOp::BigIntToLeBytes>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::BigIntToLeBytes obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, const BlackBoxOp::Poseidon2Permutation &rhs) {
         if (!(lhs.message == rhs.message)) { return false; }
@@ -3950,11 +3969,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Poseidon2Permutation>::serialize(const Circuit::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Poseidon2Permutation>::serialize(const Program::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.message)>::serialize(obj.message, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
     serde::Serializable<decltype(obj.len)>::serialize(obj.len, serializer);
@@ -3962,15 +3981,15 @@ void serde::Serializable<Circuit::BlackBoxOp::Poseidon2Permutation>::serialize(c
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Poseidon2Permutation serde::Deserializable<Circuit::BlackBoxOp::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Poseidon2Permutation obj;
+Program::BlackBoxOp::Poseidon2Permutation serde::Deserializable<Program::BlackBoxOp::Poseidon2Permutation>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Poseidon2Permutation obj;
     obj.message = serde::Deserializable<decltype(obj.message)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     obj.len = serde::Deserializable<decltype(obj.len)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, const BlackBoxOp::Sha256Compression &rhs) {
         if (!(lhs.input == rhs.input)) { return false; }
@@ -3994,11 +4013,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlackBoxOp::Sha256Compression>::serialize(const Circuit::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlackBoxOp::Sha256Compression>::serialize(const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.hash_values)>::serialize(obj.hash_values, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
@@ -4006,15 +4025,15 @@ void serde::Serializable<Circuit::BlackBoxOp::Sha256Compression>::serialize(cons
 
 template <>
 template <typename Deserializer>
-Circuit::BlackBoxOp::Sha256Compression serde::Deserializable<Circuit::BlackBoxOp::Sha256Compression>::deserialize(Deserializer &deserializer) {
-    Circuit::BlackBoxOp::Sha256Compression obj;
+Program::BlackBoxOp::Sha256Compression serde::Deserializable<Program::BlackBoxOp::Sha256Compression>::deserialize(Deserializer &deserializer) {
+    Program::BlackBoxOp::Sha256Compression obj;
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.hash_values = serde::Deserializable<decltype(obj.hash_values)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BlockId &lhs, const BlockId &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4036,11 +4055,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BlockId>::serialize(const Circuit::BlockId &obj, Serializer &serializer) {
+void serde::Serializable<Program::BlockId>::serialize(const Program::BlockId &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -4048,15 +4067,15 @@ void serde::Serializable<Circuit::BlockId>::serialize(const Circuit::BlockId &ob
 
 template <>
 template <typename Deserializer>
-Circuit::BlockId serde::Deserializable<Circuit::BlockId>::deserialize(Deserializer &deserializer) {
+Program::BlockId serde::Deserializable<Program::BlockId>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BlockId obj;
+    Program::BlockId obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Brillig &lhs, const Brillig &rhs) {
         if (!(lhs.inputs == rhs.inputs)) { return false; }
@@ -4081,11 +4100,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Brillig>::serialize(const Circuit::Brillig &obj, Serializer &serializer) {
+void serde::Serializable<Program::Brillig>::serialize(const Program::Brillig &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -4096,9 +4115,9 @@ void serde::Serializable<Circuit::Brillig>::serialize(const Circuit::Brillig &ob
 
 template <>
 template <typename Deserializer>
-Circuit::Brillig serde::Deserializable<Circuit::Brillig>::deserialize(Deserializer &deserializer) {
+Program::Brillig serde::Deserializable<Program::Brillig>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Brillig obj;
+    Program::Brillig obj;
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     obj.bytecode = serde::Deserializable<decltype(obj.bytecode)>::deserialize(deserializer);
@@ -4107,7 +4126,7 @@ Circuit::Brillig serde::Deserializable<Circuit::Brillig>::deserialize(Deserializ
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4129,11 +4148,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs>::serialize(const Circuit::BrilligInputs &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs>::serialize(const Program::BrilligInputs &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -4141,15 +4160,15 @@ void serde::Serializable<Circuit::BrilligInputs>::serialize(const Circuit::Brill
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs serde::Deserializable<Circuit::BrilligInputs>::deserialize(Deserializer &deserializer) {
+Program::BrilligInputs serde::Deserializable<Program::BrilligInputs>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BrilligInputs obj;
+    Program::BrilligInputs obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs::Single &lhs, const BrilligInputs::Single &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4171,23 +4190,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs::Single>::serialize(const Circuit::BrilligInputs::Single &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs::Single>::serialize(const Program::BrilligInputs::Single &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs::Single serde::Deserializable<Circuit::BrilligInputs::Single>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligInputs::Single obj;
+Program::BrilligInputs::Single serde::Deserializable<Program::BrilligInputs::Single>::deserialize(Deserializer &deserializer) {
+    Program::BrilligInputs::Single obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs::Array &lhs, const BrilligInputs::Array &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4209,23 +4228,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs::Array>::serialize(const Circuit::BrilligInputs::Array &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs::Array>::serialize(const Program::BrilligInputs::Array &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs::Array serde::Deserializable<Circuit::BrilligInputs::Array>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligInputs::Array obj;
+Program::BrilligInputs::Array serde::Deserializable<Program::BrilligInputs::Array>::deserialize(Deserializer &deserializer) {
+    Program::BrilligInputs::Array obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligInputs::MemoryArray &lhs, const BrilligInputs::MemoryArray &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4247,23 +4266,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligInputs::MemoryArray>::serialize(const Circuit::BrilligInputs::MemoryArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligInputs::MemoryArray>::serialize(const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligInputs::MemoryArray serde::Deserializable<Circuit::BrilligInputs::MemoryArray>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligInputs::MemoryArray obj;
+Program::BrilligInputs::MemoryArray serde::Deserializable<Program::BrilligInputs::MemoryArray>::deserialize(Deserializer &deserializer) {
+    Program::BrilligInputs::MemoryArray obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4285,11 +4304,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode>::serialize(const Circuit::BrilligOpcode &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode>::serialize(const Program::BrilligOpcode &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -4297,15 +4316,15 @@ void serde::Serializable<Circuit::BrilligOpcode>::serialize(const Circuit::Brill
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode serde::Deserializable<Circuit::BrilligOpcode>::deserialize(Deserializer &deserializer) {
+Program::BrilligOpcode serde::Deserializable<Program::BrilligOpcode>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BrilligOpcode obj;
+    Program::BrilligOpcode obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, const BrilligOpcode::BinaryFieldOp &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4330,11 +4349,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::BinaryFieldOp>::serialize(const Circuit::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::BinaryFieldOp>::serialize(const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
     serde::Serializable<decltype(obj.lhs)>::serialize(obj.lhs, serializer);
@@ -4343,8 +4362,8 @@ void serde::Serializable<Circuit::BrilligOpcode::BinaryFieldOp>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::BinaryFieldOp serde::Deserializable<Circuit::BrilligOpcode::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::BinaryFieldOp obj;
+Program::BrilligOpcode::BinaryFieldOp serde::Deserializable<Program::BrilligOpcode::BinaryFieldOp>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::BinaryFieldOp obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
     obj.lhs = serde::Deserializable<decltype(obj.lhs)>::deserialize(deserializer);
@@ -4352,7 +4371,7 @@ Circuit::BrilligOpcode::BinaryFieldOp serde::Deserializable<Circuit::BrilligOpco
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::BinaryIntOp &lhs, const BrilligOpcode::BinaryIntOp &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4378,11 +4397,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::BinaryIntOp>::serialize(const Circuit::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::BinaryIntOp>::serialize(const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
     serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
@@ -4392,8 +4411,8 @@ void serde::Serializable<Circuit::BrilligOpcode::BinaryIntOp>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::BinaryIntOp serde::Deserializable<Circuit::BrilligOpcode::BinaryIntOp>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::BinaryIntOp obj;
+Program::BrilligOpcode::BinaryIntOp serde::Deserializable<Program::BrilligOpcode::BinaryIntOp>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::BinaryIntOp obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
     obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
@@ -4402,7 +4421,7 @@ Circuit::BrilligOpcode::BinaryIntOp serde::Deserializable<Circuit::BrilligOpcode
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Cast &lhs, const BrilligOpcode::Cast &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4426,11 +4445,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Cast>::serialize(const Circuit::BrilligOpcode::Cast &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Cast>::serialize(const Program::BrilligOpcode::Cast &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.source)>::serialize(obj.source, serializer);
     serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
@@ -4438,15 +4457,15 @@ void serde::Serializable<Circuit::BrilligOpcode::Cast>::serialize(const Circuit:
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Cast serde::Deserializable<Circuit::BrilligOpcode::Cast>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Cast obj;
+Program::BrilligOpcode::Cast serde::Deserializable<Program::BrilligOpcode::Cast>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Cast obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.source = serde::Deserializable<decltype(obj.source)>::deserialize(deserializer);
     obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, const BrilligOpcode::JumpIfNot &rhs) {
         if (!(lhs.condition == rhs.condition)) { return false; }
@@ -4469,25 +4488,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::JumpIfNot>::serialize(const Circuit::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::JumpIfNot>::serialize(const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.condition)>::serialize(obj.condition, serializer);
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::JumpIfNot serde::Deserializable<Circuit::BrilligOpcode::JumpIfNot>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::JumpIfNot obj;
+Program::BrilligOpcode::JumpIfNot serde::Deserializable<Program::BrilligOpcode::JumpIfNot>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::JumpIfNot obj;
     obj.condition = serde::Deserializable<decltype(obj.condition)>::deserialize(deserializer);
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::JumpIf &lhs, const BrilligOpcode::JumpIf &rhs) {
         if (!(lhs.condition == rhs.condition)) { return false; }
@@ -4510,25 +4529,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::JumpIf>::serialize(const Circuit::BrilligOpcode::JumpIf &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::JumpIf>::serialize(const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.condition)>::serialize(obj.condition, serializer);
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::JumpIf serde::Deserializable<Circuit::BrilligOpcode::JumpIf>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::JumpIf obj;
+Program::BrilligOpcode::JumpIf serde::Deserializable<Program::BrilligOpcode::JumpIf>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::JumpIf obj;
     obj.condition = serde::Deserializable<decltype(obj.condition)>::deserialize(deserializer);
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Jump &lhs, const BrilligOpcode::Jump &rhs) {
         if (!(lhs.location == rhs.location)) { return false; }
@@ -4550,23 +4569,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Jump>::serialize(const Circuit::BrilligOpcode::Jump &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Jump>::serialize(const Program::BrilligOpcode::Jump &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Jump serde::Deserializable<Circuit::BrilligOpcode::Jump>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Jump obj;
+Program::BrilligOpcode::Jump serde::Deserializable<Program::BrilligOpcode::Jump>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Jump obj;
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, const BrilligOpcode::CalldataCopy &rhs) {
         if (!(lhs.destination_address == rhs.destination_address)) { return false; }
@@ -4590,11 +4609,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::CalldataCopy>::serialize(const Circuit::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::CalldataCopy>::serialize(const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination_address)>::serialize(obj.destination_address, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
     serde::Serializable<decltype(obj.offset)>::serialize(obj.offset, serializer);
@@ -4602,15 +4621,15 @@ void serde::Serializable<Circuit::BrilligOpcode::CalldataCopy>::serialize(const
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::CalldataCopy serde::Deserializable<Circuit::BrilligOpcode::CalldataCopy>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::CalldataCopy obj;
+Program::BrilligOpcode::CalldataCopy serde::Deserializable<Program::BrilligOpcode::CalldataCopy>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::CalldataCopy obj;
     obj.destination_address = serde::Deserializable<decltype(obj.destination_address)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     obj.offset = serde::Deserializable<decltype(obj.offset)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Call &lhs, const BrilligOpcode::Call &rhs) {
         if (!(lhs.location == rhs.location)) { return false; }
@@ -4632,23 +4651,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Call>::serialize(const Circuit::BrilligOpcode::Call &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Call>::serialize(const Program::BrilligOpcode::Call &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.location)>::serialize(obj.location, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Call serde::Deserializable<Circuit::BrilligOpcode::Call>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Call obj;
+Program::BrilligOpcode::Call serde::Deserializable<Program::BrilligOpcode::Call>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Call obj;
     obj.location = serde::Deserializable<decltype(obj.location)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Const &lhs, const BrilligOpcode::Const &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4672,11 +4691,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Const>::serialize(const Circuit::BrilligOpcode::Const &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Const>::serialize(const Program::BrilligOpcode::Const &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
@@ -4684,15 +4703,15 @@ void serde::Serializable<Circuit::BrilligOpcode::Const>::serialize(const Circuit
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Const serde::Deserializable<Circuit::BrilligOpcode::Const>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Const obj;
+Program::BrilligOpcode::Const serde::Deserializable<Program::BrilligOpcode::Const>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Const obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Return &lhs, const BrilligOpcode::Return &rhs) {
         return true;
@@ -4713,21 +4732,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Return>::serialize(const Circuit::BrilligOpcode::Return &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Return>::serialize(const Program::BrilligOpcode::Return &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Return serde::Deserializable<Circuit::BrilligOpcode::Return>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Return obj;
+Program::BrilligOpcode::Return serde::Deserializable<Program::BrilligOpcode::Return>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Return obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::ForeignCall &lhs, const BrilligOpcode::ForeignCall &rhs) {
         if (!(lhs.function == rhs.function)) { return false; }
@@ -4753,11 +4772,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::ForeignCall>::serialize(const Circuit::BrilligOpcode::ForeignCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::ForeignCall>::serialize(const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.function)>::serialize(obj.function, serializer);
     serde::Serializable<decltype(obj.destinations)>::serialize(obj.destinations, serializer);
     serde::Serializable<decltype(obj.destination_value_types)>::serialize(obj.destination_value_types, serializer);
@@ -4767,8 +4786,8 @@ void serde::Serializable<Circuit::BrilligOpcode::ForeignCall>::serialize(const C
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::ForeignCall serde::Deserializable<Circuit::BrilligOpcode::ForeignCall>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::ForeignCall obj;
+Program::BrilligOpcode::ForeignCall serde::Deserializable<Program::BrilligOpcode::ForeignCall>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::ForeignCall obj;
     obj.function = serde::Deserializable<decltype(obj.function)>::deserialize(deserializer);
     obj.destinations = serde::Deserializable<decltype(obj.destinations)>::deserialize(deserializer);
     obj.destination_value_types = serde::Deserializable<decltype(obj.destination_value_types)>::deserialize(deserializer);
@@ -4777,7 +4796,7 @@ Circuit::BrilligOpcode::ForeignCall serde::Deserializable<Circuit::BrilligOpcode
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Mov &lhs, const BrilligOpcode::Mov &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4800,25 +4819,72 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Mov>::serialize(const Circuit::BrilligOpcode::Mov &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Mov>::serialize(const Program::BrilligOpcode::Mov &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.source)>::serialize(obj.source, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Mov serde::Deserializable<Circuit::BrilligOpcode::Mov>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Mov obj;
+Program::BrilligOpcode::Mov serde::Deserializable<Program::BrilligOpcode::Mov>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Mov obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.source = serde::Deserializable<decltype(obj.source)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
+
+    inline bool operator==(const BrilligOpcode::ConditionalMov &lhs, const BrilligOpcode::ConditionalMov &rhs) {
+        if (!(lhs.destination == rhs.destination)) { return false; }
+        if (!(lhs.source_a == rhs.source_a)) { return false; }
+        if (!(lhs.source_b == rhs.source_b)) { return false; }
+        if (!(lhs.condition == rhs.condition)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BrilligOpcode::ConditionalMov::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BrilligOpcode::ConditionalMov>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BrilligOpcode::ConditionalMov BrilligOpcode::ConditionalMov::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BrilligOpcode::ConditionalMov>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BrilligOpcode::ConditionalMov>::serialize(const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
+    serde::Serializable<decltype(obj.source_a)>::serialize(obj.source_a, serializer);
+    serde::Serializable<decltype(obj.source_b)>::serialize(obj.source_b, serializer);
+    serde::Serializable<decltype(obj.condition)>::serialize(obj.condition, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::BrilligOpcode::ConditionalMov serde::Deserializable<Program::BrilligOpcode::ConditionalMov>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::ConditionalMov obj;
+    obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
+    obj.source_a = serde::Deserializable<decltype(obj.source_a)>::deserialize(deserializer);
+    obj.source_b = serde::Deserializable<decltype(obj.source_b)>::deserialize(deserializer);
+    obj.condition = serde::Deserializable<decltype(obj.condition)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Load &lhs, const BrilligOpcode::Load &rhs) {
         if (!(lhs.destination == rhs.destination)) { return false; }
@@ -4841,25 +4907,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Load>::serialize(const Circuit::BrilligOpcode::Load &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Load>::serialize(const Program::BrilligOpcode::Load &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination)>::serialize(obj.destination, serializer);
     serde::Serializable<decltype(obj.source_pointer)>::serialize(obj.source_pointer, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Load serde::Deserializable<Circuit::BrilligOpcode::Load>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Load obj;
+Program::BrilligOpcode::Load serde::Deserializable<Program::BrilligOpcode::Load>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Load obj;
     obj.destination = serde::Deserializable<decltype(obj.destination)>::deserialize(deserializer);
     obj.source_pointer = serde::Deserializable<decltype(obj.source_pointer)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Store &lhs, const BrilligOpcode::Store &rhs) {
         if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; }
@@ -4882,25 +4948,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Store>::serialize(const Circuit::BrilligOpcode::Store &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Store>::serialize(const Program::BrilligOpcode::Store &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.destination_pointer)>::serialize(obj.destination_pointer, serializer);
     serde::Serializable<decltype(obj.source)>::serialize(obj.source, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Store serde::Deserializable<Circuit::BrilligOpcode::Store>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Store obj;
+Program::BrilligOpcode::Store serde::Deserializable<Program::BrilligOpcode::Store>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Store obj;
     obj.destination_pointer = serde::Deserializable<decltype(obj.destination_pointer)>::deserialize(deserializer);
     obj.source = serde::Deserializable<decltype(obj.source)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::BlackBox &lhs, const BrilligOpcode::BlackBox &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -4922,23 +4988,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::BlackBox>::serialize(const Circuit::BrilligOpcode::BlackBox &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::BlackBox>::serialize(const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::BlackBox serde::Deserializable<Circuit::BrilligOpcode::BlackBox>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::BlackBox obj;
+Program::BrilligOpcode::BlackBox serde::Deserializable<Program::BrilligOpcode::BlackBox>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::BlackBox obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) {
         return true;
@@ -4959,21 +5025,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Trap>::serialize(const Circuit::BrilligOpcode::Trap &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Trap>::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Trap serde::Deserializable<Circuit::BrilligOpcode::Trap>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Trap obj;
+Program::BrilligOpcode::Trap serde::Deserializable<Program::BrilligOpcode::Trap>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Trap obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOpcode::Stop &lhs, const BrilligOpcode::Stop &rhs) {
         if (!(lhs.return_data_offset == rhs.return_data_offset)) { return false; }
@@ -4996,25 +5062,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOpcode::Stop>::serialize(const Circuit::BrilligOpcode::Stop &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOpcode::Stop>::serialize(const Program::BrilligOpcode::Stop &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.return_data_offset)>::serialize(obj.return_data_offset, serializer);
     serde::Serializable<decltype(obj.return_data_size)>::serialize(obj.return_data_size, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOpcode::Stop serde::Deserializable<Circuit::BrilligOpcode::Stop>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOpcode::Stop obj;
+Program::BrilligOpcode::Stop serde::Deserializable<Program::BrilligOpcode::Stop>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::Stop obj;
     obj.return_data_offset = serde::Deserializable<decltype(obj.return_data_offset)>::deserialize(deserializer);
     obj.return_data_size = serde::Deserializable<decltype(obj.return_data_size)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5036,11 +5102,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOutputs>::serialize(const Circuit::BrilligOutputs &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOutputs>::serialize(const Program::BrilligOutputs &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5048,15 +5114,15 @@ void serde::Serializable<Circuit::BrilligOutputs>::serialize(const Circuit::Bril
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOutputs serde::Deserializable<Circuit::BrilligOutputs>::deserialize(Deserializer &deserializer) {
+Program::BrilligOutputs serde::Deserializable<Program::BrilligOutputs>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::BrilligOutputs obj;
+    Program::BrilligOutputs obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOutputs::Simple &lhs, const BrilligOutputs::Simple &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5078,23 +5144,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOutputs::Simple>::serialize(const Circuit::BrilligOutputs::Simple &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOutputs::Simple>::serialize(const Program::BrilligOutputs::Simple &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOutputs::Simple serde::Deserializable<Circuit::BrilligOutputs::Simple>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOutputs::Simple obj;
+Program::BrilligOutputs::Simple serde::Deserializable<Program::BrilligOutputs::Simple>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOutputs::Simple obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const BrilligOutputs::Array &lhs, const BrilligOutputs::Array &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5116,23 +5182,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::BrilligOutputs::Array>::serialize(const Circuit::BrilligOutputs::Array &obj, Serializer &serializer) {
+void serde::Serializable<Program::BrilligOutputs::Array>::serialize(const Program::BrilligOutputs::Array &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::BrilligOutputs::Array serde::Deserializable<Circuit::BrilligOutputs::Array>::deserialize(Deserializer &deserializer) {
-    Circuit::BrilligOutputs::Array obj;
+Program::BrilligOutputs::Array serde::Deserializable<Program::BrilligOutputs::Array>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOutputs::Array obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Circuit &lhs, const Circuit &rhs) {
         if (!(lhs.current_witness_index == rhs.current_witness_index)) { return false; }
@@ -5161,11 +5227,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit &obj, Serializer &serializer) {
+void serde::Serializable<Program::Circuit>::serialize(const Program::Circuit &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.current_witness_index)>::serialize(obj.current_witness_index, serializer);
     serde::Serializable<decltype(obj.opcodes)>::serialize(obj.opcodes, serializer);
@@ -5180,9 +5246,9 @@ void serde::Serializable<Circuit::Circuit>::serialize(const Circuit::Circuit &ob
 
 template <>
 template <typename Deserializer>
-Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializer &deserializer) {
+Program::Circuit serde::Deserializable<Program::Circuit>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Circuit obj;
+    Program::Circuit obj;
     obj.current_witness_index = serde::Deserializable<decltype(obj.current_witness_index)>::deserialize(deserializer);
     obj.opcodes = serde::Deserializable<decltype(obj.opcodes)>::deserialize(deserializer);
     obj.expression_width = serde::Deserializable<decltype(obj.expression_width)>::deserialize(deserializer);
@@ -5195,7 +5261,7 @@ Circuit::Circuit serde::Deserializable<Circuit::Circuit>::deserialize(Deserializ
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Directive &lhs, const Directive &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5217,11 +5283,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Directive>::serialize(const Circuit::Directive &obj, Serializer &serializer) {
+void serde::Serializable<Program::Directive>::serialize(const Program::Directive &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5229,15 +5295,15 @@ void serde::Serializable<Circuit::Directive>::serialize(const Circuit::Directive
 
 template <>
 template <typename Deserializer>
-Circuit::Directive serde::Deserializable<Circuit::Directive>::deserialize(Deserializer &deserializer) {
+Program::Directive serde::Deserializable<Program::Directive>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Directive obj;
+    Program::Directive obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Directive::ToLeRadix &lhs, const Directive::ToLeRadix &rhs) {
         if (!(lhs.a == rhs.a)) { return false; }
@@ -5261,11 +5327,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Directive::ToLeRadix>::serialize(const Circuit::Directive::ToLeRadix &obj, Serializer &serializer) {
+void serde::Serializable<Program::Directive::ToLeRadix>::serialize(const Program::Directive::ToLeRadix &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.a)>::serialize(obj.a, serializer);
     serde::Serializable<decltype(obj.b)>::serialize(obj.b, serializer);
     serde::Serializable<decltype(obj.radix)>::serialize(obj.radix, serializer);
@@ -5273,15 +5339,15 @@ void serde::Serializable<Circuit::Directive::ToLeRadix>::serialize(const Circuit
 
 template <>
 template <typename Deserializer>
-Circuit::Directive::ToLeRadix serde::Deserializable<Circuit::Directive::ToLeRadix>::deserialize(Deserializer &deserializer) {
-    Circuit::Directive::ToLeRadix obj;
+Program::Directive::ToLeRadix serde::Deserializable<Program::Directive::ToLeRadix>::deserialize(Deserializer &deserializer) {
+    Program::Directive::ToLeRadix obj;
     obj.a = serde::Deserializable<decltype(obj.a)>::deserialize(deserializer);
     obj.b = serde::Deserializable<decltype(obj.b)>::deserialize(deserializer);
     obj.radix = serde::Deserializable<decltype(obj.radix)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Expression &lhs, const Expression &rhs) {
         if (!(lhs.mul_terms == rhs.mul_terms)) { return false; }
@@ -5305,11 +5371,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Expression>::serialize(const Circuit::Expression &obj, Serializer &serializer) {
+void serde::Serializable<Program::Expression>::serialize(const Program::Expression &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.mul_terms)>::serialize(obj.mul_terms, serializer);
     serde::Serializable<decltype(obj.linear_combinations)>::serialize(obj.linear_combinations, serializer);
@@ -5319,9 +5385,9 @@ void serde::Serializable<Circuit::Expression>::serialize(const Circuit::Expressi
 
 template <>
 template <typename Deserializer>
-Circuit::Expression serde::Deserializable<Circuit::Expression>::deserialize(Deserializer &deserializer) {
+Program::Expression serde::Deserializable<Program::Expression>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Expression obj;
+    Program::Expression obj;
     obj.mul_terms = serde::Deserializable<decltype(obj.mul_terms)>::deserialize(deserializer);
     obj.linear_combinations = serde::Deserializable<decltype(obj.linear_combinations)>::deserialize(deserializer);
     obj.q_c = serde::Deserializable<decltype(obj.q_c)>::deserialize(deserializer);
@@ -5329,7 +5395,7 @@ Circuit::Expression serde::Deserializable<Circuit::Expression>::deserialize(Dese
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5351,11 +5417,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ExpressionWidth>::serialize(const Circuit::ExpressionWidth &obj, Serializer &serializer) {
+void serde::Serializable<Program::ExpressionWidth>::serialize(const Program::ExpressionWidth &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5363,15 +5429,15 @@ void serde::Serializable<Circuit::ExpressionWidth>::serialize(const Circuit::Exp
 
 template <>
 template <typename Deserializer>
-Circuit::ExpressionWidth serde::Deserializable<Circuit::ExpressionWidth>::deserialize(Deserializer &deserializer) {
+Program::ExpressionWidth serde::Deserializable<Program::ExpressionWidth>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::ExpressionWidth obj;
+    Program::ExpressionWidth obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ExpressionWidth::Unbounded &lhs, const ExpressionWidth::Unbounded &rhs) {
         return true;
@@ -5392,21 +5458,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ExpressionWidth::Unbounded>::serialize(const Circuit::ExpressionWidth::Unbounded &obj, Serializer &serializer) {
+void serde::Serializable<Program::ExpressionWidth::Unbounded>::serialize(const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ExpressionWidth::Unbounded serde::Deserializable<Circuit::ExpressionWidth::Unbounded>::deserialize(Deserializer &deserializer) {
-    Circuit::ExpressionWidth::Unbounded obj;
+Program::ExpressionWidth::Unbounded serde::Deserializable<Program::ExpressionWidth::Unbounded>::deserialize(Deserializer &deserializer) {
+    Program::ExpressionWidth::Unbounded obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ExpressionWidth::Bounded &lhs, const ExpressionWidth::Bounded &rhs) {
         if (!(lhs.width == rhs.width)) { return false; }
@@ -5428,23 +5494,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ExpressionWidth::Bounded>::serialize(const Circuit::ExpressionWidth::Bounded &obj, Serializer &serializer) {
+void serde::Serializable<Program::ExpressionWidth::Bounded>::serialize(const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.width)>::serialize(obj.width, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ExpressionWidth::Bounded serde::Deserializable<Circuit::ExpressionWidth::Bounded>::deserialize(Deserializer &deserializer) {
-    Circuit::ExpressionWidth::Bounded obj;
+Program::ExpressionWidth::Bounded serde::Deserializable<Program::ExpressionWidth::Bounded>::deserialize(Deserializer &deserializer) {
+    Program::ExpressionWidth::Bounded obj;
     obj.width = serde::Deserializable<decltype(obj.width)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) {
         if (!(lhs.witness == rhs.witness)) { return false; }
@@ -5467,11 +5533,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::FunctionInput>::serialize(const Circuit::FunctionInput &obj, Serializer &serializer) {
+void serde::Serializable<Program::FunctionInput>::serialize(const Program::FunctionInput &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.witness)>::serialize(obj.witness, serializer);
     serde::Serializable<decltype(obj.num_bits)>::serialize(obj.num_bits, serializer);
@@ -5480,16 +5546,16 @@ void serde::Serializable<Circuit::FunctionInput>::serialize(const Circuit::Funct
 
 template <>
 template <typename Deserializer>
-Circuit::FunctionInput serde::Deserializable<Circuit::FunctionInput>::deserialize(Deserializer &deserializer) {
+Program::FunctionInput serde::Deserializable<Program::FunctionInput>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::FunctionInput obj;
+    Program::FunctionInput obj;
     obj.witness = serde::Deserializable<decltype(obj.witness)>::deserialize(deserializer);
     obj.num_bits = serde::Deserializable<decltype(obj.num_bits)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) {
         if (!(lhs.pointer == rhs.pointer)) { return false; }
@@ -5512,11 +5578,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapArray>::serialize(const Circuit::HeapArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapArray>::serialize(const Program::HeapArray &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.pointer)>::serialize(obj.pointer, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
@@ -5525,16 +5591,16 @@ void serde::Serializable<Circuit::HeapArray>::serialize(const Circuit::HeapArray
 
 template <>
 template <typename Deserializer>
-Circuit::HeapArray serde::Deserializable<Circuit::HeapArray>::deserialize(Deserializer &deserializer) {
+Program::HeapArray serde::Deserializable<Program::HeapArray>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::HeapArray obj;
+    Program::HeapArray obj;
     obj.pointer = serde::Deserializable<decltype(obj.pointer)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5556,11 +5622,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType>::serialize(const Circuit::HeapValueType &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType>::serialize(const Program::HeapValueType &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5568,15 +5634,15 @@ void serde::Serializable<Circuit::HeapValueType>::serialize(const Circuit::HeapV
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType serde::Deserializable<Circuit::HeapValueType>::deserialize(Deserializer &deserializer) {
+Program::HeapValueType serde::Deserializable<Program::HeapValueType>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::HeapValueType obj;
+    Program::HeapValueType obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType::Simple &lhs, const HeapValueType::Simple &rhs) {
         return true;
@@ -5597,21 +5663,21 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType::Simple>::serialize(const Circuit::HeapValueType::Simple &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType::Simple>::serialize(const Program::HeapValueType::Simple &obj, Serializer &serializer) {
 }
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType::Simple serde::Deserializable<Circuit::HeapValueType::Simple>::deserialize(Deserializer &deserializer) {
-    Circuit::HeapValueType::Simple obj;
+Program::HeapValueType::Simple serde::Deserializable<Program::HeapValueType::Simple>::deserialize(Deserializer &deserializer) {
+    Program::HeapValueType::Simple obj;
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType::Array &lhs, const HeapValueType::Array &rhs) {
         if (!(lhs.value_types == rhs.value_types)) { return false; }
@@ -5634,25 +5700,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType::Array>::serialize(const Circuit::HeapValueType::Array &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType::Array>::serialize(const Program::HeapValueType::Array &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value_types)>::serialize(obj.value_types, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType::Array serde::Deserializable<Circuit::HeapValueType::Array>::deserialize(Deserializer &deserializer) {
-    Circuit::HeapValueType::Array obj;
+Program::HeapValueType::Array serde::Deserializable<Program::HeapValueType::Array>::deserialize(Deserializer &deserializer) {
+    Program::HeapValueType::Array obj;
     obj.value_types = serde::Deserializable<decltype(obj.value_types)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapValueType::Vector &lhs, const HeapValueType::Vector &rhs) {
         if (!(lhs.value_types == rhs.value_types)) { return false; }
@@ -5674,23 +5740,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapValueType::Vector>::serialize(const Circuit::HeapValueType::Vector &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapValueType::Vector>::serialize(const Program::HeapValueType::Vector &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value_types)>::serialize(obj.value_types, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::HeapValueType::Vector serde::Deserializable<Circuit::HeapValueType::Vector>::deserialize(Deserializer &deserializer) {
-    Circuit::HeapValueType::Vector obj;
+Program::HeapValueType::Vector serde::Deserializable<Program::HeapValueType::Vector>::deserialize(Deserializer &deserializer) {
+    Program::HeapValueType::Vector obj;
     obj.value_types = serde::Deserializable<decltype(obj.value_types)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) {
         if (!(lhs.pointer == rhs.pointer)) { return false; }
@@ -5713,11 +5779,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::HeapVector>::serialize(const Circuit::HeapVector &obj, Serializer &serializer) {
+void serde::Serializable<Program::HeapVector>::serialize(const Program::HeapVector &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.pointer)>::serialize(obj.pointer, serializer);
     serde::Serializable<decltype(obj.size)>::serialize(obj.size, serializer);
@@ -5726,16 +5792,16 @@ void serde::Serializable<Circuit::HeapVector>::serialize(const Circuit::HeapVect
 
 template <>
 template <typename Deserializer>
-Circuit::HeapVector serde::Deserializable<Circuit::HeapVector>::deserialize(Deserializer &deserializer) {
+Program::HeapVector serde::Deserializable<Program::HeapVector>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::HeapVector obj;
+    Program::HeapVector obj;
     obj.pointer = serde::Deserializable<decltype(obj.pointer)>::deserialize(deserializer);
     obj.size = serde::Deserializable<decltype(obj.size)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const MemOp &lhs, const MemOp &rhs) {
         if (!(lhs.operation == rhs.operation)) { return false; }
@@ -5759,11 +5825,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::MemOp>::serialize(const Circuit::MemOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::MemOp>::serialize(const Program::MemOp &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.operation)>::serialize(obj.operation, serializer);
     serde::Serializable<decltype(obj.index)>::serialize(obj.index, serializer);
@@ -5773,9 +5839,9 @@ void serde::Serializable<Circuit::MemOp>::serialize(const Circuit::MemOp &obj, S
 
 template <>
 template <typename Deserializer>
-Circuit::MemOp serde::Deserializable<Circuit::MemOp>::deserialize(Deserializer &deserializer) {
+Program::MemOp serde::Deserializable<Program::MemOp>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::MemOp obj;
+    Program::MemOp obj;
     obj.operation = serde::Deserializable<decltype(obj.operation)>::deserialize(deserializer);
     obj.index = serde::Deserializable<decltype(obj.index)>::deserialize(deserializer);
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
@@ -5783,7 +5849,7 @@ Circuit::MemOp serde::Deserializable<Circuit::MemOp>::deserialize(Deserializer &
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5805,11 +5871,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::MemoryAddress>::serialize(const Circuit::MemoryAddress &obj, Serializer &serializer) {
+void serde::Serializable<Program::MemoryAddress>::serialize(const Program::MemoryAddress &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5817,15 +5883,15 @@ void serde::Serializable<Circuit::MemoryAddress>::serialize(const Circuit::Memor
 
 template <>
 template <typename Deserializer>
-Circuit::MemoryAddress serde::Deserializable<Circuit::MemoryAddress>::deserialize(Deserializer &deserializer) {
+Program::MemoryAddress serde::Deserializable<Program::MemoryAddress>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::MemoryAddress obj;
+    Program::MemoryAddress obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode &lhs, const Opcode &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5847,11 +5913,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode>::serialize(const Circuit::Opcode &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode>::serialize(const Program::Opcode &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -5859,15 +5925,15 @@ void serde::Serializable<Circuit::Opcode>::serialize(const Circuit::Opcode &obj,
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode serde::Deserializable<Circuit::Opcode>::deserialize(Deserializer &deserializer) {
+Program::Opcode serde::Deserializable<Program::Opcode>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Opcode obj;
+    Program::Opcode obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5889,23 +5955,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::AssertZero>::serialize(const Circuit::Opcode::AssertZero &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::AssertZero>::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::AssertZero serde::Deserializable<Circuit::Opcode::AssertZero>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::AssertZero obj;
+Program::Opcode::AssertZero serde::Deserializable<Program::Opcode::AssertZero>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::AssertZero obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5927,23 +5993,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::BlackBoxFuncCall>::serialize(const Circuit::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::BlackBoxFuncCall>::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::BlackBoxFuncCall serde::Deserializable<Circuit::Opcode::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::BlackBoxFuncCall obj;
+Program::Opcode::BlackBoxFuncCall serde::Deserializable<Program::Opcode::BlackBoxFuncCall>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::BlackBoxFuncCall obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::Directive &lhs, const Opcode::Directive &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -5965,23 +6031,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Directive>::serialize(const Circuit::Opcode::Directive &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::Directive>::serialize(const Program::Opcode::Directive &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Directive serde::Deserializable<Circuit::Opcode::Directive>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::Directive obj;
+Program::Opcode::Directive serde::Deserializable<Program::Opcode::Directive>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::Directive obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::Brillig &lhs, const Opcode::Brillig &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6003,23 +6069,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Brillig>::serialize(const Circuit::Opcode::Brillig &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::Brillig>::serialize(const Program::Opcode::Brillig &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Brillig serde::Deserializable<Circuit::Opcode::Brillig>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::Brillig obj;
+Program::Opcode::Brillig serde::Deserializable<Program::Opcode::Brillig>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::Brillig obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::MemoryOp &lhs, const Opcode::MemoryOp &rhs) {
         if (!(lhs.block_id == rhs.block_id)) { return false; }
@@ -6043,11 +6109,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::MemoryOp>::serialize(const Circuit::Opcode::MemoryOp &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::MemoryOp>::serialize(const Program::Opcode::MemoryOp &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.op)>::serialize(obj.op, serializer);
     serde::Serializable<decltype(obj.predicate)>::serialize(obj.predicate, serializer);
@@ -6055,15 +6121,15 @@ void serde::Serializable<Circuit::Opcode::MemoryOp>::serialize(const Circuit::Op
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::MemoryOp serde::Deserializable<Circuit::Opcode::MemoryOp>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::MemoryOp obj;
+Program::Opcode::MemoryOp serde::Deserializable<Program::Opcode::MemoryOp>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::MemoryOp obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.op = serde::Deserializable<decltype(obj.op)>::deserialize(deserializer);
     obj.predicate = serde::Deserializable<decltype(obj.predicate)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) {
         if (!(lhs.block_id == rhs.block_id)) { return false; }
@@ -6086,25 +6152,25 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::MemoryInit>::serialize(const Circuit::Opcode::MemoryInit &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::MemoryInit>::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.block_id)>::serialize(obj.block_id, serializer);
     serde::Serializable<decltype(obj.init)>::serialize(obj.init, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::MemoryInit serde::Deserializable<Circuit::Opcode::MemoryInit>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::MemoryInit obj;
+Program::Opcode::MemoryInit serde::Deserializable<Program::Opcode::MemoryInit>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::MemoryInit obj;
     obj.block_id = serde::Deserializable<decltype(obj.block_id)>::deserialize(deserializer);
     obj.init = serde::Deserializable<decltype(obj.init)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) {
         if (!(lhs.id == rhs.id)) { return false; }
@@ -6128,11 +6194,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Opcode::Call>::serialize(const Circuit::Opcode::Call &obj, Serializer &serializer) {
+void serde::Serializable<Program::Opcode::Call>::serialize(const Program::Opcode::Call &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.id)>::serialize(obj.id, serializer);
     serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
     serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
@@ -6140,15 +6206,15 @@ void serde::Serializable<Circuit::Opcode::Call>::serialize(const Circuit::Opcode
 
 template <>
 template <typename Deserializer>
-Circuit::Opcode::Call serde::Deserializable<Circuit::Opcode::Call>::deserialize(Deserializer &deserializer) {
-    Circuit::Opcode::Call obj;
+Program::Opcode::Call serde::Deserializable<Program::Opcode::Call>::deserialize(Deserializer &deserializer) {
+    Program::Opcode::Call obj;
     obj.id = serde::Deserializable<decltype(obj.id)>::deserialize(deserializer);
     obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
     obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6170,11 +6236,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::OpcodeLocation>::serialize(const Circuit::OpcodeLocation &obj, Serializer &serializer) {
+void serde::Serializable<Program::OpcodeLocation>::serialize(const Program::OpcodeLocation &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6182,15 +6248,15 @@ void serde::Serializable<Circuit::OpcodeLocation>::serialize(const Circuit::Opco
 
 template <>
 template <typename Deserializer>
-Circuit::OpcodeLocation serde::Deserializable<Circuit::OpcodeLocation>::deserialize(Deserializer &deserializer) {
+Program::OpcodeLocation serde::Deserializable<Program::OpcodeLocation>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::OpcodeLocation obj;
+    Program::OpcodeLocation obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const OpcodeLocation::Acir &lhs, const OpcodeLocation::Acir &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6212,23 +6278,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::OpcodeLocation::Acir>::serialize(const Circuit::OpcodeLocation::Acir &obj, Serializer &serializer) {
+void serde::Serializable<Program::OpcodeLocation::Acir>::serialize(const Program::OpcodeLocation::Acir &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::OpcodeLocation::Acir serde::Deserializable<Circuit::OpcodeLocation::Acir>::deserialize(Deserializer &deserializer) {
-    Circuit::OpcodeLocation::Acir obj;
+Program::OpcodeLocation::Acir serde::Deserializable<Program::OpcodeLocation::Acir>::deserialize(Deserializer &deserializer) {
+    Program::OpcodeLocation::Acir obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const OpcodeLocation::Brillig &lhs, const OpcodeLocation::Brillig &rhs) {
         if (!(lhs.acir_index == rhs.acir_index)) { return false; }
@@ -6251,25 +6317,67 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::OpcodeLocation::Brillig>::serialize(const Circuit::OpcodeLocation::Brillig &obj, Serializer &serializer) {
+void serde::Serializable<Program::OpcodeLocation::Brillig>::serialize(const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.acir_index)>::serialize(obj.acir_index, serializer);
     serde::Serializable<decltype(obj.brillig_index)>::serialize(obj.brillig_index, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::OpcodeLocation::Brillig serde::Deserializable<Circuit::OpcodeLocation::Brillig>::deserialize(Deserializer &deserializer) {
-    Circuit::OpcodeLocation::Brillig obj;
+Program::OpcodeLocation::Brillig serde::Deserializable<Program::OpcodeLocation::Brillig>::deserialize(Deserializer &deserializer) {
+    Program::OpcodeLocation::Brillig obj;
     obj.acir_index = serde::Deserializable<decltype(obj.acir_index)>::deserialize(deserializer);
     obj.brillig_index = serde::Deserializable<decltype(obj.brillig_index)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
+
+    inline bool operator==(const Program &lhs, const Program &rhs) {
+        if (!(lhs.functions == rhs.functions)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> Program::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<Program>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline Program Program::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<Program>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::Program>::serialize(const Program::Program &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.functions)>::serialize(obj.functions, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::Program serde::Deserializable<Program::Program>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::Program obj;
+    obj.functions = serde::Deserializable<decltype(obj.functions)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
 
     inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6291,11 +6399,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::PublicInputs>::serialize(const Circuit::PublicInputs &obj, Serializer &serializer) {
+void serde::Serializable<Program::PublicInputs>::serialize(const Program::PublicInputs &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6303,15 +6411,15 @@ void serde::Serializable<Circuit::PublicInputs>::serialize(const Circuit::Public
 
 template <>
 template <typename Deserializer>
-Circuit::PublicInputs serde::Deserializable<Circuit::PublicInputs>::deserialize(Deserializer &deserializer) {
+Program::PublicInputs serde::Deserializable<Program::PublicInputs>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::PublicInputs obj;
+    Program::PublicInputs obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Value &lhs, const Value &rhs) {
         if (!(lhs.inner == rhs.inner)) { return false; }
@@ -6333,11 +6441,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Value>::serialize(const Circuit::Value &obj, Serializer &serializer) {
+void serde::Serializable<Program::Value>::serialize(const Program::Value &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.inner)>::serialize(obj.inner, serializer);
     serializer.decrease_container_depth();
@@ -6345,15 +6453,15 @@ void serde::Serializable<Circuit::Value>::serialize(const Circuit::Value &obj, S
 
 template <>
 template <typename Deserializer>
-Circuit::Value serde::Deserializable<Circuit::Value>::deserialize(Deserializer &deserializer) {
+Program::Value serde::Deserializable<Program::Value>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Value obj;
+    Program::Value obj;
     obj.inner = serde::Deserializable<decltype(obj.inner)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6375,11 +6483,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray>::serialize(const Circuit::ValueOrArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray>::serialize(const Program::ValueOrArray &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6387,15 +6495,15 @@ void serde::Serializable<Circuit::ValueOrArray>::serialize(const Circuit::ValueO
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray serde::Deserializable<Circuit::ValueOrArray>::deserialize(Deserializer &deserializer) {
+Program::ValueOrArray serde::Deserializable<Program::ValueOrArray>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::ValueOrArray obj;
+    Program::ValueOrArray obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray::MemoryAddress &lhs, const ValueOrArray::MemoryAddress &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6417,23 +6525,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray::MemoryAddress>::serialize(const Circuit::ValueOrArray::MemoryAddress &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray::MemoryAddress>::serialize(const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray::MemoryAddress serde::Deserializable<Circuit::ValueOrArray::MemoryAddress>::deserialize(Deserializer &deserializer) {
-    Circuit::ValueOrArray::MemoryAddress obj;
+Program::ValueOrArray::MemoryAddress serde::Deserializable<Program::ValueOrArray::MemoryAddress>::deserialize(Deserializer &deserializer) {
+    Program::ValueOrArray::MemoryAddress obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray::HeapArray &lhs, const ValueOrArray::HeapArray &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6455,23 +6563,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray::HeapArray>::serialize(const Circuit::ValueOrArray::HeapArray &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray::HeapArray>::serialize(const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray::HeapArray serde::Deserializable<Circuit::ValueOrArray::HeapArray>::deserialize(Deserializer &deserializer) {
-    Circuit::ValueOrArray::HeapArray obj;
+Program::ValueOrArray::HeapArray serde::Deserializable<Program::ValueOrArray::HeapArray>::deserialize(Deserializer &deserializer) {
+    Program::ValueOrArray::HeapArray obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const ValueOrArray::HeapVector &lhs, const ValueOrArray::HeapVector &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6493,23 +6601,23 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::ValueOrArray::HeapVector>::serialize(const Circuit::ValueOrArray::HeapVector &obj, Serializer &serializer) {
+void serde::Serializable<Program::ValueOrArray::HeapVector>::serialize(const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) {
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
 }
 
 template <>
 template <typename Deserializer>
-Circuit::ValueOrArray::HeapVector serde::Deserializable<Circuit::ValueOrArray::HeapVector>::deserialize(Deserializer &deserializer) {
-    Circuit::ValueOrArray::HeapVector obj;
+Program::ValueOrArray::HeapVector serde::Deserializable<Program::ValueOrArray::HeapVector>::deserialize(Deserializer &deserializer) {
+    Program::ValueOrArray::HeapVector obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     return obj;
 }
 
-namespace Circuit {
+namespace Program {
 
     inline bool operator==(const Witness &lhs, const Witness &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -6531,11 +6639,11 @@ namespace Circuit {
         return value;
     }
 
-} // end of namespace Circuit
+} // end of namespace Program
 
 template <>
 template <typename Serializer>
-void serde::Serializable<Circuit::Witness>::serialize(const Circuit::Witness &obj, Serializer &serializer) {
+void serde::Serializable<Program::Witness>::serialize(const Program::Witness &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -6543,9 +6651,9 @@ void serde::Serializable<Circuit::Witness>::serialize(const Circuit::Witness &ob
 
 template <>
 template <typename Deserializer>
-Circuit::Witness serde::Deserializable<Circuit::Witness>::deserialize(Deserializer &deserializer) {
+Program::Witness serde::Deserializable<Program::Witness>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    Circuit::Witness obj;
+    Program::Witness obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
diff --git a/acvm-repo/acir/codegen/witness.cpp b/acvm-repo/acir/codegen/witness.cpp
index 118d4ca7ac5..ad2b0550db2 100644
--- a/acvm-repo/acir/codegen/witness.cpp
+++ b/acvm-repo/acir/codegen/witness.cpp
@@ -3,7 +3,7 @@
 #include "serde.hpp"
 #include "bincode.hpp"
 
-namespace WitnessMap {
+namespace WitnessStack {
 
     struct Witness {
         uint32_t value;
@@ -14,17 +14,79 @@ namespace WitnessMap {
     };
 
     struct WitnessMap {
-        std::map<WitnessMap::Witness, std::string> value;
+        std::map<WitnessStack::Witness, std::string> value;
 
         friend bool operator==(const WitnessMap&, const WitnessMap&);
         std::vector<uint8_t> bincodeSerialize() const;
         static WitnessMap bincodeDeserialize(std::vector<uint8_t>);
     };
 
-} // end of namespace WitnessMap
+    struct StackItem {
+        uint32_t index;
+        WitnessStack::WitnessMap witness;
 
+        friend bool operator==(const StackItem&, const StackItem&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static StackItem bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+    struct WitnessStack {
+        std::vector<WitnessStack::StackItem> stack;
+
+        friend bool operator==(const WitnessStack&, const WitnessStack&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static WitnessStack bincodeDeserialize(std::vector<uint8_t>);
+    };
+
+} // end of namespace WitnessStack
+
+
+namespace WitnessStack {
+
+    inline bool operator==(const StackItem &lhs, const StackItem &rhs) {
+        if (!(lhs.index == rhs.index)) { return false; }
+        if (!(lhs.witness == rhs.witness)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> StackItem::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<StackItem>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline StackItem StackItem::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<StackItem>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace WitnessStack
+
+template <>
+template <typename Serializer>
+void serde::Serializable<WitnessStack::StackItem>::serialize(const WitnessStack::StackItem &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.index)>::serialize(obj.index, serializer);
+    serde::Serializable<decltype(obj.witness)>::serialize(obj.witness, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+WitnessStack::StackItem serde::Deserializable<WitnessStack::StackItem>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    WitnessStack::StackItem obj;
+    obj.index = serde::Deserializable<decltype(obj.index)>::deserialize(deserializer);
+    obj.witness = serde::Deserializable<decltype(obj.witness)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
 
-namespace WitnessMap {
+namespace WitnessStack {
 
     inline bool operator==(const Witness &lhs, const Witness &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -46,11 +108,11 @@ namespace WitnessMap {
         return value;
     }
 
-} // end of namespace WitnessMap
+} // end of namespace WitnessStack
 
 template <>
 template <typename Serializer>
-void serde::Serializable<WitnessMap::Witness>::serialize(const WitnessMap::Witness &obj, Serializer &serializer) {
+void serde::Serializable<WitnessStack::Witness>::serialize(const WitnessStack::Witness &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -58,15 +120,15 @@ void serde::Serializable<WitnessMap::Witness>::serialize(const WitnessMap::Witne
 
 template <>
 template <typename Deserializer>
-WitnessMap::Witness serde::Deserializable<WitnessMap::Witness>::deserialize(Deserializer &deserializer) {
+WitnessStack::Witness serde::Deserializable<WitnessStack::Witness>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    WitnessMap::Witness obj;
+    WitnessStack::Witness obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
 
-namespace WitnessMap {
+namespace WitnessStack {
 
     inline bool operator==(const WitnessMap &lhs, const WitnessMap &rhs) {
         if (!(lhs.value == rhs.value)) { return false; }
@@ -88,11 +150,11 @@ namespace WitnessMap {
         return value;
     }
 
-} // end of namespace WitnessMap
+} // end of namespace WitnessStack
 
 template <>
 template <typename Serializer>
-void serde::Serializable<WitnessMap::WitnessMap>::serialize(const WitnessMap::WitnessMap &obj, Serializer &serializer) {
+void serde::Serializable<WitnessStack::WitnessMap>::serialize(const WitnessStack::WitnessMap &obj, Serializer &serializer) {
     serializer.increase_container_depth();
     serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
     serializer.decrease_container_depth();
@@ -100,10 +162,52 @@ void serde::Serializable<WitnessMap::WitnessMap>::serialize(const WitnessMap::Wi
 
 template <>
 template <typename Deserializer>
-WitnessMap::WitnessMap serde::Deserializable<WitnessMap::WitnessMap>::deserialize(Deserializer &deserializer) {
+WitnessStack::WitnessMap serde::Deserializable<WitnessStack::WitnessMap>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
-    WitnessMap::WitnessMap obj;
+    WitnessStack::WitnessMap obj;
     obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;
 }
+
+namespace WitnessStack {
+
+    inline bool operator==(const WitnessStack &lhs, const WitnessStack &rhs) {
+        if (!(lhs.stack == rhs.stack)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> WitnessStack::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<WitnessStack>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline WitnessStack WitnessStack::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<WitnessStack>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace WitnessStack
+
+template <>
+template <typename Serializer>
+void serde::Serializable<WitnessStack::WitnessStack>::serialize(const WitnessStack::WitnessStack &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.stack)>::serialize(obj.stack, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+WitnessStack::WitnessStack serde::Deserializable<WitnessStack::WitnessStack>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    WitnessStack::WitnessStack obj;
+    obj.stack = serde::Deserializable<decltype(obj.stack)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
diff --git a/acvm-repo/acir/src/circuit/mod.rs b/acvm-repo/acir/src/circuit/mod.rs
index 7e6cbf23803..b5d6348d34f 100644
--- a/acvm-repo/acir/src/circuit/mod.rs
+++ b/acvm-repo/acir/src/circuit/mod.rs
@@ -32,6 +32,13 @@ pub enum ExpressionWidth {
     },
 }
 
+/// A program represented by multiple ACIR circuits. The execution trace of these
+/// circuits is dictated by construction of the [crate::native_types::WitnessStack].
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct Program {
+    pub functions: Vec<Circuit>,
+}
+
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct Circuit {
     // current_witness_index is the highest witness index in the circuit. The next witness to be added to this circuit
@@ -152,7 +159,9 @@ impl Circuit {
             self.public_parameters.0.union(&self.return_values.0).cloned().collect();
         PublicInputs(public_inputs)
     }
+}
 
+impl Program {
     fn write<W: std::io::Write>(&self, writer: W) -> std::io::Result<()> {
         let buf = bincode::serialize(self).unwrap();
         let mut encoder = flate2::write::GzEncoder::new(writer, Compression::default());
@@ -169,36 +178,36 @@ impl Circuit {
             .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidInput, err))
     }
 
-    pub fn serialize_circuit(circuit: &Circuit) -> Vec<u8> {
-        let mut circuit_bytes: Vec<u8> = Vec::new();
-        circuit.write(&mut circuit_bytes).expect("expected circuit to be serializable");
-        circuit_bytes
+    pub fn serialize_program(program: &Program) -> Vec<u8> {
+        let mut program_bytes: Vec<u8> = Vec::new();
+        program.write(&mut program_bytes).expect("expected circuit to be serializable");
+        program_bytes
     }
 
-    pub fn deserialize_circuit(serialized_circuit: &[u8]) -> std::io::Result<Self> {
-        Circuit::read(serialized_circuit)
+    pub fn deserialize_program(serialized_circuit: &[u8]) -> std::io::Result<Self> {
+        Program::read(serialized_circuit)
     }
 
-    // Serialize and base64 encode circuit
-    pub fn serialize_circuit_base64<S>(circuit: &Circuit, s: S) -> Result<S::Ok, S::Error>
+    // Serialize and base64 encode program
+    pub fn serialize_program_base64<S>(program: &Program, s: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        let circuit_bytes = Circuit::serialize_circuit(circuit);
-        let encoded_b64 = base64::engine::general_purpose::STANDARD.encode(circuit_bytes);
+        let program_bytes = Program::serialize_program(program);
+        let encoded_b64 = base64::engine::general_purpose::STANDARD.encode(program_bytes);
         s.serialize_str(&encoded_b64)
     }
 
-    // Deserialize and base64 decode circuit
-    pub fn deserialize_circuit_base64<'de, D>(deserializer: D) -> Result<Circuit, D::Error>
+    // Deserialize and base64 decode program
+    pub fn deserialize_program_base64<'de, D>(deserializer: D) -> Result<Program, D::Error>
     where
         D: Deserializer<'de>,
     {
         let bytecode_b64: String = serde::Deserialize::deserialize(deserializer)?;
-        let circuit_bytes = base64::engine::general_purpose::STANDARD
+        let program_bytes = base64::engine::general_purpose::STANDARD
             .decode(bytecode_b64)
             .map_err(D::Error::custom)?;
-        let circuit = Self::deserialize_circuit(&circuit_bytes).map_err(D::Error::custom)?;
+        let circuit = Self::deserialize_program(&program_bytes).map_err(D::Error::custom)?;
         Ok(circuit)
     }
 }
@@ -240,6 +249,22 @@ impl std::fmt::Debug for Circuit {
     }
 }
 
+impl std::fmt::Display for Program {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for (func_index, function) in self.functions.iter().enumerate() {
+            writeln!(f, "func {}", func_index)?;
+            writeln!(f, "{}", function)?;
+        }
+        Ok(())
+    }
+}
+
+impl std::fmt::Debug for Program {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct PublicInputs(pub BTreeSet<Witness>);
 
@@ -262,7 +287,10 @@ mod tests {
         opcodes::{BlackBoxFuncCall, FunctionInput},
         Circuit, Compression, Opcode, PublicInputs,
     };
-    use crate::{circuit::ExpressionWidth, native_types::Witness};
+    use crate::{
+        circuit::{ExpressionWidth, Program},
+        native_types::Witness,
+    };
     use acir_field::FieldElement;
 
     fn and_opcode() -> Opcode {
@@ -348,14 +376,15 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
+        let program = Program { functions: vec![circuit] };
 
-        fn read_write(circuit: Circuit) -> (Circuit, Circuit) {
-            let bytes = Circuit::serialize_circuit(&circuit);
-            let got_circuit = Circuit::deserialize_circuit(&bytes).unwrap();
-            (circuit, got_circuit)
+        fn read_write(program: Program) -> (Program, Program) {
+            let bytes = Program::serialize_program(&program);
+            let got_program = Program::deserialize_program(&bytes).unwrap();
+            (program, got_program)
         }
 
-        let (circ, got_circ) = read_write(circuit);
+        let (circ, got_circ) = read_write(program);
         assert_eq!(circ, got_circ);
     }
 
@@ -380,11 +409,12 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
+        let program = Program { functions: vec![circuit] };
 
-        let json = serde_json::to_string_pretty(&circuit).unwrap();
+        let json = serde_json::to_string_pretty(&program).unwrap();
 
         let deserialized = serde_json::from_str(&json).unwrap();
-        assert_eq!(circuit, deserialized);
+        assert_eq!(program, deserialized);
     }
 
     #[test]
@@ -400,7 +430,7 @@ mod tests {
         encoder.write_all(bad_circuit).unwrap();
         encoder.finish().unwrap();
 
-        let deserialization_result = Circuit::deserialize_circuit(&zipped_bad_circuit);
+        let deserialization_result = Program::deserialize_program(&zipped_bad_circuit);
         assert!(deserialization_result.is_err());
     }
 }
diff --git a/acvm-repo/acir/src/lib.rs b/acvm-repo/acir/src/lib.rs
index c7be5026850..d14159f34a1 100644
--- a/acvm-repo/acir/src/lib.rs
+++ b/acvm-repo/acir/src/lib.rs
@@ -42,9 +42,9 @@ mod reflection {
             brillig::{BrilligInputs, BrilligOutputs},
             directives::Directive,
             opcodes::BlackBoxFuncCall,
-            Circuit, ExpressionWidth, Opcode, OpcodeLocation,
+            Circuit, ExpressionWidth, Opcode, OpcodeLocation, Program,
         },
-        native_types::{Witness, WitnessMap},
+        native_types::{Witness, WitnessMap, WitnessStack},
     };
 
     #[test]
@@ -59,6 +59,7 @@ mod reflection {
         };
 
         let mut tracer = Tracer::new(TracerConfig::default());
+        tracer.trace_simple_type::<Program>().unwrap();
         tracer.trace_simple_type::<Circuit>().unwrap();
         tracer.trace_simple_type::<ExpressionWidth>().unwrap();
         tracer.trace_simple_type::<Opcode>().unwrap();
@@ -78,7 +79,7 @@ mod reflection {
 
         // Create C++ class definitions.
         let mut source = Vec::new();
-        let config = serde_generate::CodeGeneratorConfig::new("Circuit".to_string())
+        let config = serde_generate::CodeGeneratorConfig::new("Program".to_string())
             .with_encodings(vec![serde_generate::Encoding::Bincode]);
         let generator = serde_generate::cpp::CodeGenerator::new(&config);
         generator.output(&mut source, &registry).unwrap();
@@ -106,12 +107,13 @@ mod reflection {
         let mut tracer = Tracer::new(TracerConfig::default());
         tracer.trace_simple_type::<Witness>().unwrap();
         tracer.trace_simple_type::<WitnessMap>().unwrap();
+        tracer.trace_simple_type::<WitnessStack>().unwrap();
 
         let registry = tracer.registry().unwrap();
 
         // Create C++ class definitions.
         let mut source = Vec::new();
-        let config = serde_generate::CodeGeneratorConfig::new("WitnessMap".to_string())
+        let config = serde_generate::CodeGeneratorConfig::new("WitnessStack".to_string())
             .with_encodings(vec![serde_generate::Encoding::Bincode]);
         let generator = serde_generate::cpp::CodeGenerator::new(&config);
         generator.output(&mut source, &registry).unwrap();
diff --git a/acvm-repo/acir/src/native_types/mod.rs b/acvm-repo/acir/src/native_types/mod.rs
index 66c822bfff8..eb9d1f6fd03 100644
--- a/acvm-repo/acir/src/native_types/mod.rs
+++ b/acvm-repo/acir/src/native_types/mod.rs
@@ -1,8 +1,10 @@
 mod expression;
 mod witness;
 mod witness_map;
+mod witness_stack;
 
 pub use expression::Expression;
 pub use witness::Witness;
 pub use witness_map::WitnessMap;
-pub use witness_map::WitnessMapError;
+pub use witness_stack::WitnessStack;
+pub use witness_stack::WitnessStackError;
diff --git a/acvm-repo/acir/src/native_types/witness_stack.rs b/acvm-repo/acir/src/native_types/witness_stack.rs
new file mode 100644
index 00000000000..9592d90b014
--- /dev/null
+++ b/acvm-repo/acir/src/native_types/witness_stack.rs
@@ -0,0 +1,64 @@
+use std::io::Read;
+
+use flate2::bufread::GzDecoder;
+use flate2::bufread::GzEncoder;
+use flate2::Compression;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use super::WitnessMap;
+
+#[derive(Debug, Error)]
+enum SerializationError {
+    #[error(transparent)]
+    Deflate(#[from] std::io::Error),
+}
+
+#[derive(Debug, Error)]
+#[error(transparent)]
+pub struct WitnessStackError(#[from] SerializationError);
+
+/// An ordered set of witness maps for separate circuits
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
+pub struct WitnessStack {
+    pub stack: Vec<StackItem>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Default, Serialize, Deserialize)]
+pub struct StackItem {
+    /// Index into a [crate::circuit::Program] function list for which we have an associated witness
+    pub index: u32,
+    /// A full witness for the respective constraint system specified by the index
+    pub witness: WitnessMap,
+}
+
+impl From<WitnessMap> for WitnessStack {
+    fn from(witness: WitnessMap) -> Self {
+        let stack = vec![StackItem { index: 0, witness }];
+        Self { stack }
+    }
+}
+
+impl TryFrom<WitnessStack> for Vec<u8> {
+    type Error = WitnessStackError;
+
+    fn try_from(val: WitnessStack) -> Result<Self, Self::Error> {
+        let buf = bincode::serialize(&val).unwrap();
+        let mut deflater = GzEncoder::new(buf.as_slice(), Compression::best());
+        let mut buf_c = Vec::new();
+        deflater.read_to_end(&mut buf_c).map_err(|err| WitnessStackError(err.into()))?;
+        Ok(buf_c)
+    }
+}
+
+impl TryFrom<&[u8]> for WitnessStack {
+    type Error = WitnessStackError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
+        let mut deflater = GzDecoder::new(bytes);
+        let mut buf_d = Vec::new();
+        deflater.read_to_end(&mut buf_d).map_err(|err| WitnessStackError(err.into()))?;
+        let witness_stack = bincode::deserialize(&buf_d).unwrap();
+        Ok(witness_stack)
+    }
+}
diff --git a/acvm-repo/acir/tests/test_program_serialization.rs b/acvm-repo/acir/tests/test_program_serialization.rs
index 2c8ad2b9986..64385a37582 100644
--- a/acvm-repo/acir/tests/test_program_serialization.rs
+++ b/acvm-repo/acir/tests/test_program_serialization.rs
@@ -1,13 +1,13 @@
 //! This integration test defines a set of circuits which are used in order to test the acvm_js package.
 //!
-//! The acvm_js test suite contains serialized [circuits][`Circuit`] which must be kept in sync with the format
+//! The acvm_js test suite contains serialized program [circuits][`Program`] which must be kept in sync with the format
 //! outputted from the [ACIR crate][acir].
 //! Breaking changes to the serialization format then require refreshing acvm_js's test suite.
 //! This file contains Rust definitions of these circuits and outputs the updated serialized format.
 //!
 //! These tests also check this circuit serialization against an expected value, erroring if the serialization changes.
 //! Generally in this situation we just need to refresh the `expected_serialization` variables to match the
-//! actual output, **HOWEVER** note that this results in a breaking change to the ACIR format.
+//! actual output, **HOWEVER** note that this results in a breaking change to the backend ACIR format.
 
 use std::collections::BTreeSet;
 
@@ -15,7 +15,7 @@ use acir::{
     circuit::{
         brillig::{Brillig, BrilligInputs, BrilligOutputs},
         opcodes::{BlackBoxFuncCall, BlockId, FunctionInput, MemOp},
-        Circuit, Opcode, PublicInputs,
+        Circuit, Opcode, Program, PublicInputs,
     },
     native_types::{Expression, Witness},
 };
@@ -41,16 +41,17 @@ fn addition_circuit() {
         return_values: PublicInputs([Witness(3)].into()),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 208, 49, 14, 192, 32, 8, 5, 80, 212, 30, 8, 4, 20,
-        182, 94, 165, 166, 122, 255, 35, 52, 77, 28, 76, 58, 214, 191, 124, 166, 23, 242, 15, 0, 8,
-        240, 77, 154, 125, 206, 198, 127, 161, 176, 209, 138, 139, 197, 88, 68, 122, 205, 157, 152,
-        46, 204, 222, 76, 81, 180, 21, 35, 35, 53, 189, 179, 49, 119, 19, 171, 222, 188, 162, 147,
-        112, 167, 161, 206, 99, 98, 105, 223, 95, 248, 26, 113, 90, 97, 185, 97, 217, 56, 173, 35,
-        63, 243, 81, 87, 163, 125, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 75, 14, 128, 32, 12, 68, 249, 120, 160, 150,
+        182, 208, 238, 188, 138, 68, 184, 255, 17, 212, 200, 130, 196, 165, 188, 164, 153, 174, 94,
+        38, 227, 221, 203, 118, 159, 119, 95, 226, 200, 125, 36, 252, 3, 253, 66, 87, 152, 92, 4,
+        153, 185, 149, 212, 144, 240, 128, 100, 85, 5, 88, 106, 86, 84, 20, 149, 51, 41, 81, 83,
+        214, 98, 213, 10, 24, 50, 53, 236, 98, 212, 135, 44, 174, 235, 5, 143, 35, 12, 151, 159,
+        126, 55, 109, 28, 231, 145, 47, 245, 105, 191, 143, 133, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -71,13 +72,14 @@ fn fixed_base_scalar_mul_circuit() {
         return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(3), Witness(4)])),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 91, 10, 0, 32, 16, 2, 109, 171, 175, 46, 221,
-        209, 247, 229, 130, 130, 140, 200, 92, 0, 11, 157, 228, 35, 127, 212, 200, 29, 61, 116, 76,
-        220, 217, 250, 171, 91, 113, 160, 66, 104, 242, 97, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233,
+        29, 61, 43, 3, 5, 121, 34, 207, 86, 231, 162, 198, 157, 124, 228, 71, 157, 220, 232, 161,
+        227, 226, 206, 214, 95, 221, 74, 0, 116, 58, 13, 182, 105, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -98,13 +100,14 @@ fn pedersen_circuit() {
         return_values: PublicInputs(BTreeSet::from_iter(vec![Witness(2), Witness(3)])),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 135, 9, 0, 48, 8, 75, 171, 224, 255, 15, 139,
-        27, 196, 64, 200, 100, 0, 15, 133, 80, 57, 89, 219, 127, 39, 173, 126, 235, 236, 247, 151,
-        48, 224, 71, 90, 33, 97, 0, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 7, 6, 0, 0, 8, 108, 209, 255, 63, 156, 54, 233,
+        56, 55, 17, 26, 18, 196, 241, 169, 250, 178, 141, 167, 32, 159, 254, 234, 238, 255, 87,
+        112, 52, 63, 63, 101, 105, 0, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -139,26 +142,27 @@ fn schnorr_verify_circuit() {
         return_values: PublicInputs(BTreeSet::from([output])),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 74, 3, 1, 20, 69, 209, 177, 247, 222, 123,
-        239, 189, 119, 141, 93, 99, 220, 133, 251, 95, 130, 152, 103, 78, 32, 3, 195, 33, 4, 66,
-        248, 239, 254, 20, 69, 209, 84, 212, 158, 216, 206, 223, 234, 219, 204, 146, 239, 91, 170,
-        111, 103, 245, 109, 101, 27, 219, 217, 193, 250, 219, 197, 110, 246, 176, 151, 125, 236,
-        231, 0, 7, 57, 196, 97, 142, 112, 148, 99, 28, 231, 4, 39, 57, 197, 105, 206, 112, 150,
-        115, 156, 231, 2, 23, 185, 196, 101, 174, 112, 149, 107, 92, 231, 6, 55, 185, 197, 109,
-        238, 112, 151, 123, 220, 231, 1, 15, 121, 196, 99, 158, 240, 148, 103, 60, 231, 5, 47, 121,
-        197, 107, 222, 240, 150, 119, 188, 231, 3, 75, 124, 228, 83, 195, 142, 121, 158, 125, 126,
-        225, 43, 223, 248, 206, 15, 126, 178, 204, 47, 86, 248, 237, 119, 43, 76, 127, 105, 47,
-        189, 165, 181, 116, 150, 198, 234, 125, 117, 249, 47, 233, 41, 45, 165, 163, 52, 148, 126,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 78, 2, 1, 20, 69, 81, 236, 189, 247, 222,
+        123, 239, 93, 177, 33, 34, 238, 194, 253, 47, 193, 200, 147, 67, 194, 36, 147, 163, 33, 33,
+        228, 191, 219, 82, 168, 63, 63, 181, 183, 197, 223, 177, 147, 191, 181, 183, 149, 69, 159,
+        183, 213, 222, 238, 218, 219, 206, 14, 118, 178, 139, 141, 183, 135, 189, 236, 99, 63, 7,
+        56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227,
+        60, 23, 184, 200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187,
+        220, 227, 62, 15, 120, 200, 35, 30, 243, 132, 167, 60, 227, 57, 47, 120, 201, 43, 94, 243,
+        134, 183, 188, 227, 61, 31, 248, 200, 39, 22, 249, 204, 151, 166, 29, 243, 188, 250, 255,
+        141, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 123, 171, 76, 127, 105, 47,
+        189, 165, 181, 116, 150, 198, 26, 125, 245, 248, 45, 233, 41, 45, 165, 163, 52, 148, 126,
         210, 78, 186, 73, 51, 233, 37, 173, 164, 147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33,
-        45, 164, 131, 52, 144, 253, 23, 139, 218, 238, 217, 60, 123, 103, 235, 236, 156, 141, 179,
-        239, 166, 93, 183, 237, 185, 107, 199, 125, 251, 29, 218, 237, 216, 94, 167, 118, 58, 183,
-        207, 165, 93, 174, 237, 113, 107, 135, 123, 247, 47, 185, 251, 147, 59, 191, 184, 239, 155,
-        187, 126, 184, 103, 217, 29, 235, 55, 171, 223, 173, 104, 184, 231, 255, 243, 7, 236, 52,
-        239, 128, 225, 3, 0, 0,
+        45, 164, 131, 52, 144, 253, 151, 11, 245, 221, 179, 121, 246, 206, 214, 217, 57, 27, 103,
+        223, 109, 187, 238, 218, 115, 223, 142, 135, 246, 59, 182, 219, 169, 189, 206, 237, 116,
+        105, 159, 107, 187, 220, 218, 227, 222, 14, 143, 238, 95, 116, 247, 23, 119, 126, 115, 223,
+        146, 187, 150, 221, 179, 226, 142, 141, 155, 53, 238, 86, 104, 186, 231, 255, 243, 7, 100,
+        141, 232, 192, 233, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -202,15 +206,16 @@ fn simple_brillig_foreign_call() {
         private_parameters: BTreeSet::from([Witness(1), Witness(2)]),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 177, 10, 192, 32, 16, 67, 227, 21, 74, 233,
-        212, 79, 177, 127, 208, 159, 233, 224, 226, 32, 226, 247, 139, 168, 16, 68, 93, 244, 45,
-        119, 228, 142, 144, 92, 0, 20, 50, 7, 237, 76, 213, 190, 50, 245, 26, 175, 218, 231, 165,
-        57, 175, 148, 14, 137, 179, 147, 191, 114, 211, 221, 216, 240, 59, 63, 107, 221, 115, 104,
-        181, 103, 244, 43, 36, 10, 38, 68, 108, 25, 253, 238, 136, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 65, 10, 192, 32, 12, 4, 77, 10, 165, 244, 214,
+        159, 216, 31, 244, 51, 61, 120, 241, 32, 226, 251, 85, 140, 176, 136, 122, 209, 129, 144,
+        176, 9, 97, 151, 84, 225, 74, 69, 50, 31, 48, 35, 85, 251, 164, 235, 53, 94, 218, 247, 75,
+        163, 95, 150, 12, 153, 179, 227, 191, 114, 195, 222, 216, 240, 59, 63, 75, 221, 251, 208,
+        106, 207, 232, 150, 65, 100, 53, 33, 2, 22, 232, 178, 27, 144, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -301,19 +306,20 @@ fn complex_brillig_foreign_call() {
         private_parameters: BTreeSet::from([Witness(1), Witness(2), Witness(3)]),
         ..Circuit::default()
     };
+    let program = Program { functions: vec![circuit] };
 
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 125, 177, 163, 35, 179,
-        154, 35, 8, 51, 7, 232, 204, 9, 188, 139, 184, 83, 116, 233, 241, 173, 152, 98, 12, 213,
-        141, 21, 244, 65, 232, 39, 175, 233, 35, 73, 155, 3, 32, 204, 48, 206, 18, 158, 19, 175,
-        37, 60, 175, 228, 209, 30, 195, 143, 226, 197, 178, 103, 105, 76, 110, 160, 209, 156, 160,
-        209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 241,
-        250, 201, 99, 206, 251, 96, 95, 161, 242, 14, 193, 243, 40, 162, 105, 253, 219, 12, 75, 47,
-        146, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96, 20, 85, 75, 253, 136, 249, 87, 249, 105,
-        231, 220, 4, 249, 237, 132, 56, 20, 224, 109, 113, 223, 88, 82, 153, 34, 64, 34, 14, 164,
-        69, 172, 48, 2, 23, 243, 6, 31, 25, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 65, 14, 132, 32, 12, 108, 101, 117, 205, 222,
+        246, 7, 38, 187, 15, 96, 247, 5, 254, 197, 120, 211, 232, 209, 231, 139, 113, 136, 181, 65,
+        47, 98, 162, 147, 52, 20, 24, 202, 164, 45, 48, 205, 200, 157, 49, 124, 227, 44, 129, 207,
+        152, 75, 120, 94, 137, 209, 30, 195, 143, 227, 197, 178, 103, 105, 76, 110, 160, 209, 156,
+        160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 97,
+        254, 196, 152, 99, 157, 176, 87, 168, 188, 147, 224, 121, 20, 209, 180, 254, 109, 70, 75,
+        47, 178, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96, 20, 85, 75, 253, 8, 255, 171, 246,
+        121, 231, 220, 4, 249, 237, 132, 56, 28, 224, 109, 113, 223, 180, 164, 50, 165, 0, 137, 17,
+        72, 139, 88, 97, 4, 173, 98, 132, 157, 33, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -342,13 +348,16 @@ fn memory_op_circuit() {
         return_values: PublicInputs([Witness(4)].into()),
         ..Circuit::default()
     };
-    let bytes = Circuit::serialize_circuit(&circuit);
+    let program = Program { functions: vec![circuit] };
+
+    let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 145, 187, 17, 0, 32, 8, 67, 195, 111, 31, 220, 192,
-        253, 167, 178, 144, 2, 239, 236, 132, 194, 52, 129, 230, 93, 8, 6, 64, 176, 101, 225, 28,
-        78, 49, 43, 238, 154, 225, 254, 166, 209, 205, 165, 98, 174, 212, 177, 188, 187, 92, 255,
-        173, 92, 173, 190, 93, 82, 80, 78, 123, 14, 127, 60, 97, 1, 210, 144, 46, 242, 19, 3, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 201, 13, 0, 32, 8, 147, 195, 125, 112, 3, 247,
+        159, 74, 141, 60, 106, 226, 79, 120, 216, 132, 180, 124, 154, 82, 168, 108, 212, 57, 2,
+        122, 129, 157, 201, 181, 150, 59, 186, 179, 189, 161, 101, 251, 82, 176, 175, 196, 121, 89,
+        118, 185, 246, 91, 185, 26, 125, 187, 64, 80, 134, 29, 195, 31, 79, 24, 2, 250, 167, 252,
+        27, 3, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
diff --git a/acvm-repo/acvm_js/src/compression.rs b/acvm-repo/acvm_js/src/compression.rs
index fedaa514bf0..18e9216297e 100644
--- a/acvm-repo/acvm_js/src/compression.rs
+++ b/acvm-repo/acvm_js/src/compression.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use js_sys::JsString;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -13,10 +13,11 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString>
     console_error_panic_hook::set_once();
 
     let witness_map = WitnessMap::from(witness_map);
-    let compressed_witness_map: Vec<u8> =
-        Vec::<u8>::try_from(witness_map).map_err(|err| err.to_string())?;
+    let witness_stack = WitnessStack::from(witness_map);
+    let compressed_witness_stack: Vec<u8> =
+        Vec::<u8>::try_from(witness_stack).map_err(|err| err.to_string())?;
 
-    Ok(compressed_witness_map)
+    Ok(compressed_witness_stack)
 }
 
 /// Decompresses a compressed witness as outputted by Nargo into a `WitnessMap`.
@@ -27,8 +28,8 @@ pub fn compress_witness(witness_map: JsWitnessMap) -> Result<Vec<u8>, JsString>
 pub fn decompress_witness(compressed_witness: Vec<u8>) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
 
-    let witness_map =
-        WitnessMap::try_from(compressed_witness.as_slice()).map_err(|err| err.to_string())?;
+    let witness_stack =
+        WitnessStack::try_from(compressed_witness.as_slice()).map_err(|err| err.to_string())?;
 
-    Ok(witness_map.into())
+    Ok(witness_stack.stack[0].witness.clone().into())
 }
diff --git a/acvm-repo/acvm_js/src/execute.rs b/acvm-repo/acvm_js/src/execute.rs
index 3f691e1abf2..ac71a573e64 100644
--- a/acvm-repo/acvm_js/src/execute.rs
+++ b/acvm-repo/acvm_js/src/execute.rs
@@ -1,5 +1,5 @@
 use acvm::{
-    acir::circuit::Circuit,
+    acir::circuit::Program,
     pwg::{ACVMStatus, ErrorLocation, OpcodeResolutionError, ACVM},
 };
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
@@ -34,7 +34,7 @@ pub async fn create_black_box_solver() -> WasmBlackBoxFunctionSolver {
 /// @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
 #[wasm_bindgen(js_name = executeCircuit, skip_jsdoc)]
 pub async fn execute_circuit(
-    circuit: Vec<u8>,
+    program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
 ) -> Result<JsWitnessMap, Error> {
@@ -42,7 +42,7 @@ pub async fn execute_circuit(
 
     let solver = WasmBlackBoxFunctionSolver::initialize().await;
 
-    execute_circuit_with_black_box_solver(&solver, circuit, initial_witness, foreign_call_handler)
+    execute_circuit_with_black_box_solver(&solver, program, initial_witness, foreign_call_handler)
         .await
 }
 
@@ -56,13 +56,21 @@ pub async fn execute_circuit(
 #[wasm_bindgen(js_name = executeCircuitWithBlackBoxSolver, skip_jsdoc)]
 pub async fn execute_circuit_with_black_box_solver(
     solver: &WasmBlackBoxFunctionSolver,
-    circuit: Vec<u8>,
+    // TODO(https://github.com/noir-lang/noir/issues/4428): These need to be updated to match the same interfaces
+    // as the native ACVM executor. Right now native execution still only handles one circuit so I do not feel the need
+    // to break the JS interface just yet.
+    program: Vec<u8>,
     initial_witness: JsWitnessMap,
     foreign_call_handler: ForeignCallHandler,
 ) -> Result<JsWitnessMap, Error> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit = Circuit::deserialize_circuit(&circuit)
+    let program: Program = Program::deserialize_program(&program)
         .map_err(|_| JsExecutionError::new("Failed to deserialize circuit. This is likely due to differing serialization formats between ACVM_JS and your compiler".to_string(), None))?;
+    let circuit = match program.functions.len() {
+        0 => return Ok(initial_witness),
+        1 => &program.functions[0],
+        _ => return Err(JsExecutionError::new("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit".to_string(), None).into())
+    };
 
     let mut acvm = ACVM::new(&solver.0, &circuit.opcodes, initial_witness.into());
 
diff --git a/acvm-repo/acvm_js/src/public_witness.rs b/acvm-repo/acvm_js/src/public_witness.rs
index 8dc66c435b3..a0d5b5f8be2 100644
--- a/acvm-repo/acvm_js/src/public_witness.rs
+++ b/acvm-repo/acvm_js/src/public_witness.rs
@@ -1,5 +1,5 @@
 use acvm::acir::{
-    circuit::Circuit,
+    circuit::Program,
     native_types::{Witness, WitnessMap},
 };
 use js_sys::JsString;
@@ -26,16 +26,25 @@ fn extract_indices(witness_map: &WitnessMap, indices: Vec<Witness>) -> Result<Wi
 /// @returns {WitnessMap} A witness map containing the circuit's return values.
 #[wasm_bindgen(js_name = getReturnWitness)]
 pub fn get_return_witness(
-    circuit: Vec<u8>,
+    // TODO(https://github.com/noir-lang/noir/issues/4428): These need to be updated to match the same interfaces
+    // as the native ACVM executor. Right now native execution still only handles one circuit so I do not feel the need
+    // to break the JS interface just yet.
+    program: Vec<u8>,
     witness_map: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit =
-        Circuit::deserialize_circuit(&circuit).expect("Failed to deserialize circuit");
+    let program: Program =
+        Program::deserialize_program(&program).expect("Failed to deserialize circuit");
+    let circuit = match program.functions.len() {
+        0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
+        1 => &program.functions[0],
+        _ => return Err(JsString::from("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit"))
+    };
+
     let witness_map = WitnessMap::from(witness_map);
 
     let return_witness =
-        extract_indices(&witness_map, circuit.return_values.0.into_iter().collect())?;
+        extract_indices(&witness_map, circuit.return_values.0.clone().into_iter().collect())?;
 
     Ok(JsWitnessMap::from(return_witness))
 }
@@ -47,16 +56,22 @@ pub fn get_return_witness(
 /// @returns {WitnessMap} A witness map containing the circuit's public parameters.
 #[wasm_bindgen(js_name = getPublicParametersWitness)]
 pub fn get_public_parameters_witness(
-    circuit: Vec<u8>,
+    program: Vec<u8>,
     solved_witness: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit =
-        Circuit::deserialize_circuit(&circuit).expect("Failed to deserialize circuit");
+    let program: Program =
+        Program::deserialize_program(&program).expect("Failed to deserialize circuit");
+    let circuit = match program.functions.len() {
+        0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
+        1 => &program.functions[0],
+        _ => return Err(JsString::from("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit"))
+    };
+
     let witness_map = WitnessMap::from(solved_witness);
 
     let public_params_witness =
-        extract_indices(&witness_map, circuit.public_parameters.0.into_iter().collect())?;
+        extract_indices(&witness_map, circuit.public_parameters.0.clone().into_iter().collect())?;
 
     Ok(JsWitnessMap::from(public_params_witness))
 }
@@ -68,16 +83,22 @@ pub fn get_public_parameters_witness(
 /// @returns {WitnessMap} A witness map containing the circuit's public inputs.
 #[wasm_bindgen(js_name = getPublicWitness)]
 pub fn get_public_witness(
-    circuit: Vec<u8>,
+    program: Vec<u8>,
     solved_witness: JsWitnessMap,
 ) -> Result<JsWitnessMap, JsString> {
     console_error_panic_hook::set_once();
-    let circuit: Circuit =
-        Circuit::deserialize_circuit(&circuit).expect("Failed to deserialize circuit");
+    let program: Program =
+        Program::deserialize_program(&program).expect("Failed to deserialize circuit");
+    let circuit = match program.functions.len() {
+        0 => return Ok(JsWitnessMap::from(WitnessMap::new())),
+        1 => &program.functions[0],
+        _ => return Err(JsString::from("Program contains multiple circuits however ACVM currently only supports programs containing a single circuit"))
+    };
+
     let witness_map = WitnessMap::from(solved_witness);
 
     let public_witness =
-        extract_indices(&witness_map, circuit.public_inputs().0.into_iter().collect())?;
+        extract_indices(&witness_map, circuit.public_inputs().0.clone().into_iter().collect())?;
 
     Ok(JsWitnessMap::from(public_witness))
 }
diff --git a/acvm-repo/acvm_js/test/shared/addition.ts b/acvm-repo/acvm_js/test/shared/addition.ts
index 217902bdea6..b56a4286878 100644
--- a/acvm-repo/acvm_js/test/shared/addition.ts
+++ b/acvm-repo/acvm_js/test/shared/addition.ts
@@ -2,11 +2,11 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `addition_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 208, 49, 14, 192, 32, 8, 5, 80, 212, 30, 8, 4, 20, 182, 94, 165, 166, 122,
-  255, 35, 52, 77, 28, 76, 58, 214, 191, 124, 166, 23, 242, 15, 0, 8, 240, 77, 154, 125, 206, 198, 127, 161, 176, 209,
-  138, 139, 197, 88, 68, 122, 205, 157, 152, 46, 204, 222, 76, 81, 180, 21, 35, 35, 53, 189, 179, 49, 119, 19, 171, 222,
-  188, 162, 147, 112, 167, 161, 206, 99, 98, 105, 223, 95, 248, 26, 113, 90, 97, 185, 97, 217, 56, 173, 35, 63, 243, 81,
-  87, 163, 125, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 144, 75, 14, 128, 32, 12, 68, 249, 120, 160, 150, 182, 208, 238, 188, 138, 68,
+  184, 255, 17, 212, 200, 130, 196, 165, 188, 164, 153, 174, 94, 38, 227, 221, 203, 118, 159, 119, 95, 226, 200, 125,
+  36, 252, 3, 253, 66, 87, 152, 92, 4, 153, 185, 149, 212, 144, 240, 128, 100, 85, 5, 88, 106, 86, 84, 20, 149, 51, 41,
+  81, 83, 214, 98, 213, 10, 24, 50, 53, 236, 98, 212, 135, 44, 174, 235, 5, 143, 35, 12, 151, 159, 126, 55, 109, 28,
+  231, 145, 47, 245, 105, 191, 143, 133, 1, 0, 0,
 ]);
 
 export const initialWitnessMap: WitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
index 27abd72305f..fba8470585f 100644
--- a/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/complex_foreign_call.ts
@@ -2,13 +2,13 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 125, 177, 163, 35, 179, 154, 35, 8, 51, 7, 232, 204,
-  9, 188, 139, 184, 83, 116, 233, 241, 173, 152, 98, 12, 213, 141, 21, 244, 65, 232, 39, 175, 233, 35, 73, 155, 3, 32,
-  204, 48, 206, 18, 158, 19, 175, 37, 60, 175, 228, 209, 30, 195, 143, 226, 197, 178, 103, 105, 76, 110, 160, 209, 156,
-  160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 241, 250, 201, 99, 206, 251,
-  96, 95, 161, 242, 14, 193, 243, 40, 162, 105, 253, 219, 12, 75, 47, 146, 186, 251, 37, 116, 86, 93, 219, 55, 245, 96,
-  20, 85, 75, 253, 136, 249, 87, 249, 105, 231, 220, 4, 249, 237, 132, 56, 20, 224, 109, 113, 223, 88, 82, 153, 34, 64,
-  34, 14, 164, 69, 172, 48, 2, 23, 243, 6, 31, 25, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 65, 14, 132, 32, 12, 108, 101, 117, 205, 222, 246, 7, 38, 187, 15, 96,
+  247, 5, 254, 197, 120, 211, 232, 209, 231, 139, 113, 136, 181, 65, 47, 98, 162, 147, 52, 20, 24, 202, 164, 45, 48,
+  205, 200, 157, 49, 124, 227, 44, 129, 207, 152, 75, 120, 94, 137, 209, 30, 195, 143, 227, 197, 178, 103, 105, 76, 110,
+  160, 209, 156, 160, 209, 247, 195, 69, 235, 29, 179, 46, 81, 243, 103, 2, 239, 231, 225, 44, 117, 150, 97, 254, 196,
+  152, 99, 157, 176, 87, 168, 188, 147, 224, 121, 20, 209, 180, 254, 109, 70, 75, 47, 178, 186, 251, 37, 116, 86, 93,
+  219, 55, 245, 96, 20, 85, 75, 253, 8, 255, 171, 246, 121, 231, 220, 4, 249, 237, 132, 56, 28, 224, 109, 113, 223, 180,
+  164, 50, 165, 0, 137, 17, 72, 139, 88, 97, 4, 173, 98, 132, 157, 33, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
index c0859f50135..5aef521f231 100644
--- a/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
+++ b/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts
@@ -1,8 +1,8 @@
 // See `fixed_base_scalar_mul_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 91, 10, 0, 32, 16, 2, 109, 171, 175, 46, 221, 209, 247, 229, 130, 130,
-  140, 200, 92, 0, 11, 157, 228, 35, 127, 212, 200, 29, 61, 116, 76, 220, 217, 250, 171, 91, 113, 160, 66, 104, 242, 97,
-  0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, 29, 61, 43, 3, 5, 121, 34,
+  207, 86, 231, 162, 198, 157, 124, 228, 71, 157, 220, 232, 161, 227, 226, 206, 214, 95, 221, 74, 0, 116, 58, 13, 182,
+  105, 0, 0, 0,
 ]);
 export const initialWitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
diff --git a/acvm-repo/acvm_js/test/shared/foreign_call.ts b/acvm-repo/acvm_js/test/shared/foreign_call.ts
index 0be8937b57d..dd010f0c5e5 100644
--- a/acvm-repo/acvm_js/test/shared/foreign_call.ts
+++ b/acvm-repo/acvm_js/test/shared/foreign_call.ts
@@ -2,10 +2,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 177, 10, 192, 32, 16, 67, 227, 21, 74, 233, 212, 79, 177, 127, 208, 159,
-  233, 224, 226, 32, 226, 247, 139, 168, 16, 68, 93, 244, 45, 119, 228, 142, 144, 92, 0, 20, 50, 7, 237, 76, 213, 190,
-  50, 245, 26, 175, 218, 231, 165, 57, 175, 148, 14, 137, 179, 147, 191, 114, 211, 221, 216, 240, 59, 63, 107, 221, 115,
-  104, 181, 103, 244, 43, 36, 10, 38, 68, 108, 25, 253, 238, 136, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 65, 10, 192, 32, 12, 4, 77, 10, 165, 244, 214, 159, 216, 31, 244, 51, 61,
+  120, 241, 32, 226, 251, 85, 140, 176, 136, 122, 209, 129, 144, 176, 9, 97, 151, 84, 225, 74, 69, 50, 31, 48, 35, 85,
+  251, 164, 235, 53, 94, 218, 247, 75, 163, 95, 150, 12, 153, 179, 227, 191, 114, 195, 222, 216, 240, 59, 63, 75, 221,
+  251, 208, 106, 207, 232, 150, 65, 100, 53, 33, 2, 22, 232, 178, 27, 144, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],
diff --git a/acvm-repo/acvm_js/test/shared/memory_op.ts b/acvm-repo/acvm_js/test/shared/memory_op.ts
index b5ab64b3447..1d0e06b3c8a 100644
--- a/acvm-repo/acvm_js/test/shared/memory_op.ts
+++ b/acvm-repo/acvm_js/test/shared/memory_op.ts
@@ -1,9 +1,9 @@
 // See `memory_op_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 145, 187, 17, 0, 32, 8, 67, 195, 111, 31, 220, 192, 253, 167, 178, 144, 2,
-  239, 236, 132, 194, 52, 129, 230, 93, 8, 6, 64, 176, 101, 225, 28, 78, 49, 43, 238, 154, 225, 254, 166, 209, 205, 165,
-  98, 174, 212, 177, 188, 187, 92, 255, 173, 92, 173, 190, 93, 82, 80, 78, 123, 14, 127, 60, 97, 1, 210, 144, 46, 242,
-  19, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 81, 201, 13, 0, 32, 8, 147, 195, 125, 112, 3, 247, 159, 74, 141, 60, 106, 226,
+  79, 120, 216, 132, 180, 124, 154, 82, 168, 108, 212, 57, 2, 122, 129, 157, 201, 181, 150, 59, 186, 179, 189, 161, 101,
+  251, 82, 176, 175, 196, 121, 89, 118, 185, 246, 91, 185, 26, 125, 187, 64, 80, 134, 29, 195, 31, 79, 24, 2, 250, 167,
+  252, 27, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/pedersen.ts b/acvm-repo/acvm_js/test/shared/pedersen.ts
index 5150d24131c..00d207053d8 100644
--- a/acvm-repo/acvm_js/test/shared/pedersen.ts
+++ b/acvm-repo/acvm_js/test/shared/pedersen.ts
@@ -1,7 +1,7 @@
 // See `pedersen_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 135, 9, 0, 48, 8, 75, 171, 224, 255, 15, 139, 27, 196, 64, 200, 100, 0, 15,
-  133, 80, 57, 89, 219, 127, 39, 173, 126, 235, 236, 247, 151, 48, 224, 71, 90, 33, 97, 0, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 7, 6, 0, 0, 8, 108, 209, 255, 63, 156, 54, 233, 56, 55, 17, 26, 18, 196,
+  241, 169, 250, 178, 141, 167, 32, 159, 254, 234, 238, 255, 87, 112, 52, 63, 63, 101, 105, 0, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([[1, '0x0000000000000000000000000000000000000000000000000000000000000001']]);
diff --git a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
index 2127de66f69..14c32c615c8 100644
--- a/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
+++ b/acvm-repo/acvm_js/test/shared/schnorr_verify.ts
@@ -1,17 +1,17 @@
 // See `schnorr_verify_circuit` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 74, 3, 1, 20, 69, 209, 177, 247, 222, 123, 239, 189, 119, 141, 93, 99,
-  220, 133, 251, 95, 130, 152, 103, 78, 32, 3, 195, 33, 4, 66, 248, 239, 254, 20, 69, 209, 84, 212, 158, 216, 206, 223,
-  234, 219, 204, 146, 239, 91, 170, 111, 103, 245, 109, 101, 27, 219, 217, 193, 250, 219, 197, 110, 246, 176, 151, 125,
-  236, 231, 0, 7, 57, 196, 97, 142, 112, 148, 99, 28, 231, 4, 39, 57, 197, 105, 206, 112, 150, 115, 156, 231, 2, 23,
-  185, 196, 101, 174, 112, 149, 107, 92, 231, 6, 55, 185, 197, 109, 238, 112, 151, 123, 220, 231, 1, 15, 121, 196, 99,
-  158, 240, 148, 103, 60, 231, 5, 47, 121, 197, 107, 222, 240, 150, 119, 188, 231, 3, 75, 124, 228, 83, 195, 142, 121,
-  158, 125, 126, 225, 43, 223, 248, 206, 15, 126, 178, 204, 47, 86, 248, 237, 119, 43, 76, 127, 105, 47, 189, 165, 181,
-  116, 150, 198, 234, 125, 117, 249, 47, 233, 41, 45, 165, 163, 52, 148, 126, 210, 78, 186, 73, 51, 233, 37, 173, 164,
-  147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33, 45, 164, 131, 52, 144, 253, 23, 139, 218, 238, 217, 60, 123, 103,
-  235, 236, 156, 141, 179, 239, 166, 93, 183, 237, 185, 107, 199, 125, 251, 29, 218, 237, 216, 94, 167, 118, 58, 183,
-  207, 165, 93, 174, 237, 113, 107, 135, 123, 247, 47, 185, 251, 147, 59, 191, 184, 239, 155, 187, 126, 184, 103, 217,
-  29, 235, 55, 171, 223, 173, 104, 184, 231, 255, 243, 7, 236, 52, 239, 128, 225, 3, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 210, 7, 78, 2, 1, 20, 69, 81, 236, 189, 247, 222, 123, 239, 93, 177, 33, 34,
+  238, 194, 253, 47, 193, 200, 147, 67, 194, 36, 147, 163, 33, 33, 228, 191, 219, 82, 168, 63, 63, 181, 183, 197, 223,
+  177, 147, 191, 181, 183, 149, 69, 159, 183, 213, 222, 238, 218, 219, 206, 14, 118, 178, 139, 141, 183, 135, 189, 236,
+  99, 63, 7, 56, 200, 33, 14, 115, 132, 163, 28, 227, 56, 39, 56, 201, 41, 78, 115, 134, 179, 156, 227, 60, 23, 184,
+  200, 37, 46, 115, 133, 171, 92, 227, 58, 55, 184, 201, 45, 110, 115, 135, 187, 220, 227, 62, 15, 120, 200, 35, 30,
+  243, 132, 167, 60, 227, 57, 47, 120, 201, 43, 94, 243, 134, 183, 188, 227, 61, 31, 248, 200, 39, 22, 249, 204, 151,
+  166, 29, 243, 188, 250, 255, 141, 239, 44, 241, 131, 101, 126, 178, 194, 47, 86, 249, 237, 123, 171, 76, 127, 105, 47,
+  189, 165, 181, 116, 150, 198, 26, 125, 245, 248, 45, 233, 41, 45, 165, 163, 52, 148, 126, 210, 78, 186, 73, 51, 233,
+  37, 173, 164, 147, 52, 146, 62, 210, 70, 186, 72, 19, 233, 33, 45, 164, 131, 52, 144, 253, 151, 11, 245, 221, 179,
+  121, 246, 206, 214, 217, 57, 27, 103, 223, 109, 187, 238, 218, 115, 223, 142, 135, 246, 59, 182, 219, 169, 189, 206,
+  237, 116, 105, 159, 107, 187, 220, 218, 227, 222, 14, 143, 238, 95, 116, 247, 23, 119, 126, 115, 223, 146, 187, 150,
+  221, 179, 226, 142, 141, 155, 53, 238, 86, 104, 186, 231, 255, 243, 7, 100, 141, 232, 192, 233, 3, 0, 0,
 ]);
 
 export const initialWitnessMap = new Map([
diff --git a/acvm-repo/acvm_js/test/shared/witness_compression.ts b/acvm-repo/acvm_js/test/shared/witness_compression.ts
index 36b9a0284af..d2326c1b11b 100644
--- a/acvm-repo/acvm_js/test/shared/witness_compression.ts
+++ b/acvm-repo/acvm_js/test/shared/witness_compression.ts
@@ -4,19 +4,21 @@
 //   assert(x != y);
 //   x + y
 // }
+//
+// Regenerate this byte array by going to the Noir integration tests and running `/test_programs/execution_success/witness_compression`
+// after recompiling Noir to print the witness byte array to be written to file after execution
 
 export const expectedCompressedWitnessMap = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 173, 208, 187, 13, 128, 48, 12, 4, 80, 190, 153, 199, 142, 237, 196, 238, 88, 133,
-  8, 103, 255, 17, 64, 34, 5, 61, 62, 233, 164, 171, 94, 113, 105, 122, 51, 63, 61, 198, 134, 127, 193, 37, 206, 202,
-  235, 199, 34, 40, 204, 94, 179, 35, 225, 9, 217, 154, 10, 176, 180, 162, 168, 40, 42, 87, 86, 34, 87, 214, 106, 205,
-  42, 24, 50, 57, 118, 49, 234, 3, 219, 2, 173, 61, 240, 175, 20, 103, 209, 13, 151, 252, 77, 33, 208, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 173, 206, 185, 13, 0, 48, 8, 67, 209, 144, 107, 30, 146, 44, 144, 253, 167, 162,
+  65, 130, 158, 239, 198, 174, 158, 44, 45, 178, 211, 254, 222, 90, 203, 17, 206, 186, 29, 252, 53, 64, 107, 114, 150,
+  46, 206, 122, 6, 24, 73, 44, 193, 220, 1, 0, 0,
 ]);
 
 export const expectedWitnessMap = new Map([
-  [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [2, '0x0000000000000000000000000000000000000000000000000000000000000002'],
-  [3, '0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000'],
-  [4, '0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000'],
-  [5, '0x0000000000000000000000000000000000000000000000000000000000000001'],
-  [6, '0x0000000000000000000000000000000000000000000000000000000000000003'],
+  [0, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [1, '0x0000000000000000000000000000000000000000000000000000000000000002'],
+  [2, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [3, '0x0000000000000000000000000000000000000000000000000000000000000001'],
+  [4, '0x0000000000000000000000000000000000000000000000000000000000000000'],
+  [5, '0x0000000000000000000000000000000000000000000000000000000000000003'],
 ]);
diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
index 03a8e53e510..22a0ebe1170 100644
--- a/acvm-repo/brillig/src/opcodes.rs
+++ b/acvm-repo/brillig/src/opcodes.rs
@@ -156,6 +156,13 @@ pub enum BrilligOpcode {
         destination: MemoryAddress,
         source: MemoryAddress,
     },
+    /// destination = condition > 0 ? source_a : source_b
+    ConditionalMov {
+        destination: MemoryAddress,
+        source_a: MemoryAddress,
+        source_b: MemoryAddress,
+        condition: MemoryAddress,
+    },
     Load {
         destination: MemoryAddress,
         source_pointer: MemoryAddress,
diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
index c7bf014f068..e2a037618a4 100644
--- a/acvm-repo/brillig_vm/src/lib.rs
+++ b/acvm-repo/brillig_vm/src/lib.rs
@@ -339,6 +339,15 @@ impl<'a, B: BlackBoxFunctionSolver> VM<'a, B> {
                 self.memory.write(*destination_address, source_value);
                 self.increment_program_counter()
             }
+            Opcode::ConditionalMov { destination, source_a, source_b, condition } => {
+                let condition_value = self.memory.read(*condition);
+                if condition_value.is_zero() {
+                    self.memory.write(*destination, self.memory.read(*source_b));
+                } else {
+                    self.memory.write(*destination, self.memory.read(*source_a));
+                }
+                self.increment_program_counter()
+            }
             Opcode::Trap => self.fail("explicit trap hit in brillig".to_string()),
             Opcode::Stop { return_data_offset, return_data_size } => {
                 self.finish(*return_data_offset, *return_data_size)
@@ -793,6 +802,52 @@ mod tests {
         assert_eq!(source_value, Value::from(1u128));
     }
 
+    #[test]
+    fn cmov_opcode() {
+        let calldata =
+            vec![Value::from(0u128), Value::from(1u128), Value::from(2u128), Value::from(3u128)];
+
+        let calldata_copy = Opcode::CalldataCopy {
+            destination_address: MemoryAddress::from(0),
+            size: 4,
+            offset: 0,
+        };
+
+        let opcodes = &[
+            calldata_copy,
+            Opcode::ConditionalMov {
+                destination: MemoryAddress(4), // Sets 3_u128 to memory address 4
+                source_a: MemoryAddress(2),
+                source_b: MemoryAddress(3),
+                condition: MemoryAddress(0),
+            },
+            Opcode::ConditionalMov {
+                destination: MemoryAddress(5), // Sets 2_u128 to memory address 5
+                source_a: MemoryAddress(2),
+                source_b: MemoryAddress(3),
+                condition: MemoryAddress(1),
+            },
+        ];
+        let mut vm = VM::new(calldata, opcodes, vec![], &DummyBlackBoxSolver);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
+
+        let VM { memory, .. } = vm;
+
+        let destination_value = memory.read(MemoryAddress::from(4));
+        assert_eq!(destination_value, Value::from(3_u128));
+
+        let source_value = memory.read(MemoryAddress::from(5));
+        assert_eq!(source_value, Value::from(2_u128));
+    }
+
     #[test]
     fn cmp_binary_ops() {
         let bit_size = 32;
diff --git a/aztec_macros/Cargo.toml b/aztec_macros/Cargo.toml
index ed9821fabcf..355036d28a7 100644
--- a/aztec_macros/Cargo.toml
+++ b/aztec_macros/Cargo.toml
@@ -14,3 +14,5 @@ noirc_frontend.workspace = true
 noirc_errors.workspace = true
 iter-extended.workspace = true
 convert_case = "0.6.0"
+regex = "1.10"
+
diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
index e0100977eee..0fe450e6cb1 100644
--- a/aztec_macros/src/lib.rs
+++ b/aztec_macros/src/lib.rs
@@ -5,22 +5,27 @@ use transforms::{
     compute_note_hash_and_nullifier::inject_compute_note_hash_and_nullifier,
     events::{generate_selector_impl, transform_events},
     functions::{transform_function, transform_unconstrained, transform_vm_function},
+    note_interface::generate_note_interface_impl,
     storage::{
         assign_storage_slots, check_for_storage_definition, check_for_storage_implementation,
         generate_storage_implementation,
     },
 };
 
-use noirc_frontend::hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl};
-
-use noirc_frontend::macros_api::SortedModule;
-use noirc_frontend::macros_api::{CrateId, MacroError};
-use noirc_frontend::macros_api::{FileId, MacroProcessor};
-use noirc_frontend::macros_api::{HirContext, SecondaryAttribute, Span};
+use noirc_frontend::{
+    hir::def_collector::dc_crate::{UnresolvedFunctions, UnresolvedTraitImpl},
+    macros_api::{
+        CrateId, FileId, HirContext, MacroError, MacroProcessor, SecondaryAttribute, SortedModule,
+        Span,
+    },
+};
 
-use utils::ast_utils::is_custom_attribute;
-use utils::checks::{check_for_aztec_dependency, has_aztec_dependency};
-use utils::{constants::MAX_CONTRACT_PRIVATE_FUNCTIONS, errors::AztecMacroError};
+use utils::{
+    ast_utils::is_custom_attribute,
+    checks::{check_for_aztec_dependency, has_aztec_dependency},
+    constants::MAX_CONTRACT_PRIVATE_FUNCTIONS,
+    errors::AztecMacroError,
+};
 pub struct AztecMacro;
 
 impl MacroProcessor for AztecMacro {
@@ -28,9 +33,10 @@ impl MacroProcessor for AztecMacro {
         &self,
         ast: SortedModule,
         crate_id: &CrateId,
+        file_id: FileId,
         context: &HirContext,
     ) -> Result<SortedModule, (MacroError, FileId)> {
-        transform(ast, crate_id, context)
+        transform(ast, crate_id, file_id, context)
     }
 
     fn process_collected_defs(
@@ -61,38 +67,34 @@ impl MacroProcessor for AztecMacro {
 fn transform(
     mut ast: SortedModule,
     crate_id: &CrateId,
+    file_id: FileId,
     context: &HirContext,
 ) -> Result<SortedModule, (MacroError, FileId)> {
     // Usage -> mut ast -> aztec_library::transform(&mut ast)
     // Covers all functions in the ast
     for submodule in ast.submodules.iter_mut().filter(|submodule| submodule.is_contract) {
-        if transform_module(&mut submodule.contents, crate_id, context)
-            .map_err(|(err, file_id)| (err.into(), file_id))?
-        {
+        if transform_module(&mut submodule.contents).map_err(|err| (err.into(), file_id))? {
             check_for_aztec_dependency(crate_id, context)?;
         }
     }
+
+    generate_note_interface_impl(&mut ast).map_err(|err| (err.into(), file_id))?;
+
     Ok(ast)
 }
 
 /// Determines if ast nodes are annotated with aztec attributes.
 /// For annotated functions it calls the `transform` function which will perform the required transformations.
 /// Returns true if an annotated node is found, false otherwise
-fn transform_module(
-    module: &mut SortedModule,
-    crate_id: &CrateId,
-    context: &HirContext,
-) -> Result<bool, (AztecMacroError, FileId)> {
+fn transform_module(module: &mut SortedModule) -> Result<bool, AztecMacroError> {
     let mut has_transformed_module = false;
 
     // Check for a user defined storage struct
     let storage_defined = check_for_storage_definition(module);
     let storage_implemented = check_for_storage_implementation(module);
 
-    let crate_graph = &context.crate_graph[crate_id];
-
     if storage_defined && !storage_implemented {
-        generate_storage_implementation(module).map_err(|err| (err, crate_graph.root_file_id))?;
+        generate_storage_implementation(module)?;
     }
 
     for structure in module.types.iter() {
@@ -144,12 +146,10 @@ fn transform_module(
                 is_initializer,
                 insert_init_check,
                 is_internal,
-            )
-            .map_err(|err| (err, crate_graph.root_file_id))?;
+            )?;
             has_transformed_module = true;
         } else if is_public_vm {
-            transform_vm_function(func, storage_defined)
-                .map_err(|err| (err, crate_graph.root_file_id))?;
+            transform_vm_function(func, storage_defined)?;
             has_transformed_module = true;
         } else if storage_defined && func.def.is_unconstrained {
             transform_unconstrained(func);
@@ -173,11 +173,9 @@ fn transform_module(
             .count();
 
         if private_functions_count > MAX_CONTRACT_PRIVATE_FUNCTIONS {
-            let crate_graph = &context.crate_graph[crate_id];
-            return Err((
-                AztecMacroError::ContractHasTooManyPrivateFunctions { span: Span::default() },
-                crate_graph.root_file_id,
-            ));
+            return Err(AztecMacroError::ContractHasTooManyPrivateFunctions {
+                span: Span::default(),
+            });
         }
     }
 
diff --git a/aztec_macros/src/transforms/mod.rs b/aztec_macros/src/transforms/mod.rs
index 144ffc3efc3..5a454c75148 100644
--- a/aztec_macros/src/transforms/mod.rs
+++ b/aztec_macros/src/transforms/mod.rs
@@ -1,4 +1,5 @@
 pub mod compute_note_hash_and_nullifier;
 pub mod events;
 pub mod functions;
+pub mod note_interface;
 pub mod storage;
diff --git a/aztec_macros/src/transforms/note_interface.rs b/aztec_macros/src/transforms/note_interface.rs
new file mode 100644
index 00000000000..01d0272088b
--- /dev/null
+++ b/aztec_macros/src/transforms/note_interface.rs
@@ -0,0 +1,583 @@
+use noirc_errors::Span;
+use noirc_frontend::{
+    parse_program, parser::SortedModule, ItemVisibility, NoirFunction, NoirStruct, PathKind,
+    TraitImplItem, TypeImpl, UnresolvedTypeData, UnresolvedTypeExpression,
+};
+use regex::Regex;
+
+use crate::{
+    chained_dep,
+    utils::{
+        ast_utils::{
+            check_trait_method_implemented, ident, ident_path, is_custom_attribute, make_type,
+        },
+        errors::AztecMacroError,
+    },
+};
+
+// Automatic implementation of most of the methods in the NoteInterface trait, guiding the user with meaningful error messages in case some
+// methods must be implemented manually.
+pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), AztecMacroError> {
+    // Find structs annotated with #[aztec(note)]
+    let annotated_note_structs = module
+        .types
+        .iter_mut()
+        .filter(|typ| typ.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(note)")));
+
+    let mut note_properties_structs = vec![];
+
+    for note_struct in annotated_note_structs {
+        // Look for the NoteInterface trait implementation for the note
+        let trait_impl = module
+            .trait_impls
+            .iter_mut()
+            .find(|trait_impl| {
+                if let UnresolvedTypeData::Named(struct_path, _, _) = &trait_impl.object_type.typ {
+                    struct_path.last_segment() == note_struct.name
+                        && trait_impl.trait_name.last_segment().0.contents == "NoteInterface"
+                } else {
+                    false
+                }
+            })
+            .ok_or(AztecMacroError::CouldNotImplementNoteInterface {
+                span: Some(note_struct.name.span()),
+                secondary_message: Some(format!(
+                    "Could not find NoteInterface trait implementation for note: {}",
+                    note_struct.name.0.contents
+                )),
+            })?;
+        let note_interface_impl_span: Option<Span> = trait_impl.object_type.span;
+        // Look for the note struct implementation, generate a default one if it doesn't exist (in order to append methods to it)
+        let existing_impl = module.impls.iter_mut().find(|r#impl| match &r#impl.object_type.typ {
+            UnresolvedTypeData::Named(path, _, _) => path.last_segment().eq(&note_struct.name),
+            _ => false,
+        });
+        let note_impl = if let Some(note_impl) = existing_impl {
+            note_impl
+        } else {
+            let default_impl = TypeImpl {
+                object_type: trait_impl.object_type.clone(),
+                type_span: note_struct.name.span(),
+                generics: vec![],
+                methods: vec![],
+            };
+            module.impls.push(default_impl.clone());
+            module.impls.last_mut().unwrap()
+        };
+        // Identify the note type (struct name), its fields and its serialized length (generic param of NoteInterface trait impl)
+        let note_type = note_struct.name.0.contents.to_string();
+        let mut note_fields = vec![];
+        let note_serialized_len = match &trait_impl.trait_generics[0].typ {
+            UnresolvedTypeData::Named(path, _, _) => Ok(path.last_segment().0.contents.to_string()),
+            UnresolvedTypeData::Expression(UnresolvedTypeExpression::Constant(val, _)) => {
+                Ok(val.to_string())
+            }
+            _ => Err(AztecMacroError::CouldNotImplementNoteInterface {
+                span: trait_impl.object_type.span,
+                secondary_message: Some(format!(
+                    "Cannot find note serialization length for: {}",
+                    note_type
+                )),
+            }),
+        }?;
+
+        // Automatically inject the header field if it's not present
+        let (header_field_name, _) = if let Some(existing_header) =
+            note_struct.fields.iter().find(|(_, field_type)| match &field_type.typ {
+                UnresolvedTypeData::Named(path, _, _) => {
+                    path.last_segment().0.contents == "NoteHeader"
+                }
+                _ => false,
+            }) {
+            existing_header.clone()
+        } else {
+            let generated_header = (
+                ident("header"),
+                make_type(UnresolvedTypeData::Named(
+                    chained_dep!("aztec", "note", "note_header", "NoteHeader"),
+                    vec![],
+                    false,
+                )),
+            );
+            note_struct.fields.push(generated_header.clone());
+            generated_header
+        };
+
+        for (field_ident, field_type) in note_struct.fields.iter() {
+            note_fields.push((
+                field_ident.0.contents.to_string(),
+                field_type.typ.to_string().replace("plain::", ""),
+            ));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "serialize_content")
+            && !check_trait_method_implemented(trait_impl, "deserialize_content")
+            && !note_impl.methods.iter().any(|(func, _)| func.def.name.0.contents == "properties")
+        {
+            let note_serialize_content_fn = generate_note_serialize_content(
+                &note_type,
+                &note_fields,
+                &note_serialized_len,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(note_serialize_content_fn));
+
+            let note_deserialize_content_fn = generate_note_deserialize_content(
+                &note_type,
+                &note_fields,
+                &note_serialized_len,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(note_deserialize_content_fn));
+
+            let note_properties_struct = generate_note_properties_struct(
+                &note_type,
+                &note_fields,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            note_properties_structs.push(note_properties_struct);
+            let note_properties_fn = generate_note_properties_fn(
+                &note_type,
+                &note_fields,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            note_impl.methods.push((note_properties_fn, note_impl.type_span));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "get_header") {
+            let get_header_fn = generate_note_get_header(
+                &note_type,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(get_header_fn));
+        }
+        if !check_trait_method_implemented(trait_impl, "set_header") {
+            let set_header_fn = generate_note_set_header(
+                &note_type,
+                &header_field_name.0.contents,
+                note_interface_impl_span,
+            )?;
+            trait_impl.items.push(TraitImplItem::Function(set_header_fn));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "get_note_type_id") {
+            let get_note_type_id_fn =
+                generate_note_get_type_id(&note_type, note_interface_impl_span)?;
+            trait_impl.items.push(TraitImplItem::Function(get_note_type_id_fn));
+        }
+
+        if !check_trait_method_implemented(trait_impl, "compute_note_content_hash") {
+            let get_header_fn =
+                generate_compute_note_content_hash(&note_type, note_interface_impl_span)?;
+            trait_impl.items.push(TraitImplItem::Function(get_header_fn));
+        }
+    }
+
+    module.types.extend(note_properties_structs);
+    Ok(())
+}
+
+fn generate_note_get_header(
+    note_type: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn get_header(note: {}) -> dep::aztec::note::note_header::NoteHeader {{
+            note.{}
+        }}
+    ",
+        note_type, note_header_field_name
+    )
+    .to_string();
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn get_header). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+fn generate_note_set_header(
+    note_type: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn set_header(self: &mut {}, header: dep::aztec::note::note_header::NoteHeader) {{
+            self.{} = header;
+        }}
+    ",
+        note_type, note_header_field_name
+    );
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface  {
+            secondary_message: Some("Failed to parse Noir macro code (fn set_header). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate the note type id getter method. The id itself its calculated as the concatenation
+// of the conversion of the characters in the note's struct name to unsigned integers.
+fn generate_note_get_type_id(
+    note_type: &str,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    // TODO(#4519) Improve automatic note id generation and assignment
+    let note_id =
+        note_type.chars().map(|c| (c as u32).to_string()).collect::<Vec<String>>().join("");
+    let function_source = format!(
+        "
+        fn get_note_type_id() -> Field {{
+            {}
+        }}
+    ",
+        note_id
+    )
+    .to_string();
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn get_note_type_id). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate a struct that represents the note's serialization metadata, as
+//
+// NoteTypeFields {
+//     field1: PropertySelector { index: 0, offset: 0, length: 32 },
+//     field2: PropertySelector { index: 1, offset: 0, length: 32 },
+//     ...
+// }
+//
+// It assumes each field occupies an entire field and its serialized in definition order
+fn generate_note_properties_struct(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirStruct, AztecMacroError> {
+    let struct_source =
+        generate_note_properties_struct_source(note_type, note_fields, note_header_field_name);
+
+    let (struct_ast, errors) = parse_program(&struct_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some(format!("Failed to parse Noir macro code (struct {}Properties). This is either a bug in the compiler or the Noir macro code", note_type)),
+            span: impl_span
+        });
+    }
+
+    let mut struct_ast = struct_ast.into_sorted();
+    Ok(struct_ast.types.remove(0))
+}
+
+// Generate the deserialize_content method as
+//
+// fn deserialize_content(serialized_note: [Field; NOTE_SERILIZED_LEN]) -> Self {
+//     NoteType {
+//        note_field1: serialized_note[0] as Field,
+//        note_field2: NoteFieldType2::from_field(serialized_note[1])...
+//     }
+// }
+// It assumes every note field is stored in an individual serialized field,
+// and can be converted to the original type via the from_field() trait (structs) or cast as Field (integers)
+fn generate_note_deserialize_content(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = generate_note_deserialize_content_source(
+        note_type,
+        note_fields,
+        note_serialize_len,
+        note_header_field_name,
+    );
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn deserialize_content). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Generate the serialize_content method as
+//
+// fn serialize_content(self: {}) -> [Field; NOTE_SERIALIZED_LEN] {
+//   [self.note_field1 as Field, self.note_field2.to_field()...]
+// }
+//
+// It assumes every struct field can be converted either via the to_field() trait (structs) or cast as Field (integers)
+fn generate_note_serialize_content(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = generate_note_serialize_content_source(
+        note_type,
+        note_fields,
+        note_serialize_len,
+        note_header_field_name,
+    );
+
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn serialize_content). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate a function in the Note's impl that returns the note's fields metadata
+fn generate_note_properties_fn(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source =
+        generate_note_properties_fn_source(note_type, note_fields, note_header_field_name);
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn properties). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Automatically generate the method to compute the note's content hash as:
+// fn compute_note_content_hash(self: NoteType) -> Field {
+//    // TODO(#1205) Should use a non-zero generator index.
+//    dep::aztec::hash::pedersen_hash(self.serialize_content(), 0)
+// }
+//
+fn generate_compute_note_content_hash(
+    note_type: &String,
+    impl_span: Option<Span>,
+) -> Result<NoirFunction, AztecMacroError> {
+    let function_source = format!(
+        "
+        fn compute_note_content_hash(self: {}) -> Field {{
+            // TODO(#1205) Should use a non-zero generator index.
+            dep::aztec::hash::pedersen_hash(self.serialize_content(), 0)
+        }}
+        ",
+        note_type
+    );
+    let (function_ast, errors) = parse_program(&function_source);
+    if !errors.is_empty() {
+        dbg!(errors);
+        return Err(AztecMacroError::CouldNotImplementNoteInterface {
+            secondary_message: Some("Failed to parse Noir macro code (fn compute_note_content_hash). This is either a bug in the compiler or the Noir macro code".to_string()),
+            span: impl_span
+        });
+    }
+    let mut function_ast = function_ast.into_sorted();
+    let mut noir_fn = function_ast.functions.remove(0);
+    noir_fn.def.span = impl_span.unwrap();
+    noir_fn.def.visibility = ItemVisibility::Public;
+    Ok(noir_fn)
+}
+
+// Source code generator functions. These utility methods produce Noir code as strings, that are then parsed and added to the AST.
+
+fn generate_note_properties_struct_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+) -> String {
+    let note_property_selectors = note_fields
+        .iter()
+        .filter_map(|(field_name, _)| {
+            if field_name != note_header_field_name {
+                Some(format!(
+                    "{}: dep::aztec::note::note_getter_options::PropertySelector",
+                    field_name
+                ))
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(",\n");
+    format!(
+        "
+        struct {}Properties {{
+            {}
+        }}",
+        note_type, note_property_selectors
+    )
+    .to_string()
+}
+
+fn generate_note_properties_fn_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_header_field_name: &String,
+) -> String {
+    let note_property_selectors = note_fields
+        .iter()
+        .enumerate()
+        .filter_map(|(index, (field_name, _))| {
+            if field_name != note_header_field_name {
+                Some(format!(
+                    "{}: dep::aztec::note::note_getter_options::PropertySelector {{ index: {}, offset: 0, length: 32 }}",
+                    field_name,
+                    index
+                ))
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(", ");
+    format!(
+        "
+        pub fn properties() -> {}Properties {{
+            {}Properties {{
+                {}
+            }}
+        }}",
+        note_type, note_type, note_property_selectors
+    )
+    .to_string()
+}
+
+fn generate_note_serialize_content_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+) -> String {
+    let note_fields = note_fields
+        .iter()
+        .filter_map(|(field_name, field_type)| {
+            if field_name != note_header_field_name {
+                if field_type == "Field" {
+                    Some(format!("self.{}", field_name))
+                } else {
+                    Some(format!("self.{}.to_field()", field_name))
+                }
+            } else {
+                None
+            }
+        })
+        .collect::<Vec<String>>()
+        .join(", ");
+    format!(
+        "
+        fn serialize_content(self: {}) -> [Field; {}] {{
+            [{}]
+        }}",
+        note_type, note_serialize_len, note_fields
+    )
+    .to_string()
+}
+
+fn generate_note_deserialize_content_source(
+    note_type: &str,
+    note_fields: &[(String, String)],
+    note_serialize_len: &String,
+    note_header_field_name: &String,
+) -> String {
+    let note_fields = note_fields
+        .iter()
+        .enumerate()
+        .map(|(index, (field_name, field_type))| {
+            if field_name != note_header_field_name {
+                // TODO: Simplify this when https://github.com/noir-lang/noir/issues/4463 is fixed
+                if field_type.eq("Field")
+                    || Regex::new(r"u[0-9]+").unwrap().is_match(field_type)
+                    || field_type.eq("bool")
+                {
+                    format!("{}: serialized_note[{}] as {},", field_name, index, field_type)
+                } else {
+                    format!(
+                        "{}: {}::from_field(serialized_note[{}]),",
+                        field_name, field_type, index
+                    )
+                }
+            } else {
+                format!(
+                    "{}: dep::aztec::note::note_header::NoteHeader::empty()",
+                    note_header_field_name
+                )
+            }
+        })
+        .collect::<Vec<String>>()
+        .join("\n");
+    format!(
+        "
+        fn deserialize_content(serialized_note: [Field; {}]) -> Self {{
+            {} {{
+                {}
+            }}
+        }}",
+        note_serialize_len, note_type, note_fields
+    )
+    .to_string()
+}
diff --git a/aztec_macros/src/utils/ast_utils.rs b/aztec_macros/src/utils/ast_utils.rs
index 71c6a93f388..bdcbad646c2 100644
--- a/aztec_macros/src/utils/ast_utils.rs
+++ b/aztec_macros/src/utils/ast_utils.rs
@@ -2,8 +2,9 @@ use noirc_errors::{Span, Spanned};
 use noirc_frontend::{
     token::SecondaryAttribute, BinaryOpKind, CallExpression, CastExpression, Expression,
     ExpressionKind, FunctionReturnType, Ident, IndexExpression, InfixExpression, Lambda,
-    LetStatement, MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression,
-    Statement, StatementKind, UnaryOp, UnresolvedType, UnresolvedTypeData,
+    LetStatement, MemberAccessExpression, MethodCallExpression, NoirTraitImpl, Path, Pattern,
+    PrefixExpression, Statement, StatementKind, TraitImplItem, UnaryOp, UnresolvedType,
+    UnresolvedTypeData,
 };
 
 //
@@ -173,6 +174,13 @@ pub fn index_array_variable(array: Expression, index: &str) -> Expression {
     })))
 }
 
+pub fn check_trait_method_implemented(trait_impl: &NoirTraitImpl, method_name: &str) -> bool {
+    trait_impl.items.iter().any(|item| match item {
+        TraitImplItem::Function(func) => func.def.name.0.contents == method_name,
+        _ => false,
+    })
+}
+
 /// Checks if an attribute is a custom attribute with a specific name
 pub fn is_custom_attribute(attr: &SecondaryAttribute, attribute_name: &str) -> bool {
     if let SecondaryAttribute::Custom(custom_attr) = attr {
diff --git a/aztec_macros/src/utils/errors.rs b/aztec_macros/src/utils/errors.rs
index 199473baec6..48186555eff 100644
--- a/aztec_macros/src/utils/errors.rs
+++ b/aztec_macros/src/utils/errors.rs
@@ -10,7 +10,7 @@ pub enum AztecMacroError {
     UnsupportedFunctionArgumentType { span: Span, typ: UnresolvedTypeData },
     UnsupportedStorageType { span: Option<Span>, typ: UnresolvedTypeData },
     CouldNotAssignStorageSlots { secondary_message: Option<String> },
-    CouldNotImplementNoteSerialization { span: Option<Span>, typ: UnresolvedTypeData },
+    CouldNotImplementNoteInterface { span: Option<Span>, secondary_message: Option<String> },
     EventError { span: Span, message: String },
     UnsupportedAttributes { span: Span, secondary_message: Option<String> },
 }
@@ -43,9 +43,9 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message,
                 span: None,
             },
-            AztecMacroError::CouldNotImplementNoteSerialization { span, typ } => MacroError {
-                primary_message: format!("Could not implement serialization methods for note `{typ:?}`, please provide a serialize_content and deserialize_content methods"),
-                secondary_message: None,
+            AztecMacroError::CouldNotImplementNoteInterface { span, secondary_message } => MacroError {
+                primary_message: "Could not implement automatic methods for note, please provide an implementation of the NoteInterface trait".to_string(),
+                secondary_message,
                 span,
             },
             AztecMacroError::EventError { span, message } => MacroError {
@@ -53,7 +53,7 @@ impl From<AztecMacroError> for MacroError {
                 secondary_message: None,
                 span: Some(span),
             },
-AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
+            AztecMacroError::UnsupportedAttributes { span, secondary_message } => MacroError {
                 primary_message: "Unsupported attributes in contract function".to_string(),
                 secondary_message,
                 span: Some(span),
diff --git a/compiler/noirc_driver/src/contract.rs b/compiler/noirc_driver/src/contract.rs
index 66e8dc0e730..9a0e25a321b 100644
--- a/compiler/noirc_driver/src/contract.rs
+++ b/compiler/noirc_driver/src/contract.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use fm::FileId;
 use noirc_abi::{Abi, ContractEvent};
 use noirc_errors::debug_info::DebugInfo;
@@ -45,10 +45,10 @@ pub struct ContractFunction {
     pub abi: Abi,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Circuit,
+    pub bytecode: Program,
 
     pub debug: DebugInfo,
 }
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index c9494a64b41..bc3062e5807 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -3,7 +3,7 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 
-use acvm::acir::circuit::ExpressionWidth;
+use acvm::acir::circuit::{ExpressionWidth, Program};
 use clap::Args;
 use fm::{FileId, FileManager};
 use iter_extended::vecmap;
@@ -298,7 +298,7 @@ pub fn compile_main(
 
     if options.print_acir {
         println!("Compiled ACIR for main (unoptimized):");
-        println!("{}", compiled_program.circuit);
+        println!("{}", compiled_program.program);
     }
 
     Ok((compiled_program, warnings))
@@ -414,7 +414,7 @@ fn compile_contract_inner(
             name,
             custom_attributes,
             abi: function.abi,
-            bytecode: function.circuit,
+            bytecode: function.program,
             debug: function.debug,
             is_unconstrained: modifiers.is_unconstrained,
         });
@@ -487,7 +487,8 @@ pub fn compile_no_check(
 
     Ok(CompiledProgram {
         hash,
-        circuit,
+        // TODO(https://github.com/noir-lang/noir/issues/4428)
+        program: Program { functions: vec![circuit] },
         debug,
         abi,
         file_map,
diff --git a/compiler/noirc_driver/src/program.rs b/compiler/noirc_driver/src/program.rs
index 8d509d3bf68..6f527297dcb 100644
--- a/compiler/noirc_driver/src/program.rs
+++ b/compiler/noirc_driver/src/program.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use fm::FileId;
 
 use noirc_errors::debug_info::DebugInfo;
@@ -19,10 +19,10 @@ pub struct CompiledProgram {
     pub hash: u64,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub circuit: Circuit,
+    pub program: Program,
     pub abi: noirc_abi::Abi,
     pub debug: DebugInfo,
     pub file_map: BTreeMap<FileId, DebugFile>,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
index a9eea74ddd9..94e81d02053 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1346,18 +1346,23 @@ impl<'block> BrilligBlock<'block> {
             BrilligBinaryOp::LessThan,
         );
 
-        self.brillig_context.codegen_branch(result_is_negative.address, |ctx, is_negative| {
-            if is_negative {
-                // Two's complement of num
-                let zero = ctx.make_constant_instruction(0_usize.into(), num.bit_size);
-                ctx.binary_instruction(zero, num, absolute_value, BrilligBinaryOp::Sub);
-                ctx.deallocate_single_addr(zero);
-            } else {
-                // Simply move the original num
-                ctx.mov_instruction(absolute_value.address, num.address);
-            }
-        });
+        // Two's complement of num
+        let zero = self.brillig_context.make_constant_instruction(0_usize.into(), num.bit_size);
+        let twos_complement =
+            SingleAddrVariable::new(self.brillig_context.allocate_register(), num.bit_size);
+        self.brillig_context.binary_instruction(zero, num, twos_complement, BrilligBinaryOp::Sub);
+
+        // absolute_value = result_is_negative ? twos_complement : num
+        self.brillig_context.conditional_mov_instruction(
+            absolute_value.address,
+            result_is_negative.address,
+            twos_complement.address,
+            num.address,
+        );
+
+        self.brillig_context.deallocate_single_addr(zero);
         self.brillig_context.deallocate_single_addr(max_positive);
+        self.brillig_context.deallocate_single_addr(twos_complement);
     }
 
     fn convert_signed_division(
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
index fa99e968a31..5611905697c 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs
@@ -121,6 +121,24 @@ impl DebugShow {
         debug_println!(self.enable_debug_trace, "  MOV {}, {}", destination, source);
     }
 
+    /// Emits a conditional `mov` instruction.
+    pub(crate) fn conditional_mov_instruction(
+        &self,
+        destination: MemoryAddress,
+        condition: MemoryAddress,
+        source_a: MemoryAddress,
+        source_b: MemoryAddress,
+    ) {
+        debug_println!(
+            self.enable_debug_trace,
+            "  CMOV {} = {}? {} : {}",
+            destination,
+            condition,
+            source_a,
+            source_b
+        );
+    }
+
     /// Emits a `cast` instruction.
     pub(crate) fn cast_instruction(
         &self,
diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
index 5c2a6bfacca..99fb4c89f64 100644
--- a/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
+++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/instructions.rs
@@ -359,6 +359,25 @@ impl BrilligContext {
         self.push_opcode(BrilligOpcode::Mov { destination, source });
     }
 
+    /// Emits a conditional `mov` instruction.
+    ///
+    /// Copies the value at `source` into `destination`
+    pub(crate) fn conditional_mov_instruction(
+        &mut self,
+        destination: MemoryAddress,
+        condition: MemoryAddress,
+        source_a: MemoryAddress,
+        source_b: MemoryAddress,
+    ) {
+        self.debug_show.conditional_mov_instruction(destination, condition, source_a, source_b);
+        self.push_opcode(BrilligOpcode::ConditionalMov {
+            destination,
+            source_a,
+            source_b,
+            condition,
+        });
+    }
+
     /// Cast truncates the value to the given bit size and converts the type of the value in memory to that bit size.
     pub(crate) fn cast_instruction(
         &mut self,
diff --git a/compiler/noirc_evaluator/src/errors.rs b/compiler/noirc_evaluator/src/errors.rs
index 06259e06248..b3e838e708e 100644
--- a/compiler/noirc_evaluator/src/errors.rs
+++ b/compiler/noirc_evaluator/src/errors.rs
@@ -140,8 +140,8 @@ impl RuntimeError {
             | RuntimeError::UnsupportedIntegerSize { call_stack, .. }
             | RuntimeError::NestedSlice { call_stack, .. }
             | RuntimeError::BigIntModulus { call_stack, .. }
-            | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack } => call_stack,
-            RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
+            | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack }
+            | RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 5adb9eb5b7e..fcb20c740c7 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -577,7 +577,12 @@ impl<'a> ModCollector<'a> {
         let mut ast = ast.into_sorted();
 
         for macro_processor in macro_processors {
-            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, context) {
+            match macro_processor.process_untyped_ast(
+                ast.clone(),
+                &crate_id,
+                child_file_id,
+                context,
+            ) {
                 Ok(processed_ast) => {
                     ast = processed_ast;
                 }
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 1326ffca9f7..157227f763e 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -91,7 +91,8 @@ impl CrateDefMap {
         let mut ast = ast.into_sorted();
 
         for macro_processor in macro_processors {
-            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, context) {
+            match macro_processor.process_untyped_ast(ast.clone(), &crate_id, root_file_id, context)
+            {
                 Ok(processed_ast) => {
                     ast = processed_ast;
                 }
diff --git a/compiler/noirc_frontend/src/hir/type_check/errors.rs b/compiler/noirc_frontend/src/hir/type_check/errors.rs
index 4e2a3a8b4a2..642cebc83b0 100644
--- a/compiler/noirc_frontend/src/hir/type_check/errors.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/errors.rs
@@ -235,9 +235,9 @@ impl From<TypeCheckError> for Diagnostic {
             | TypeCheckError::OverflowingAssignment { span, .. }
             | TypeCheckError::FieldModulo { span }
             | TypeCheckError::ConstrainedReferenceToUnconstrained { span }
-            | TypeCheckError::NonConstantSliceLength { span }
             | TypeCheckError::UnconstrainedReferenceToConstrained { span }
-            | TypeCheckError::UnconstrainedSliceReturnToConstrained { span } => {
+            | TypeCheckError::UnconstrainedSliceReturnToConstrained { span }
+            | TypeCheckError::NonConstantSliceLength { span } => {
                 Diagnostic::simple_error(error.to_string(), String::new(), span)
             }
             TypeCheckError::PublicReturnType { typ, span } => Diagnostic::simple_error(
diff --git a/compiler/noirc_frontend/src/hir/type_check/expr.rs b/compiler/noirc_frontend/src/hir/type_check/expr.rs
index 6ee0460784f..10476b6caef 100644
--- a/compiler/noirc_frontend/src/hir/type_check/expr.rs
+++ b/compiler/noirc_frontend/src/hir/type_check/expr.rs
@@ -217,7 +217,7 @@ impl<'interner> TypeChecker<'interner> {
                         });
                         return Type::Error;
                     }
-                }
+                };
 
                 return_type
             }
diff --git a/compiler/noirc_frontend/src/lib.rs b/compiler/noirc_frontend/src/lib.rs
index 1871b594ae7..6ce6f4325e4 100644
--- a/compiler/noirc_frontend/src/lib.rs
+++ b/compiler/noirc_frontend/src/lib.rs
@@ -72,6 +72,7 @@ pub mod macros_api {
             &self,
             ast: SortedModule,
             crate_id: &CrateId,
+            file_id: FileId,
             context: &HirContext,
         ) -> Result<SortedModule, (MacroError, FileId)>;
 
diff --git a/test_programs/compile_failure/unconstrained_oracle/Nargo.toml b/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
index 1081b5ab8e2..7c3fb8766bf 100644
--- a/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
+++ b/test_programs/compile_failure/unconstrained_oracle/Nargo.toml
@@ -2,4 +2,6 @@
 name = "unconstrained_oracle"
 type = "bin"
 authors = [""]
+compiler_version = ">=0.25.0"
+
 [dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/unconstrained_ref/Nargo.toml b/test_programs/compile_failure/unconstrained_ref/Nargo.toml
index b120a3b5532..c03aaea5fca 100644
--- a/test_programs/compile_failure/unconstrained_ref/Nargo.toml
+++ b/test_programs/compile_failure/unconstrained_ref/Nargo.toml
@@ -2,4 +2,6 @@
 name = "unconstrained_ref"
 type = "bin"
 authors = [""]
+compiler_version = ">=0.25.0"
+
 [dependencies]
\ No newline at end of file
diff --git a/test_programs/compile_failure/unconstrained_ref/src/main.nr b/test_programs/compile_failure/unconstrained_ref/src/main.nr
index bb4b2090ddb..1491badaa49 100644
--- a/test_programs/compile_failure/unconstrained_ref/src/main.nr
+++ b/test_programs/compile_failure/unconstrained_ref/src/main.nr
@@ -5,4 +5,4 @@ unconstrained fn uncon_ref() -> &mut Field {
 
 fn main() {
     let e = uncon_ref();
-}
\ No newline at end of file
+}
diff --git a/test_programs/execution_success/witness_compression/Nargo.toml b/test_programs/execution_success/witness_compression/Nargo.toml
new file mode 100644
index 00000000000..7d6ba0c1938
--- /dev/null
+++ b/test_programs/execution_success/witness_compression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "witness_compression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.24.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/test_programs/execution_success/witness_compression/Prover.toml b/test_programs/execution_success/witness_compression/Prover.toml
new file mode 100644
index 00000000000..8c12ebba6cf
--- /dev/null
+++ b/test_programs/execution_success/witness_compression/Prover.toml
@@ -0,0 +1,2 @@
+x = "1"
+y = "2"
diff --git a/test_programs/execution_success/witness_compression/src/main.nr b/test_programs/execution_success/witness_compression/src/main.nr
new file mode 100644
index 00000000000..3027d35b13a
--- /dev/null
+++ b/test_programs/execution_success/witness_compression/src/main.nr
@@ -0,0 +1,7 @@
+// This test should be used to regenerate the serialized witness used in the `acvm_js` integration tests.
+// The `acvm_js` test file containing the serialized witness should be also called `witness_compression`.
+// After recompiling Noir, you can manually print the witness byte array to be written to file after execution.
+fn main(x: Field, y: pub Field) -> pub Field {
+    assert(x != y);
+    x + y
+}
diff --git a/tooling/acvm_cli/src/cli/execute_cmd.rs b/tooling/acvm_cli/src/cli/execute_cmd.rs
index 255b6131fd6..b76d0eccc29 100644
--- a/tooling/acvm_cli/src/cli/execute_cmd.rs
+++ b/tooling/acvm_cli/src/cli/execute_cmd.rs
@@ -1,6 +1,6 @@
 use std::io::{self, Write};
 
-use acir::circuit::Circuit;
+use acir::circuit::Program;
 use acir::native_types::WitnessMap;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
@@ -66,10 +66,10 @@ pub(crate) fn execute_program_from_witness(
     foreign_call_resolver_url: Option<&str>,
 ) -> Result<WitnessMap, CliError> {
     let blackbox_solver = Bn254BlackBoxSolver::new();
-    let circuit: Circuit = Circuit::deserialize_circuit(bytecode)
+    let program: Program = Program::deserialize_program(bytecode)
         .map_err(|_| CliError::CircuitDeserializationError())?;
     execute_circuit(
-        &circuit,
+        &program.functions[0],
         inputs_map.clone(),
         &blackbox_solver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
diff --git a/tooling/acvm_cli/src/errors.rs b/tooling/acvm_cli/src/errors.rs
index 035388d05f7..923046410ea 100644
--- a/tooling/acvm_cli/src/errors.rs
+++ b/tooling/acvm_cli/src/errors.rs
@@ -32,7 +32,7 @@ pub(crate) enum CliError {
     FilesystemError(#[from] FilesystemError),
 
     /// Error related to circuit deserialization
-    #[error("Error: failed to deserialize circuit")]
+    #[error("Error: failed to deserialize circuit in ACVM CLI")]
     CircuitDeserializationError(),
 
     /// Error related to circuit execution
diff --git a/tooling/backend_interface/src/proof_system.rs b/tooling/backend_interface/src/proof_system.rs
index 485381006df..105ae337793 100644
--- a/tooling/backend_interface/src/proof_system.rs
+++ b/tooling/backend_interface/src/proof_system.rs
@@ -3,8 +3,8 @@ use std::io::Write;
 use std::path::Path;
 
 use acvm::acir::{
-    circuit::{Circuit, ExpressionWidth},
-    native_types::WitnessMap,
+    circuit::{ExpressionWidth, Program},
+    native_types::{WitnessMap, WitnessStack},
 };
 use acvm::FieldElement;
 use tempfile::tempdir;
@@ -17,7 +17,7 @@ use crate::cli::{
 use crate::{Backend, BackendError};
 
 impl Backend {
-    pub fn get_exact_circuit_size(&self, circuit: &Circuit) -> Result<u32, BackendError> {
+    pub fn get_exact_circuit_size(&self, program: &Program) -> Result<u32, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
 
@@ -26,8 +26,8 @@ impl Backend {
 
         // Create a temporary file for the circuit
         let circuit_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &circuit_path);
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &circuit_path);
 
         GatesCommand { crs_path: self.crs_directory(), bytecode_path: circuit_path }
             .run(binary_path)
@@ -55,8 +55,8 @@ impl Backend {
     #[tracing::instrument(level = "trace", skip_all)]
     pub fn prove(
         &self,
-        circuit: &Circuit,
-        witness_values: WitnessMap,
+        program: &Program,
+        witness_values: WitnessStack,
     ) -> Result<Vec<u8>, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
@@ -72,9 +72,9 @@ impl Backend {
 
         // Create a temporary file for the circuit
         //
-        let bytecode_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create proof and store it in the specified path
         let proof_with_public_inputs =
@@ -82,7 +82,8 @@ impl Backend {
                 .run(binary_path)?;
 
         let proof = bb_abstraction_leaks::remove_public_inputs(
-            circuit.public_inputs().0.len(),
+            // TODO(https://github.com/noir-lang/noir/issues/4428)
+            program.functions[0].public_inputs().0.len(),
             &proof_with_public_inputs,
         );
         Ok(proof)
@@ -93,7 +94,7 @@ impl Backend {
         &self,
         proof: &[u8],
         public_inputs: WitnessMap,
-        circuit: &Circuit,
+        program: &Program,
     ) -> Result<bool, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
@@ -108,9 +109,9 @@ impl Backend {
         write_to_file(&proof_with_public_inputs, &proof_path);
 
         // Create a temporary file for the circuit
-        let bytecode_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create the verification key and write it to the specified path
         let vk_path = temp_directory.join("vk");
@@ -128,7 +129,7 @@ impl Backend {
 
     pub fn get_intermediate_proof_artifacts(
         &self,
-        circuit: &Circuit,
+        program: &Program,
         proof: &[u8],
         public_inputs: WitnessMap,
     ) -> Result<(Vec<FieldElement>, FieldElement, Vec<FieldElement>), BackendError> {
@@ -140,9 +141,9 @@ impl Backend {
 
         // Create a temporary file for the circuit
         //
-        let bytecode_path = temp_directory.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create the verification key and write it to the specified path
         let vk_path = temp_directory.join("vk");
diff --git a/tooling/backend_interface/src/smart_contract.rs b/tooling/backend_interface/src/smart_contract.rs
index 5af75e48389..f6beeeb09d9 100644
--- a/tooling/backend_interface/src/smart_contract.rs
+++ b/tooling/backend_interface/src/smart_contract.rs
@@ -3,11 +3,11 @@ use crate::{
     cli::{ContractCommand, WriteVkCommand},
     Backend, BackendError,
 };
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use tempfile::tempdir;
 
 impl Backend {
-    pub fn eth_contract(&self, circuit: &Circuit) -> Result<String, BackendError> {
+    pub fn eth_contract(&self, program: &Program) -> Result<String, BackendError> {
         let binary_path = self.assert_binary_exists()?;
         self.assert_correct_version()?;
 
@@ -15,9 +15,9 @@ impl Backend {
         let temp_directory_path = temp_directory.path().to_path_buf();
 
         // Create a temporary file for the circuit
-        let bytecode_path = temp_directory_path.join("circuit").with_extension("bytecode");
-        let serialized_circuit = Circuit::serialize_circuit(circuit);
-        write_to_file(&serialized_circuit, &bytecode_path);
+        let bytecode_path = temp_directory_path.join("program").with_extension("bytecode");
+        let serialized_program = Program::serialize_program(program);
+        write_to_file(&serialized_program, &bytecode_path);
 
         // Create the verification key and write it to the specified path
         let vk_path = temp_directory_path.join("vk");
@@ -38,7 +38,7 @@ mod tests {
     use std::collections::BTreeSet;
 
     use acvm::acir::{
-        circuit::{Circuit, ExpressionWidth, Opcode, PublicInputs},
+        circuit::{Circuit, ExpressionWidth, Opcode, Program, PublicInputs},
         native_types::{Expression, Witness},
     };
 
@@ -59,8 +59,9 @@ mod tests {
             assert_messages: Default::default(),
             recursive: false,
         };
+        let program = Program { functions: vec![circuit] };
 
-        let contract = get_mock_backend()?.eth_contract(&circuit)?;
+        let contract = get_mock_backend()?.eth_contract(&program)?;
 
         assert!(contract.contains("contract VerifierContract"));
 
diff --git a/tooling/bb_abstraction_leaks/build.rs b/tooling/bb_abstraction_leaks/build.rs
index 2eae9e1f07e..362d2132952 100644
--- a/tooling/bb_abstraction_leaks/build.rs
+++ b/tooling/bb_abstraction_leaks/build.rs
@@ -10,7 +10,7 @@ use const_format::formatcp;
 
 const USERNAME: &str = "AztecProtocol";
 const REPO: &str = "aztec-packages";
-const VERSION: &str = "0.29.0";
+const VERSION: &str = "0.30.1";
 const TAG: &str = formatcp!("aztec-packages-v{}", VERSION);
 
 const API_URL: &str =
diff --git a/tooling/debugger/src/dap.rs b/tooling/debugger/src/dap.rs
index 7c722ed0a61..ea3204ebbbc 100644
--- a/tooling/debugger/src/dap.rs
+++ b/tooling/debugger/src/dap.rs
@@ -607,8 +607,13 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver>(
         file_map: program.file_map,
         warnings: program.warnings,
     };
-    let mut session =
-        DapSession::new(server, solver, &program.circuit, &debug_artifact, initial_witness);
+    let mut session = DapSession::new(
+        server,
+        solver,
+        &program.program.functions[0],
+        &debug_artifact,
+        initial_witness,
+    );
 
     session.run_loop()
 }
diff --git a/tooling/nargo/src/artifacts/contract.rs b/tooling/nargo/src/artifacts/contract.rs
index 020ce49662f..c0316a6d1a2 100644
--- a/tooling/nargo/src/artifacts/contract.rs
+++ b/tooling/nargo/src/artifacts/contract.rs
@@ -1,4 +1,4 @@
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use noirc_abi::{Abi, ContractEvent};
 use noirc_driver::{CompiledContract, ContractFunction};
 use serde::{Deserialize, Serialize};
@@ -50,10 +50,10 @@ pub struct ContractFunctionArtifact {
     pub abi: Abi,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Circuit,
+    pub bytecode: Program,
 
     #[serde(
         serialize_with = "DebugInfo::serialize_compressed_base64_json",
diff --git a/tooling/nargo/src/artifacts/program.rs b/tooling/nargo/src/artifacts/program.rs
index d8dc42ec214..046db1cd8fa 100644
--- a/tooling/nargo/src/artifacts/program.rs
+++ b/tooling/nargo/src/artifacts/program.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use fm::FileId;
 use noirc_abi::Abi;
 use noirc_driver::CompiledProgram;
@@ -21,10 +21,10 @@ pub struct ProgramArtifact {
     pub abi: Abi,
 
     #[serde(
-        serialize_with = "Circuit::serialize_circuit_base64",
-        deserialize_with = "Circuit::deserialize_circuit_base64"
+        serialize_with = "Program::serialize_program_base64",
+        deserialize_with = "Program::deserialize_program_base64"
     )]
-    pub bytecode: Circuit,
+    pub bytecode: Program,
 
     #[serde(
         serialize_with = "DebugInfo::serialize_compressed_base64_json",
@@ -37,14 +37,14 @@ pub struct ProgramArtifact {
 }
 
 impl From<CompiledProgram> for ProgramArtifact {
-    fn from(program: CompiledProgram) -> Self {
+    fn from(compiled_program: CompiledProgram) -> Self {
         ProgramArtifact {
-            hash: program.hash,
-            abi: program.abi,
-            noir_version: program.noir_version,
-            bytecode: program.circuit,
-            debug_symbols: program.debug,
-            file_map: program.file_map,
+            hash: compiled_program.hash,
+            abi: compiled_program.abi,
+            noir_version: compiled_program.noir_version,
+            bytecode: compiled_program.program,
+            debug_symbols: compiled_program.debug,
+            file_map: compiled_program.file_map,
         }
     }
 }
@@ -55,7 +55,7 @@ impl From<ProgramArtifact> for CompiledProgram {
             hash: program.hash,
             abi: program.abi,
             noir_version: program.noir_version,
-            circuit: program.bytecode,
+            program: program.bytecode,
             debug: program.debug_symbols,
             file_map: program.file_map,
             warnings: vec![],
diff --git a/tooling/nargo/src/ops/optimize.rs b/tooling/nargo/src/ops/optimize.rs
index 2d0c4c43d25..cfaaf27ea98 100644
--- a/tooling/nargo/src/ops/optimize.rs
+++ b/tooling/nargo/src/ops/optimize.rs
@@ -1,17 +1,22 @@
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 
-pub fn optimize_program(mut program: CompiledProgram) -> CompiledProgram {
-    let (optimized_circuit, location_map) = acvm::compiler::optimize(program.circuit);
-    program.circuit = optimized_circuit;
-    program.debug.update_acir(location_map);
-    program
+/// TODO(https://github.com/noir-lang/noir/issues/4428): Need to update how these passes are run to account for
+/// multiple ACIR functions
+
+pub fn optimize_program(mut compiled_program: CompiledProgram) -> CompiledProgram {
+    let (optimized_circuit, location_map) =
+        acvm::compiler::optimize(std::mem::take(&mut compiled_program.program.functions[0]));
+    compiled_program.program.functions[0] = optimized_circuit;
+    compiled_program.debug.update_acir(location_map);
+    compiled_program
 }
 
 pub fn optimize_contract(contract: CompiledContract) -> CompiledContract {
     let functions = vecmap(contract.functions, |mut func| {
-        let (optimized_bytecode, location_map) = acvm::compiler::optimize(func.bytecode);
-        func.bytecode = optimized_bytecode;
+        let (optimized_bytecode, location_map) =
+            acvm::compiler::optimize(std::mem::take(&mut func.bytecode.functions[0]));
+        func.bytecode.functions[0] = optimized_bytecode;
         func.debug.update_acir(location_map);
         func
     });
diff --git a/tooling/nargo/src/ops/test.rs b/tooling/nargo/src/ops/test.rs
index 8ddcb5cf8d2..8cf2934da4d 100644
--- a/tooling/nargo/src/ops/test.rs
+++ b/tooling/nargo/src/ops/test.rs
@@ -28,18 +28,23 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
     foreign_call_resolver_url: Option<&str>,
     config: &CompileOptions,
 ) -> TestStatus {
-    let program = compile_no_check(context, config, test_function.get_id(), None, false);
-    match program {
-        Ok(program) => {
+    let compiled_program = compile_no_check(context, config, test_function.get_id(), None, false);
+    match compiled_program {
+        Ok(compiled_program) => {
             // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen,
             // otherwise constraints involving these expressions will not error.
             let circuit_execution = execute_circuit(
-                &program.circuit,
+                // TODO(https://github.com/noir-lang/noir/issues/4428)
+                &compiled_program.program.functions[0],
                 WitnessMap::new(),
                 blackbox_solver,
                 &mut DefaultForeignCallExecutor::new(show_output, foreign_call_resolver_url),
             );
-            test_status_program_compile_pass(test_function, program.debug, circuit_execution)
+            test_status_program_compile_pass(
+                test_function,
+                compiled_program.debug,
+                circuit_execution,
+            )
         }
         Err(err) => test_status_program_compile_fail(err, test_function),
     }
diff --git a/tooling/nargo/src/ops/transform.rs b/tooling/nargo/src/ops/transform.rs
index 9267ed7e045..274286a46e4 100644
--- a/tooling/nargo/src/ops/transform.rs
+++ b/tooling/nargo/src/ops/transform.rs
@@ -2,16 +2,21 @@ use acvm::acir::circuit::ExpressionWidth;
 use iter_extended::vecmap;
 use noirc_driver::{CompiledContract, CompiledProgram};
 
+/// TODO(https://github.com/noir-lang/noir/issues/4428): Need to update how these passes are run to account for
+/// multiple ACIR functions
+
 pub fn transform_program(
-    mut program: CompiledProgram,
+    mut compiled_program: CompiledProgram,
     expression_width: ExpressionWidth,
 ) -> CompiledProgram {
-    let (optimized_circuit, location_map) =
-        acvm::compiler::compile(program.circuit, expression_width);
+    let (optimized_circuit, location_map) = acvm::compiler::compile(
+        std::mem::take(&mut compiled_program.program.functions[0]),
+        expression_width,
+    );
 
-    program.circuit = optimized_circuit;
-    program.debug.update_acir(location_map);
-    program
+    compiled_program.program.functions[0] = optimized_circuit;
+    compiled_program.debug.update_acir(location_map);
+    compiled_program
 }
 
 pub fn transform_contract(
@@ -19,9 +24,11 @@ pub fn transform_contract(
     expression_width: ExpressionWidth,
 ) -> CompiledContract {
     let functions = vecmap(contract.functions, |mut func| {
-        let (optimized_bytecode, location_map) =
-            acvm::compiler::compile(func.bytecode, expression_width);
-        func.bytecode = optimized_bytecode;
+        let (optimized_bytecode, location_map) = acvm::compiler::compile(
+            std::mem::take(&mut func.bytecode.functions[0]),
+            expression_width,
+        );
+        func.bytecode.functions[0] = optimized_bytecode;
         func.debug.update_acir(location_map);
         func
     });
diff --git a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
index f0fe2e0ea78..259e209b65a 100644
--- a/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
+++ b/tooling/nargo_cli/src/cli/codegen_verifier_cmd.rs
@@ -64,7 +64,13 @@ pub(crate) fn run(
 
         let program = nargo::ops::transform_program(program, expression_width);
 
-        let smart_contract_string = backend.eth_contract(&program.circuit)?;
+        // TODO(https://github.com/noir-lang/noir/issues/4428):
+        // We do not expect to have a smart contract verifier for a foldable program with multiple circuits.
+        // However, in the future we can expect to possibly have non-inlined ACIR functions during compilation
+        // that will be inlined at a later step such as by the ACVM compiler or by the backend.
+        // Add appropriate handling here once the compiler enables multiple ACIR functions.
+        assert_eq!(program.program.functions.len(), 1);
+        let smart_contract_string = backend.eth_contract(&program.program)?;
 
         let contract_dir = workspace.contracts_directory_path(package);
         create_named_dir(&contract_dir, "contract");
diff --git a/tooling/nargo_cli/src/cli/compile_cmd.rs b/tooling/nargo_cli/src/cli/compile_cmd.rs
index 9b7bf9cdb0c..54e8535f094 100644
--- a/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -214,10 +214,10 @@ pub(super) fn save_program(
     circuit_dir: &Path,
     only_acir_opt: bool,
 ) {
-    let program_artifact = ProgramArtifact::from(program.clone());
     if only_acir_opt {
-        only_acir(&program_artifact, circuit_dir);
+        only_acir(program.program, circuit_dir);
     } else {
+        let program_artifact = ProgramArtifact::from(program.clone());
         save_program_to_file(&program_artifact, &package.name, circuit_dir);
     }
 }
diff --git a/tooling/nargo_cli/src/cli/debug_cmd.rs b/tooling/nargo_cli/src/cli/debug_cmd.rs
index 2c4937b6f16..1f448105ee2 100644
--- a/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -235,7 +235,7 @@ pub(crate) fn debug_program(
 
     noir_debugger::debug_circuit(
         &blackbox_solver,
-        &compiled_program.circuit,
+        &compiled_program.program.functions[0],
         debug_artifact,
         initial_witness,
     )
diff --git a/tooling/nargo_cli/src/cli/execute_cmd.rs b/tooling/nargo_cli/src/cli/execute_cmd.rs
index 1be2fbf61d9..022bf7b761e 100644
--- a/tooling/nargo_cli/src/cli/execute_cmd.rs
+++ b/tooling/nargo_cli/src/cli/execute_cmd.rs
@@ -136,8 +136,9 @@ pub(crate) fn execute_program(
 
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
+    // TODO(https://github.com/noir-lang/noir/issues/4428)
     let solved_witness_err = nargo::ops::execute_circuit(
-        &compiled_program.circuit,
+        &compiled_program.program.functions[0],
         initial_witness,
         &blackbox_solver,
         &mut DefaultForeignCallExecutor::new(true, foreign_call_resolver_url),
diff --git a/tooling/nargo_cli/src/cli/fs/program.rs b/tooling/nargo_cli/src/cli/fs/program.rs
index 1fb57ae6685..77005e8d5af 100644
--- a/tooling/nargo_cli/src/cli/fs/program.rs
+++ b/tooling/nargo_cli/src/cli/fs/program.rs
@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::circuit::Circuit;
+use acvm::acir::circuit::Program;
 use nargo::artifacts::{contract::ContractArtifact, program::ProgramArtifact};
 use noirc_frontend::graph::CrateName;
 
@@ -18,13 +18,10 @@ pub(crate) fn save_program_to_file<P: AsRef<Path>>(
 }
 
 /// Writes the bytecode as acir.gz
-pub(crate) fn only_acir<P: AsRef<Path>>(
-    program_artifact: &ProgramArtifact,
-    circuit_dir: P,
-) -> PathBuf {
+pub(crate) fn only_acir<P: AsRef<Path>>(program: Program, circuit_dir: P) -> PathBuf {
     create_named_dir(circuit_dir.as_ref(), "target");
     let circuit_path = circuit_dir.as_ref().join("acir").with_extension("gz");
-    let bytes = Circuit::serialize_circuit(&program_artifact.bytecode);
+    let bytes = Program::serialize_program(&program);
     write_to_file(&bytes, &circuit_path);
 
     circuit_path
diff --git a/tooling/nargo_cli/src/cli/fs/witness.rs b/tooling/nargo_cli/src/cli/fs/witness.rs
index 1a2cf88f4a1..52b5c385e5d 100644
--- a/tooling/nargo_cli/src/cli/fs/witness.rs
+++ b/tooling/nargo_cli/src/cli/fs/witness.rs
@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use acvm::acir::native_types::WitnessMap;
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use nargo::constants::WITNESS_EXT;
 
 use super::{create_named_dir, write_to_file};
@@ -14,7 +14,9 @@ pub(crate) fn save_witness_to_dir<P: AsRef<Path>>(
     create_named_dir(witness_dir.as_ref(), "witness");
     let witness_path = witness_dir.as_ref().join(witness_name).with_extension(WITNESS_EXT);
 
-    let buf: Vec<u8> = witnesses.try_into()?;
+    // TODO(https://github.com/noir-lang/noir/issues/4428)
+    let witness_stack: WitnessStack = witnesses.into();
+    let buf: Vec<u8> = witness_stack.try_into()?;
 
     write_to_file(buf.as_slice(), &witness_path);
 
diff --git a/tooling/nargo_cli/src/cli/info_cmd.rs b/tooling/nargo_cli/src/cli/info_cmd.rs
index 391e8061a07..49924622392 100644
--- a/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -276,8 +276,9 @@ fn count_opcodes_and_gates_in_program(
     Ok(ProgramInfo {
         name: package.name.to_string(),
         expression_width,
-        acir_opcodes: compiled_program.circuit.opcodes.len(),
-        circuit_size: backend.get_exact_circuit_size(&compiled_program.circuit)?,
+        // TODO(https://github.com/noir-lang/noir/issues/4428)
+        acir_opcodes: compiled_program.program.functions[0].opcodes.len(),
+        circuit_size: backend.get_exact_circuit_size(&compiled_program.program)?,
     })
 }
 
@@ -292,7 +293,8 @@ fn count_opcodes_and_gates_in_contract(
         .map(|function| -> Result<_, BackendError> {
             Ok(FunctionInfo {
                 name: function.name,
-                acir_opcodes: function.bytecode.opcodes.len(),
+                // TODO(https://github.com/noir-lang/noir/issues/4428)
+                acir_opcodes: function.bytecode.functions[0].opcodes.len(),
                 circuit_size: backend.get_exact_circuit_size(&function.bytecode)?,
             })
         })
diff --git a/tooling/nargo_cli/src/cli/prove_cmd.rs b/tooling/nargo_cli/src/cli/prove_cmd.rs
index e413db0e5f3..272f2fa8e5d 100644
--- a/tooling/nargo_cli/src/cli/prove_cmd.rs
+++ b/tooling/nargo_cli/src/cli/prove_cmd.rs
@@ -1,3 +1,4 @@
+use acvm::acir::native_types::WitnessStack;
 use clap::Args;
 use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
 use nargo::ops::{compile_program, report_errors};
@@ -138,11 +139,11 @@ pub(crate) fn prove_package(
         Format::Toml,
     )?;
 
-    let proof = backend.prove(&compiled_program.circuit, solved_witness)?;
+    let proof = backend.prove(&compiled_program.program, WitnessStack::from(solved_witness))?;
 
     if check_proof {
         let public_inputs = public_abi.encode(&public_inputs, return_value)?;
-        let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.circuit)?;
+        let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.program)?;
 
         if !valid_proof {
             return Err(CliError::InvalidProof("".into()));
diff --git a/tooling/nargo_cli/src/cli/verify_cmd.rs b/tooling/nargo_cli/src/cli/verify_cmd.rs
index 3e23c9a3e9f..7202a179aae 100644
--- a/tooling/nargo_cli/src/cli/verify_cmd.rs
+++ b/tooling/nargo_cli/src/cli/verify_cmd.rs
@@ -102,7 +102,7 @@ fn verify_package(
 
     let proof = load_hex_data(&proof_path)?;
 
-    let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.circuit)?;
+    let valid_proof = backend.verify(&proof, public_inputs, &compiled_program.program)?;
 
     if valid_proof {
         Ok(())
diff --git a/tooling/nargo_cli/src/errors.rs b/tooling/nargo_cli/src/errors.rs
index c2996f53420..40fb7886405 100644
--- a/tooling/nargo_cli/src/errors.rs
+++ b/tooling/nargo_cli/src/errors.rs
@@ -1,4 +1,4 @@
-use acvm::acir::native_types::WitnessMapError;
+use acvm::acir::native_types::WitnessStackError;
 use hex::FromHexError;
 use nargo::{errors::CompileError, NargoError};
 use nargo_toml::ManifestError;
@@ -22,9 +22,9 @@ pub(crate) enum FilesystemError {
     #[error(transparent)]
     InputParserError(#[from] InputParserError),
 
-    /// WitnessMap serialization error
+    /// WitnessStack serialization error
     #[error(transparent)]
-    WitnessMapSerialization(#[from] WitnessMapError),
+    WitnessStackSerialization(#[from] WitnessStackError),
 
     #[error("Error: could not deserialize build program: {0}")]
     ProgramSerializationError(String),
diff --git a/tooling/noir_js_backend_barretenberg/package.json b/tooling/noir_js_backend_barretenberg/package.json
index 6223f8d2969..92b8460d1db 100644
--- a/tooling/noir_js_backend_barretenberg/package.json
+++ b/tooling/noir_js_backend_barretenberg/package.json
@@ -42,7 +42,7 @@
     "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.29.0",
+    "@aztec/bb.js": "0.30.1",
     "@noir-lang/types": "workspace:*",
     "fflate": "^0.8.0"
   },
diff --git a/tooling/noir_js_backend_barretenberg/src/index.ts b/tooling/noir_js_backend_barretenberg/src/index.ts
index af03743eb2f..bfdf1005a93 100644
--- a/tooling/noir_js_backend_barretenberg/src/index.ts
+++ b/tooling/noir_js_backend_barretenberg/src/index.ts
@@ -45,7 +45,6 @@ export class BarretenbergBackend implements Backend {
       }
       const { Barretenberg, RawBuffer, Crs } = await import('@aztec/bb.js');
       const api = await Barretenberg.new(this.options);
-
       const [_exact, _total, subgroupSize] = await api.acirGetCircuitSizes(this.acirUncompressedBytecode);
       const crs = await Crs.new(subgroupSize + 1);
       await api.commonInitSlabAllocator(subgroupSize);
diff --git a/yarn.lock b/yarn.lock
index ee120fbb18e..3932935167d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -221,9 +221,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@aztec/bb.js@npm:0.29.0":
-  version: 0.29.0
-  resolution: "@aztec/bb.js@npm:0.29.0"
+"@aztec/bb.js@npm:0.30.1":
+  version: 0.30.1
+  resolution: "@aztec/bb.js@npm:0.30.1"
   dependencies:
     comlink: ^4.4.1
     commander: ^10.0.1
@@ -231,7 +231,7 @@ __metadata:
     tslib: ^2.4.0
   bin:
     bb.js: dest/node/main.js
-  checksum: ae2bae0eed1a64f79f4694d0b02a51b87bb00ef1d9a331193dc9ace69a47819d93b923114e95e77b9b4d3de28c94bf5bdd1e839b0236979aaa0cfcda7a04fa97
+  checksum: 52d0acaaf0966aa969b863adeb688df5c1abe7c8a0595bc2dca8603a8649f11eb39071aacbdc05b19f320f022b98691a41cb18a601ad84e6d82955ae6f885106
   languageName: node
   linkType: hard
 
@@ -4396,7 +4396,7 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "@noir-lang/backend_barretenberg@workspace:tooling/noir_js_backend_barretenberg"
   dependencies:
-    "@aztec/bb.js": 0.29.0
+    "@aztec/bb.js": 0.30.1
     "@noir-lang/types": "workspace:*"
     "@types/node": ^20.6.2
     "@types/prettier": ^3