From eddeaf309df15ddbe7a4469a7f9eb16597ea5c06 Mon Sep 17 00:00:00 2001 From: thunkar Date: Fri, 19 Apr 2024 09:31:32 +0000 Subject: [PATCH 01/27] stronger note and storage struct detection --- noir/noir-repo/aztec_macros/src/lib.rs | 9 +++++---- .../aztec_macros/src/transforms/functions.rs | 19 +++++++++++-------- .../aztec_macros/src/transforms/storage.rs | 14 ++++++++------ 3 files changed, 24 insertions(+), 18 deletions(-) diff --git a/noir/noir-repo/aztec_macros/src/lib.rs b/noir/noir-repo/aztec_macros/src/lib.rs index dff3193a3272..048ccd866bcb 100644 --- a/noir/noir-repo/aztec_macros/src/lib.rs +++ b/noir/noir-repo/aztec_macros/src/lib.rs @@ -93,9 +93,10 @@ fn transform_module( // Check for a user defined storage struct let maybe_storage_struct_name = check_for_storage_definition(module)?; + let storage_defined = maybe_storage_struct_name.is_some(); - if let Some(storage_struct_name) = maybe_storage_struct_name { + if let Some(ref storage_struct_name) = maybe_storage_struct_name { if !check_for_storage_implementation(module, &storage_struct_name) { generate_storage_implementation(module, &storage_struct_name)?; } @@ -103,7 +104,7 @@ fn transform_module( // In case we got a contract importing other contracts for their interface, we // don't want to generate the storage layout for them if crate_id == context.root_crate_id() { - generate_storage_layout(module, storage_struct_name)?; + generate_storage_layout(module, storage_struct_name.clone())?; } } @@ -164,14 +165,14 @@ fn transform_module( transform_function( fn_type, func, - storage_defined, + maybe_storage_struct_name.clone(), is_initializer, insert_init_check, is_internal, )?; has_transformed_module = true; } else if storage_defined && func.def.is_unconstrained { - transform_unconstrained(func); + transform_unconstrained(func, maybe_storage_struct_name.clone().unwrap()); has_transformed_module = true; } } diff --git a/noir/noir-repo/aztec_macros/src/transforms/functions.rs b/noir/noir-repo/aztec_macros/src/transforms/functions.rs index 534d24289b7c..40734e3574cd 100644 --- a/noir/noir-repo/aztec_macros/src/transforms/functions.rs +++ b/noir/noir-repo/aztec_macros/src/transforms/functions.rs @@ -26,7 +26,7 @@ use crate::{ pub fn transform_function( ty: &str, func: &mut NoirFunction, - storage_defined: bool, + storage_struct_name: Option, is_initializer: bool, insert_init_check: bool, is_internal: bool, @@ -54,8 +54,8 @@ pub fn transform_function( } // Add access to the storage struct - if storage_defined { - let storage_def = abstract_storage(&ty.to_lowercase(), false); + if storage_struct_name.is_some() { + let storage_def = abstract_storage(storage_struct_name.unwrap(), &ty.to_lowercase(), false); func.def.body.statements.insert(0, storage_def); } @@ -206,8 +206,11 @@ pub fn export_fn_abi( /// ``` /// /// This will allow developers to access their contract' storage struct in unconstrained functions -pub fn transform_unconstrained(func: &mut NoirFunction) { - func.def.body.statements.insert(0, abstract_storage("Unconstrained", true)); +pub fn transform_unconstrained(func: &mut NoirFunction, storage_struct_name: String) { + func.def + .body + .statements + .insert(0, abstract_storage(storage_struct_name, "Unconstrained", true)); } /// Helper function that returns what the private context would look like in the ast @@ -572,7 +575,7 @@ fn abstract_return_values(func: &NoirFunction) -> Result>, /// unconstrained fn lol() { /// let storage = Storage::init(Context::none()); /// } -fn abstract_storage(typ: &str, unconstrained: bool) -> Statement { +fn abstract_storage(storage_struct_name: String, typ: &str, unconstrained: bool) -> Statement { let init_context_call = if unconstrained { call( variable_path(chained_dep!("aztec", "context", "Context", "none")), // Path @@ -588,8 +591,8 @@ fn abstract_storage(typ: &str, unconstrained: bool) -> Statement { assignment( "storage", // Assigned to call( - variable_path(chained_path!("Storage", "init")), // Path - vec![init_context_call], // args + variable_path(chained_path!(storage_struct_name.as_str(), "init")), // Path + vec![init_context_call], // args ), ) } diff --git a/noir/noir-repo/aztec_macros/src/transforms/storage.rs b/noir/noir-repo/aztec_macros/src/transforms/storage.rs index 9135be32443b..e9fa60e00ef6 100644 --- a/noir/noir-repo/aztec_macros/src/transforms/storage.rs +++ b/noir/noir-repo/aztec_macros/src/transforms/storage.rs @@ -214,11 +214,13 @@ fn get_serialized_length( secondary_message: Some("State storage variable must be generic".to_string()), })?; - let is_note = traits.iter().any(|&trait_id| { - let r#trait = interner.get_trait(trait_id); - r#trait.name.0.contents == "NoteInterface" - && !interner.lookup_all_trait_implementations(stored_in_state, trait_id).is_empty() - }); + let is_note = match stored_in_state { + Type::Struct(typ, _) => interner + .struct_attributes(&typ.borrow().id) + .iter() + .any(|attr| is_custom_attribute(attr, "aztec(note)")), + _ => false, + }; // Maps and (private) Notes always occupy a single slot. Someone could store a Note in PublicMutable for whatever reason though. if struct_name == "Map" || (is_note && struct_name != "PublicMutable") { @@ -504,7 +506,7 @@ pub fn generate_storage_layout( let (struct_ast, errors) = parse_program(&storage_fields_source); if !errors.is_empty() { dbg!(errors); - return Err(AztecMacroError::CouldNotImplementNoteInterface { + return Err(AztecMacroError::CouldNotExportStorageLayout { secondary_message: Some("Failed to parse Noir macro code (struct StorageLayout). This is either a bug in the compiler or the Noir macro code".to_string()), span: None }); From 86eb0c5b1cbcec35ecebb4ce1dcf15c67b988748 Mon Sep 17 00:00:00 2001 From: thunkar Date: Wed, 24 Apr 2024 11:21:02 +0000 Subject: [PATCH 02/27] initial attempt --- barretenberg/cpp/src/CMakeLists.txt | 1 + .../cpp/src/barretenberg/dsl/CMakeLists.txt | 1 + .../dsl/acir_format/acir_format.cpp | 5 + .../dsl/acir_format/acir_format.hpp | 3 + .../dsl/acir_format/aes128_constraint.cpp | 63 +++++++ .../dsl/acir_format/aes128_constraint.hpp | 32 ++++ .../dsl/acir_format/serde/acir.hpp | 164 +++++++++++++++++- .../stdlib/encryption/aes128/aes128.cpp | 4 +- .../stdlib/encryption/aes128/aes128.hpp | 4 +- noir/noir-repo/Cargo.lock | 7 + .../acir/src/circuit/black_box_functions.rs | 4 + .../opcodes/black_box_function_call.rs | 13 +- .../acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 33 ++++ .../acvm-repo/acvm/src/pwg/blackbox/mod.rs | 8 +- .../acvm/src/pwg/blackbox/signature/ecdsa.rs | 10 +- .../acvm/src/pwg/blackbox/signature/mod.rs | 34 ---- .../src/pwg/blackbox/signature/schnorr.rs | 6 +- .../acvm-repo/acvm/src/pwg/blackbox/utils.rs | 33 ++++ .../src/curve_specific_solver.rs | 16 ++ .../bn254_blackbox_solver/Cargo.toml | 1 + .../bn254_blackbox_solver/src/aes.rs | 0 .../bn254_blackbox_solver/src/lib.rs | 13 ++ .../brillig/brillig_gen/brillig_black_box.rs | 1 + .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 20 +++ .../ssa/acir_gen/acir_ir/generated_acir.rs | 18 +- .../src/ssa/ir/instruction/call.rs | 1 + noir/noir-repo/noir_stdlib/src/aes128.nr | 5 + noir/noir-repo/noir_stdlib/src/lib.nr | 1 + .../aes128_encrypt/Nargo.toml | 7 + .../aes128_encrypt/Prover.toml | 5 + .../aes128_encrypt/src/main.nr | 35 ++++ noir/noir-repo/tooling/lsp/src/solver.rs | 10 ++ 32 files changed, 509 insertions(+), 49 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp create mode 100644 barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp create mode 100644 noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs create mode 100644 noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/utils.rs create mode 100644 noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/aes.rs create mode 100644 noir/noir-repo/noir_stdlib/src/aes128.nr create mode 100644 noir/noir-repo/test_programs/execution_success/aes128_encrypt/Nargo.toml create mode 100644 noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml create mode 100644 noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr diff --git a/barretenberg/cpp/src/CMakeLists.txt b/barretenberg/cpp/src/CMakeLists.txt index 57f24f01fdfd..57926166e741 100644 --- a/barretenberg/cpp/src/CMakeLists.txt +++ b/barretenberg/cpp/src/CMakeLists.txt @@ -180,6 +180,7 @@ if(WASM) $ $ $ + $ $ $ $ diff --git a/barretenberg/cpp/src/barretenberg/dsl/CMakeLists.txt b/barretenberg/cpp/src/barretenberg/dsl/CMakeLists.txt index 9a62acd63560..158c5752774a 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/CMakeLists.txt +++ b/barretenberg/cpp/src/barretenberg/dsl/CMakeLists.txt @@ -2,6 +2,7 @@ barretenberg_module( dsl plonk stdlib_sha256 + stdlib_aes128 stdlib_keccak stdlib_poseidon2 crypto_merkle_tree diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp index 5ece3c031d48..9dd1a65b432e 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp @@ -31,6 +31,11 @@ void build_constraints(Builder& builder, AcirFormat const& constraint_system, bo builder.create_range_constraint(constraint.witness, constraint.num_bits, ""); } + // Add keccak constraints + for (const auto& constraint : constraint_system.aes128_constraints) { + create_aes128_constraints(builder, constraint); + } + // Add sha256 constraints for (const auto& constraint : constraint_system.sha256_constraints) { create_sha256_constraints(builder, constraint); diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp index ec82362e2d8b..196b2a3f4426 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp @@ -1,4 +1,5 @@ #pragma once +#include "aes128_constraint.hpp" #include "barretenberg/common/slab_allocator.hpp" #include "barretenberg/serialize/msgpack.hpp" #include "bigint_constraint.hpp" @@ -33,6 +34,7 @@ struct AcirFormat { std::vector public_inputs; + std::vector aes128_constraints; std::vector logic_constraints; std::vector range_constraints; std::vector sha256_constraints; @@ -67,6 +69,7 @@ struct AcirFormat { // For serialization, update with any new fields MSGPACK_FIELDS(varnum, public_inputs, + aes128_constraints, logic_constraints, range_constraints, sha256_constraints, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp new file mode 100644 index 000000000000..afb653eefb79 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -0,0 +1,63 @@ +#include "aes128_constraint.hpp" +#include "barretenberg/stdlib/encryption/aes128/aes128.hpp" +#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp" +#include "round.hpp" + +namespace acir_format { + +template void create_aes128_constraints(Builder& builder, const AES128Constraint& constraint) +{ + using byte_array_ct = bb::stdlib::byte_array; + using field_ct = bb::stdlib::field_t; + + // Create byte array struct + byte_array_ct input(&builder); + + std::array iv; + std::array key; + + for (const auto& witness_index_num_bits : constraint.inputs) { + auto witness_index = witness_index_num_bits.witness; + auto num_bits = witness_index_num_bits.num_bits; + + // TODO: Copied forom KeccakConstraint, is this really necessary? + auto num_bytes = round_to_nearest_byte(num_bits); + + field_ct element = field_ct::from_witness_index(&builder, witness_index); + byte_array_ct element_bytes(element, num_bytes); + + input.write(element_bytes); + } + + size_t i = 0; + for (const auto& witness_index_num_bits : constraint.iv) { + auto witness_index = witness_index_num_bits.witness; + field_ct element = field_ct::from_witness_index(&builder, witness_index); + iv[i] = element; + ++i; + } + i = 0; + for (const auto& witness_index_num_bits : constraint.key) { + auto witness_index = witness_index_num_bits.witness; + field_ct element = field_ct::from_witness_index(&builder, witness_index); + key[i] = element; + ++i; + } + + byte_array_ct output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc(input_arr, iv, key); + + // Convert byte array to vector of field_t + auto bytes = output_bytes.bytes(); + + for (size_t i = 0; i < bytes.size(); ++i) { + builder.assert_equal(bytes[i].normalize().witness_index, constraint.result[i]); + } +} + +template void create_aes128_constraints(UltraCircuitBuilder& builder, + const AES128Constraint& constraint); + +template void create_aes128_constraints(GoblinUltraCircuitBuilder& builder, + const AES128Constraint& constraint); + +} // namespace acir_format diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp new file mode 100644 index 000000000000..42cc7be9220f --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp @@ -0,0 +1,32 @@ +#pragma once +#include "barretenberg/dsl/types.hpp" +#include "barretenberg/serialize/msgpack.hpp" +#include +#include + +namespace acir_format { + +struct AES128Input { + uint32_t witness; + uint32_t num_bits; + + // For serialization, update with any new fields + MSGPACK_FIELDS(witness, num_bits); + friend bool operator==(AES128Input const& lhs, AES128Input const& rhs) = default; +}; + +struct AES128Constraint { + std::vector inputs; + std::vector outputs; + std::array iv; + std::array key; + uint32_t length; + + // For serialization, update with any new fields + MSGPACK_FIELDS(inputs, iv, key, length, outputs); + friend bool operator==(AES128Constraint const& lhs, AES128Constraint const& rhs) = default; +}; + +template void create_aes128_constraints(Builder& builder, const AES128Constraint& constraint); + +} // namespace acir_format diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp index 5fd065434679..31d44c221dd2 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp @@ -24,6 +24,18 @@ struct FunctionInput { struct BlackBoxFuncCall { + struct AES128Encrypt { + std::vector inputs; + std::array iv; + std::array key; + Program::FunctionInput length; + Program::Witness output; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + struct AND { Program::FunctionInput lhs; Program::FunctionInput rhs; @@ -266,7 +278,8 @@ struct BlackBoxFuncCall { static Sha256Compression bincodeDeserialize(std::vector); }; - std::variant bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + struct Sha256 { Program::HeapVector message; Program::HeapArray output; @@ -716,7 +741,8 @@ struct BlackBoxOp { static Sha256Compression bincodeDeserialize(std::vector); }; - std::variant::dese namespace Program { +inline bool operator==(const BlackBoxFuncCall::AES128Encrypt& lhs, const BlackBoxFuncCall::AES128Encrypt& rhs) +{ + if (!(lhs.inputs == rhs.inputs)) { + return false; + } + if (!(lhs.iv == rhs.iv)) { + return false; + } + if (!(lhs.key == rhs.key)) { + return false; + } + if (!(lhs.length == rhs.length)) { + return false; + } + if (!(lhs.output == rhs.output)) { + return false; + } + return true; +} + +inline std::vector BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const +{ + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); +} + +inline BlackBoxFuncCall::AES128Encrypt BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize(std::vector input) +{ + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::deserialize(deserializer); + if (deserializer.get_buffer_offset() < input.size()) { + throw_or_abort("Some input bytes were not read"); + } + return value; +} + +} // end of namespace Program + +template <> +template +void serde::Serializable::serialize( + const Program::BlackBoxFuncCall::AES128Encrypt& obj, Serializer& serializer) +{ + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.length, serializer); + serde::Serializable::serialize(obj.output, serializer); +} + +template <> +template +Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize( + Deserializer& deserializer) +{ + Program::BlackBoxFuncCall::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.length = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; +} + +namespace Program { + inline bool operator==(const BlackBoxFuncCall::AND& lhs, const BlackBoxFuncCall::AND& rhs) { if (!(lhs.lhs == rhs.lhs)) { @@ -3640,6 +3733,73 @@ Program::BlackBoxOp serde::Deserializable::deserialize(Dese namespace Program { +inline bool operator==(const BlackBoxOp::AES128Encrypt& lhs, const BlackBoxOp::AES128Encrypt& rhs) +{ + if (!(lhs.inputs == rhs.inputs)) { + return false; + } + if (!(lhs.iv == rhs.iv)) { + return false; + } + if (!(lhs.key == rhs.key)) { + return false; + } + if (!(lhs.length == rhs.length)) { + return false; + } + if (!(lhs.result == rhs.result)) { + return false; + } + return true; +} + +inline std::vector BlackBoxOp::AES128Encrypt::bincodeSerialize() const +{ + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); +} + +inline BlackBoxOp::AES128Encrypt BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector input) +{ + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::deserialize(deserializer); + if (deserializer.get_buffer_offset() < input.size()) { + throw_or_abort("Some input bytes were not read"); + } + return value; +} + +} // end of namespace Program + +template <> +template +void serde::Serializable::serialize(const Program::BlackBoxOp::AES128Encrypt& obj, + Serializer& serializer) +{ + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.length, serializer); + serde::Serializable::serialize(obj.result, serializer); +} + +template <> +template +Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize( + Deserializer& deserializer) +{ + Program::BlackBoxOp::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.length = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; +} + +namespace Program { + inline bool operator==(const BlackBoxOp::Sha256& lhs, const BlackBoxOp::Sha256& rhs) { if (!(lhs.message == rhs.message)) { diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp index 232e21c1cc3d..ce61c9b81eef 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp @@ -9,7 +9,7 @@ using namespace bb::crypto; -namespace bb::stdlib::aes128 { +namespace bb::stdlib { template using byte_pair = std::pair, field_t>; using namespace bb::plookup; @@ -301,4 +301,4 @@ std::vector> encrypt_buffer_cbc(const std::vector std::vector> encrypt_buffer_cbc(const std::vector>& input, const stdlib::field_t& iv, const stdlib::field_t& key); -} // namespace bb::stdlib::aes128 +} // namespace bb::stdlib diff --git a/noir/noir-repo/Cargo.lock b/noir/noir-repo/Cargo.lock index ee83f7f8ddf3..390046345ac8 100644 --- a/noir/noir-repo/Cargo.lock +++ b/noir/noir-repo/Cargo.lock @@ -622,6 +622,7 @@ dependencies = [ "hex", "js-sys", "lazy_static", + "libaes", "noir_grumpkin", "num-bigint", "pprof", @@ -2615,6 +2616,12 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" +[[package]] +name = "libaes" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82903360c009b816f5ab72a9b68158c27c301ee2c3f20655b55c5e589e7d3bb7" + [[package]] name = "libc" version = "0.2.151" diff --git a/noir/noir-repo/acvm-repo/acir/src/circuit/black_box_functions.rs b/noir/noir-repo/acvm-repo/acir/src/circuit/black_box_functions.rs index 0a7ee244a5ee..6cfb2a300d08 100644 --- a/noir/noir-repo/acvm-repo/acir/src/circuit/black_box_functions.rs +++ b/noir/noir-repo/acvm-repo/acir/src/circuit/black_box_functions.rs @@ -9,6 +9,8 @@ use strum_macros::EnumIter; #[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize)] #[cfg_attr(test, derive(EnumIter))] pub enum BlackBoxFunc { + /// Encrypts the input using AES128. + AES128Encrypt, /// Bitwise AND. AND, /// Bitwise XOR. @@ -74,6 +76,7 @@ impl std::fmt::Display for BlackBoxFunc { impl BlackBoxFunc { pub fn name(&self) -> &'static str { match self { + BlackBoxFunc::AES128Encrypt => "aes128_encrypt", BlackBoxFunc::SHA256 => "sha256", BlackBoxFunc::SchnorrVerify => "schnorr_verify", BlackBoxFunc::Blake2s => "blake2s", @@ -103,6 +106,7 @@ impl BlackBoxFunc { pub fn lookup(op_name: &str) -> Option { match op_name { + "aes128_encrypt" => Some(BlackBoxFunc::AES128Encrypt), "sha256" => Some(BlackBoxFunc::SHA256), "schnorr_verify" => Some(BlackBoxFunc::SchnorrVerify), "blake2s" => Some(BlackBoxFunc::Blake2s), diff --git a/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs index 405cd0cef007..161e8da5efd0 100644 --- a/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs +++ b/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs @@ -12,6 +12,12 @@ pub struct FunctionInput { #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum BlackBoxFuncCall { + AES128Encrypt { + inputs: Vec, + iv: Box<[FunctionInput; 16]>, + key: Box<[FunctionInput; 16]>, + outputs: Vec, + }, AND { lhs: FunctionInput, rhs: FunctionInput, @@ -177,6 +183,7 @@ pub enum BlackBoxFuncCall { impl BlackBoxFuncCall { pub fn get_black_box_func(&self) -> BlackBoxFunc { match self { + BlackBoxFuncCall::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt, BlackBoxFuncCall::AND { .. } => BlackBoxFunc::AND, BlackBoxFuncCall::XOR { .. } => BlackBoxFunc::XOR, BlackBoxFuncCall::RANGE { .. } => BlackBoxFunc::RANGE, @@ -210,7 +217,8 @@ impl BlackBoxFuncCall { pub fn get_inputs_vec(&self) -> Vec { match self { - BlackBoxFuncCall::SHA256 { inputs, .. } + BlackBoxFuncCall::AES128Encrypt { inputs, .. } + | BlackBoxFuncCall::SHA256 { inputs, .. } | BlackBoxFuncCall::Blake2s { inputs, .. } | BlackBoxFuncCall::Blake3 { inputs, .. } | BlackBoxFuncCall::PedersenCommitment { inputs, .. } @@ -320,7 +328,8 @@ impl BlackBoxFuncCall { BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(), - BlackBoxFuncCall::Poseidon2Permutation { outputs, .. } => outputs.to_vec(), + BlackBoxFuncCall::AES128Encrypt { outputs, .. } + | BlackBoxFuncCall::Poseidon2Permutation { outputs, .. } => outputs.to_vec(), BlackBoxFuncCall::AND { output, .. } | BlackBoxFuncCall::XOR { output, .. } diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs new file mode 100644 index 000000000000..63e1405ba1e4 --- /dev/null +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -0,0 +1,33 @@ +use acir::{ + circuit::opcodes::FunctionInput, + native_types::{Witness, WitnessMap}, + FieldElement, +}; +use acvm_blackbox_solver::BlackBoxFunctionSolver; + +use crate::{pwg::insert_value, OpcodeResolutionError}; + +use super::utils::{to_u8_array, to_u8_vec}; + +pub(super) fn aes128_encrypt( + backend: &impl BlackBoxFunctionSolver, + initial_witness: &mut WitnessMap, + inputs: &Vec, + iv: &[FunctionInput; 16], + key: &[FunctionInput; 16], + outputs: &[Witness], +) -> Result<(), OpcodeResolutionError> { + let scalars = to_u8_vec(initial_witness, inputs)?; + + let iv = to_u8_array(initial_witness, iv)?; + let key = to_u8_array(initial_witness, key)?; + + let cyphertext = backend.aes128_encrypt(&scalars, iv, key, scalars.len() as u32)?; + + // Write witness assignments + for (output_witness, value) in outputs.iter().zip(cyphertext.into_iter()) { + insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?; + } + + Ok(()) +} diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs index 2753c7baaaa9..f4671cd628e5 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs @@ -6,12 +6,14 @@ use acir::{ use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256}; use self::{ - bigint::AcvmBigIntSolver, hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash, + aes128::aes128_encrypt, bigint::AcvmBigIntSolver, hash::solve_poseidon2_permutation_opcode, + pedersen::pedersen_hash, }; use super::{insert_value, OpcodeNotSolvable, OpcodeResolutionError}; use crate::{pwg::witness_to_value, BlackBoxFunctionSolver}; +mod aes128; pub(crate) mod bigint; mod fixed_base_scalar_mul; mod hash; @@ -19,6 +21,7 @@ mod logic; mod pedersen; mod range; mod signature; +pub(crate) mod utils; use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul}; // Hash functions should eventually be exposed for external consumers. @@ -68,6 +71,9 @@ pub(crate) fn solve( } match bb_func { + BlackBoxFuncCall::AES128Encrypt { inputs, iv, key, outputs } => { + aes128_encrypt(backend, initial_witness, inputs, iv, key, outputs) + } BlackBoxFuncCall::AND { lhs, rhs, output } => and(initial_witness, lhs, rhs, output), BlackBoxFuncCall::XOR { lhs, rhs, output } => xor(initial_witness, lhs, rhs, output), BlackBoxFuncCall::RANGE { input } => solve_range_opcode(initial_witness, input), diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs index b113c8012512..ce2e57e0bd7f 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs @@ -5,9 +5,13 @@ use acir::{ }; use acvm_blackbox_solver::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify}; -use crate::{pwg::insert_value, OpcodeResolutionError}; - -use super::{to_u8_array, to_u8_vec}; +use crate::{ + pwg::{ + blackbox::utils::{to_u8_array, to_u8_vec}, + insert_value, + }, + OpcodeResolutionError, +}; pub(crate) fn secp256k1_prehashed( initial_witness: &mut WitnessMap, diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs index bd223ecd0c97..0cfb96740b86 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/mod.rs @@ -1,36 +1,2 @@ -use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap}; - -use crate::pwg::{witness_to_value, OpcodeResolutionError}; - -fn to_u8_array( - initial_witness: &WitnessMap, - inputs: &[FunctionInput; N], -) -> Result<[u8; N], OpcodeResolutionError> { - let mut result = [0; N]; - for (it, input) in result.iter_mut().zip(inputs) { - let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes(); - let byte = witness_value_bytes - .last() - .expect("Field element must be represented by non-zero amount of bytes"); - *it = *byte; - } - Ok(result) -} - -fn to_u8_vec( - initial_witness: &WitnessMap, - inputs: &[FunctionInput], -) -> Result, OpcodeResolutionError> { - let mut result = Vec::with_capacity(inputs.len()); - for input in inputs { - let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes(); - let byte = witness_value_bytes - .last() - .expect("Field element must be represented by non-zero amount of bytes"); - result.push(*byte); - } - Ok(result) -} - pub(super) mod ecdsa; pub(super) mod schnorr; diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs index 3d0216fa2173..7b085d9ff476 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/signature/schnorr.rs @@ -1,6 +1,8 @@ -use super::{to_u8_array, to_u8_vec}; use crate::{ - pwg::{insert_value, witness_to_value, OpcodeResolutionError}, + pwg::{ + blackbox::utils::{to_u8_array, to_u8_vec}, + insert_value, witness_to_value, OpcodeResolutionError, + }, BlackBoxFunctionSolver, }; use acir::{ diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/utils.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/utils.rs new file mode 100644 index 000000000000..700f30890aeb --- /dev/null +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/utils.rs @@ -0,0 +1,33 @@ +use acir::{circuit::opcodes::FunctionInput, native_types::WitnessMap}; + +use crate::pwg::{witness_to_value, OpcodeResolutionError}; + +pub(crate) fn to_u8_array( + initial_witness: &WitnessMap, + inputs: &[FunctionInput; N], +) -> Result<[u8; N], OpcodeResolutionError> { + let mut result = [0; N]; + for (it, input) in result.iter_mut().zip(inputs) { + let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes(); + let byte = witness_value_bytes + .last() + .expect("Field element must be represented by non-zero amount of bytes"); + *it = *byte; + } + Ok(result) +} + +pub(crate) fn to_u8_vec( + initial_witness: &WitnessMap, + inputs: &[FunctionInput], +) -> Result, OpcodeResolutionError> { + let mut result = Vec::with_capacity(inputs.len()); + for input in inputs { + let witness_value_bytes = witness_to_value(initial_witness, input.witness)?.to_be_bytes(); + let byte = witness_value_bytes + .last() + .expect("Field element must be represented by non-zero amount of bytes"); + result.push(*byte); + } + Ok(result) +} diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs index fab67467d9ab..59667c55cec0 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs @@ -7,6 +7,13 @@ use crate::BlackBoxResolutionError; /// /// Returns an [`BlackBoxResolutionError`] if the backend does not support the given [`acir::BlackBoxFunc`]. pub trait BlackBoxFunctionSolver { + fn aes128_encrypt( + &self, + inputs: &[u8], + iv: [u8; 16], + key: [u8; 16], + length: u32, + ) -> Result, BlackBoxResolutionError>; fn schnorr_verify( &self, public_key_x: &FieldElement, @@ -55,6 +62,15 @@ impl StubbedBlackBoxSolver { } impl BlackBoxFunctionSolver for StubbedBlackBoxSolver { + fn aes128_encrypt( + &self, + _inputs: &[u8], + _iv: [u8; 16], + _key: [u8; 16], + _length: u32, + ) -> Result, BlackBoxResolutionError> { + Err(Self::fail(BlackBoxFunc::AES128Encrypt)) + } fn schnorr_verify( &self, _public_key_x: &FieldElement, diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml index 448642e1a9e2..a46b19dec5e6 100644 --- a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml +++ b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml @@ -19,6 +19,7 @@ thiserror.workspace = true cfg-if = "1.0.0" hex.workspace = true lazy_static = "1.4" +libaes = "0.7.0" # BN254 fixed base scalar multiplication solver grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/aes.rs b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/aes.rs new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs index 25b10252a784..893354000878 100644 --- a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs +++ b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs @@ -10,6 +10,7 @@ mod poseidon2; mod wasm; pub use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul}; +use libaes::Cipher; pub use poseidon2::poseidon2_permutation; use wasm::Barretenberg; @@ -48,6 +49,18 @@ impl Default for Bn254BlackBoxSolver { } impl BlackBoxFunctionSolver for Bn254BlackBoxSolver { + fn aes128_encrypt( + &self, + inputs: &[u8], + iv: [u8; 16], + key: [u8; 16], + _length: u32, + ) -> Result, BlackBoxResolutionError> { + let cipher = Cipher::new_128(&key); + let encrypted = cipher.cbc_encrypt(&iv, inputs); + Ok(encrypted) + } + fn schnorr_verify( &self, public_key_x: &FieldElement, diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs index ee047903743d..97a4abf838dc 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs @@ -401,6 +401,7 @@ pub(crate) fn convert_black_box_call( unreachable!("ICE: Sha256Compression expects two array argument, one array result") } } + BlackBoxFunc::AES128Encrypt => todo!(), } } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs index b94e02e51199..c924ed6f1700 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs @@ -1295,6 +1295,26 @@ impl AcirContext { self.big_int_ctx.new_big_int(FieldElement::from(modulus_id as u128)); (modulus, vec![result_id.bigint_id(), result_id.modulus_id()]) } + BlackBoxFunc::AES128Encrypt => { + let invalid_input = "aes128_encrypt - operation requires a plaintext to encrypt"; + let aes_block_size = 16; + + output_count = match inputs.first().expect(invalid_input) { + AcirValue::Array(values) => { + let input_size = values.len(); + Ok::( + input_size + (aes_block_size - (input_size % aes_block_size)), + ) + } + _ => { + return Err(RuntimeError::InternalError(InternalError::General { + message: "aes128_encrypt requires an array of inputs".to_string(), + call_stack: self.get_call_stack(), + })); + } + }?; + (vec![], vec![FieldElement::from(output_count as u128)]) + } _ => (vec![], vec![]), }; diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs index 999ff2ddb5d0..07f55dba18d2 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/generated_acir.rs @@ -160,6 +160,18 @@ impl GeneratedAcir { let outputs_clone = outputs.clone(); let black_box_func_call = match func_name { + BlackBoxFunc::AES128Encrypt => BlackBoxFuncCall::AES128Encrypt { + inputs: inputs[0].clone(), + iv: inputs[1] + .clone() + .try_into() + .expect("Compiler should generate correct size inputs"), + key: inputs[2] + .clone() + .try_into() + .expect("Compiler should generate correct size inputs"), + outputs, + }, BlackBoxFunc::AND => { BlackBoxFuncCall::AND { lhs: inputs[0][0], rhs: inputs[1][0], output: outputs[0] } } @@ -663,7 +675,8 @@ fn black_box_func_expected_input_size(name: BlackBoxFunc) -> Option { // All of the hash/cipher methods will take in a // variable number of inputs. - BlackBoxFunc::Keccak256 + BlackBoxFunc::AES128Encrypt + | BlackBoxFunc::Keccak256 | BlackBoxFunc::SHA256 | BlackBoxFunc::Blake2s | BlackBoxFunc::Blake3 @@ -758,6 +771,9 @@ fn black_box_expected_output_size(name: BlackBoxFunc) -> Option { // Recursive aggregation has a variable number of outputs BlackBoxFunc::RecursiveAggregation => None, + + // AES encryption returns a variable number of outputs + BlackBoxFunc::AES128Encrypt => None, } } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs index 1187ea8cb07c..4aa6dd17d18f 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ir/instruction/call.rs @@ -480,6 +480,7 @@ fn simplify_black_box_func( ) } BlackBoxFunc::Sha256Compression => SimplifyResult::None, //TODO(Guillaume) + BlackBoxFunc::AES128Encrypt => SimplifyResult::None, } } diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr new file mode 100644 index 000000000000..9d5613677d94 --- /dev/null +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -0,0 +1,5 @@ +#[foreign(aes128_encrypt)] +pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16], length: u32) -> [u8] {} + +#[foreign(aes128_encrypt)] +pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16], length: u32) -> [u8] {} diff --git a/noir/noir-repo/noir_stdlib/src/lib.nr b/noir/noir-repo/noir_stdlib/src/lib.nr index 90c04472066f..cda039bf443b 100644 --- a/noir/noir-repo/noir_stdlib/src/lib.nr +++ b/noir/noir-repo/noir_stdlib/src/lib.nr @@ -1,4 +1,5 @@ mod hash; +mod aes128; mod array; mod slice; mod merkle; diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Nargo.toml b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Nargo.toml new file mode 100644 index 000000000000..29425131cff2 --- /dev/null +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Nargo.toml @@ -0,0 +1,7 @@ +[package] +name = "aes128_encrypt" +type = "bin" +authors = [""] +compiler_version = ">=0.27.0" + +[dependencies] \ No newline at end of file diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml new file mode 100644 index 000000000000..7a7affab50bb --- /dev/null +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml @@ -0,0 +1,5 @@ +inputs = "kevlovesrust" +iv = "0000000000000000" +key = "0000000000000000" +length = 12 +output = "f40e7eacab28d0baadb8e269ee7acdbf" \ No newline at end of file diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr new file mode 100644 index 000000000000..34423d129dbc --- /dev/null +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -0,0 +1,35 @@ +use dep::std; + +unconstrained fn decode_ascii(ascii: u8) -> u8 { + if ascii < 58 { + ascii - 48 + } else if ascii < 71 { + ascii - 55 + } else { + ascii - 87 + } +} + +unconstrained fn decode_hex(s: str) -> [u8; M] { + let mut result: [u8; M] = [0; M]; + let as_bytes = s.as_bytes(); + for i in 0..N { + if i % 2 != 0 { + continue; + } + result[i/2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]); + } + result +} +fn main(inputs: str<12>, iv: str<16>, key: str<16>, length: u32, output: str<32>) { + let mut bytes: [u8] = &[]; + let input_as_bytes = inputs.as_bytes(); + for i in 0..12 { + bytes = bytes.push_back(input_as_bytes[i]); + } + let result = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes(), length); + let output_bytes: [u8; 16] = decode_hex(output); + for i in 0..16 { + assert(result[i] == output_bytes[i]); + } +} diff --git a/noir/noir-repo/tooling/lsp/src/solver.rs b/noir/noir-repo/tooling/lsp/src/solver.rs index 0fea9b16b54a..f2bba833438d 100644 --- a/noir/noir-repo/tooling/lsp/src/solver.rs +++ b/noir/noir-repo/tooling/lsp/src/solver.rs @@ -6,6 +6,16 @@ use acvm::BlackBoxFunctionSolver; pub(super) struct WrapperSolver(pub(super) Box); impl BlackBoxFunctionSolver for WrapperSolver { + fn aes128_encrypt( + &self, + inputs: &[u8], + iv: [u8; 16], + key: [u8; 16], + length: u32, + ) -> Result, acvm::BlackBoxResolutionError> { + self.0.aes128_encrypt(inputs, iv, key, length) + } + fn schnorr_verify( &self, public_key_x: &acvm::FieldElement, From 61f341acbba506249072ce17471e4e3b323f5358 Mon Sep 17 00:00:00 2001 From: thunkar Date: Wed, 24 Apr 2024 15:36:39 +0000 Subject: [PATCH 03/27] got bb compiling --- .../dsl/acir_format/acir_format.test.cpp | 6 ++ .../acir_format/acir_to_constraint_buf.hpp | 27 +++++++++ .../dsl/acir_format/aes128_constraint.cpp | 60 +++++++++++-------- .../dsl/acir_format/aes128_constraint.hpp | 2 +- .../acir_format/bigint_constraint.test.cpp | 5 ++ .../dsl/acir_format/block_constraint.test.cpp | 1 + .../dsl/acir_format/ec_operations.test.cpp | 1 + .../dsl/acir_format/ecdsa_secp256k1.test.cpp | 3 + .../dsl/acir_format/ecdsa_secp256r1.test.cpp | 4 ++ .../acir_format/poseidon2_constraint.test.cpp | 1 + .../acir_format/recursion_constraint.test.cpp | 2 + .../dsl/acir_format/serde/acir.hpp | 8 +-- .../acir_format/sha256_constraint.test.cpp | 1 + .../stdlib/encryption/aes128/aes128.cpp | 4 +- .../stdlib/encryption/aes128/aes128.hpp | 4 +- barretenberg/ts/src/info.ts | 1 + .../bn254_blackbox_solver/src/aes.rs | 0 17 files changed, 97 insertions(+), 33 deletions(-) delete mode 100644 noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/aes.rs diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp index c7d44e319413..547783ccede9 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.test.cpp @@ -35,6 +35,7 @@ TEST_F(AcirFormatTests, TestASingleConstraintNoPubInputs) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -151,6 +152,7 @@ TEST_F(AcirFormatTests, TestLogicGateFromNoirCircuit) .public_inputs = { 1 }, .logic_constraints = { logic_constraint }, .range_constraints = { range_a, range_b }, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -219,6 +221,7 @@ TEST_F(AcirFormatTests, TestSchnorrVerifyPass) .public_inputs = {}, .logic_constraints = {}, .range_constraints = range_constraints, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = { schnorr_constraint }, @@ -314,6 +317,7 @@ TEST_F(AcirFormatTests, TestSchnorrVerifySmallRange) .public_inputs = {}, .logic_constraints = {}, .range_constraints = range_constraints, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = { schnorr_constraint }, @@ -428,6 +432,7 @@ TEST_F(AcirFormatTests, TestVarKeccak) .public_inputs = {}, .logic_constraints = {}, .range_constraints = { range_a, range_b, range_c, range_d }, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -475,6 +480,7 @@ TEST_F(AcirFormatTests, TestKeccakPermutation) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp index 778363f3258c..f3db0c3ecdd8 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp @@ -2,6 +2,7 @@ #include "acir_format.hpp" #include "barretenberg/common/container.hpp" #include "barretenberg/common/throw_or_abort.hpp" +#include "barretenberg/dsl/acir_format/aes128_constraint.hpp" #include "barretenberg/dsl/acir_format/bigint_constraint.hpp" #include "barretenberg/dsl/acir_format/blake2s_constraint.hpp" #include "barretenberg/dsl/acir_format/blake3_constraint.hpp" @@ -222,6 +223,32 @@ void handle_blackbox_func_call(Program::Opcode::BlackBoxFuncCall const& arg, Aci .witness = arg.input.witness.value, .num_bits = arg.input.num_bits, }); + } else if constexpr (std::is_same_v) { + af.aes128_constraints.push_back(AES128Constraint{ + .inputs = map(arg.inputs, + [](auto& e) { + return AES128Input{ + .witness = e.witness.value, + .num_bits = e.num_bits, + }; + }), + .iv = map(arg.iv, + [](auto& e) { + return AES128Input{ + .witness = e.witness.value, + .num_bits = e.num_bits, + }; + }), + .key = map(arg.key, + [](auto& e) { + return AES128Input{ + .witness = e.witness.value, + .num_bits = e.num_bits, + }; + }), + .length = arg.length.witness.value, + .outputs = map(arg.outputs, [](auto& e) { return e.value; }), + }); } else if constexpr (std::is_same_v) { af.sha256_constraints.push_back(Sha256Constraint{ .inputs = map(arg.inputs, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index afb653eefb79..ddd7d56d791f 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -7,50 +7,62 @@ namespace acir_format { template void create_aes128_constraints(Builder& builder, const AES128Constraint& constraint) { - using byte_array_ct = bb::stdlib::byte_array; + + const auto convert_bytes = [](uint8_t* data) { + uint256_t converted(0); + for (uint64_t i = 0; i < 16; ++i) { + uint256_t to_add = uint256_t((uint64_t)(data[i])) << uint256_t((15 - i) * 8); + converted += to_add; + } + return converted; + }; + using field_ct = bb::stdlib::field_t; + using witness_ct = bb::stdlib::witness_t; - // Create byte array struct - byte_array_ct input(&builder); + std::vector input; - std::array iv; - std::array key; + uint8_t iv[16]; + uint8_t key[16]; for (const auto& witness_index_num_bits : constraint.inputs) { auto witness_index = witness_index_num_bits.witness; - auto num_bits = witness_index_num_bits.num_bits; - - // TODO: Copied forom KeccakConstraint, is this really necessary? - auto num_bytes = round_to_nearest_byte(num_bits); - field_ct element = field_ct::from_witness_index(&builder, witness_index); - byte_array_ct element_bytes(element, num_bytes); - - input.write(element_bytes); + input.push_back(element); } size_t i = 0; for (const auto& witness_index_num_bits : constraint.iv) { auto witness_index = witness_index_num_bits.witness; - field_ct element = field_ct::from_witness_index(&builder, witness_index); - iv[i] = element; - ++i; + std::vector fr_bytes(sizeof(fr)); + + fr value = builder.get_variable(witness_index); + + fr::serialize_to_buffer(value, &fr_bytes[0]); + + iv[i] = fr_bytes.back(); + i++; } i = 0; for (const auto& witness_index_num_bits : constraint.key) { auto witness_index = witness_index_num_bits.witness; - field_ct element = field_ct::from_witness_index(&builder, witness_index); - key[i] = element; - ++i; + std::vector fr_bytes(sizeof(fr)); + + fr value = builder.get_variable(witness_index); + + fr::serialize_to_buffer(value, &fr_bytes[0]); + + key[i] = fr_bytes.back(); + i++; } - byte_array_ct output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc(input_arr, iv, key); + field_ct key_field(witness_ct(&builder, fr(convert_bytes(key)))); + field_ct iv_field(witness_ct(&builder, fr(convert_bytes(iv)))); - // Convert byte array to vector of field_t - auto bytes = output_bytes.bytes(); + const auto output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc(input, iv_field, key_field); - for (size_t i = 0; i < bytes.size(); ++i) { - builder.assert_equal(bytes[i].normalize().witness_index, constraint.result[i]); + for (size_t i = 0; i < output_bytes.size(); ++i) { + builder.assert_equal(output_bytes[i].normalize().witness_index, constraint.outputs[i]); } } diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp index 42cc7be9220f..40efeb20decc 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp @@ -17,10 +17,10 @@ struct AES128Input { struct AES128Constraint { std::vector inputs; - std::vector outputs; std::array iv; std::array key; uint32_t length; + std::vector outputs; // For serialization, update with any new fields MSGPACK_FIELDS(inputs, iv, key, length, outputs); diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/bigint_constraint.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/bigint_constraint.test.cpp index 584f7ef62a56..af1944bf8552 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/bigint_constraint.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/bigint_constraint.test.cpp @@ -172,6 +172,7 @@ TEST_F(BigIntTests, TestBigIntConstraintMultiple) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -240,6 +241,7 @@ TEST_F(BigIntTests, TestBigIntConstraintSimple) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -293,6 +295,7 @@ TEST_F(BigIntTests, TestBigIntConstraintReuse) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -350,6 +353,7 @@ TEST_F(BigIntTests, TestBigIntConstraintReuse2) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -428,6 +432,7 @@ TEST_F(BigIntTests, TestBigIntDIV) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp index 20f9e8072bba..9a15562bd8a0 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/block_constraint.test.cpp @@ -114,6 +114,7 @@ TEST_F(UltraPlonkRAM, TestBlockConstraint) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/ec_operations.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/ec_operations.test.cpp index 92c76e3d7a37..2e709816955e 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/ec_operations.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/ec_operations.test.cpp @@ -54,6 +54,7 @@ TEST_F(EcOperations, TestECOperations) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp index 0a11adb97be2..89d6f16c4870 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp @@ -94,6 +94,7 @@ TEST_F(ECDSASecp256k1, TestECDSAConstraintSucceed) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -143,6 +144,7 @@ TEST_F(ECDSASecp256k1, TestECDSACompilesForVerifier) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -187,6 +189,7 @@ TEST_F(ECDSASecp256k1, TestECDSAConstraintFail) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp index 6cf542bc2d6e..9666228fa398 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256r1.test.cpp @@ -128,6 +128,7 @@ TEST(ECDSASecp256r1, test_hardcoded) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -179,6 +180,7 @@ TEST(ECDSASecp256r1, TestECDSAConstraintSucceed) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -228,6 +230,7 @@ TEST(ECDSASecp256r1, TestECDSACompilesForVerifier) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -272,6 +275,7 @@ TEST(ECDSASecp256r1, TestECDSAConstraintFail) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/poseidon2_constraint.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/poseidon2_constraint.test.cpp index f509c262782a..b6e1be990b1a 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/poseidon2_constraint.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/poseidon2_constraint.test.cpp @@ -34,6 +34,7 @@ TEST_F(Poseidon2Tests, TestPoseidon2Permutation) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp index bbf7768abc91..d0e54f311cf8 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/recursion_constraint.test.cpp @@ -86,6 +86,7 @@ Builder create_inner_circuit() .public_inputs = { 1, 2 }, .logic_constraints = { logic_constraint }, .range_constraints = { range_a, range_b }, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, @@ -243,6 +244,7 @@ Builder create_outer_circuit(std::vector& inner_circuits) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = {}, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp index 31d44c221dd2..e3557555364a 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp @@ -29,7 +29,7 @@ struct BlackBoxFuncCall { std::array iv; std::array key; Program::FunctionInput length; - Program::Witness output; + std::vector outputs; friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); std::vector bincodeSerialize() const; @@ -2243,7 +2243,7 @@ inline bool operator==(const BlackBoxFuncCall::AES128Encrypt& lhs, const BlackBo if (!(lhs.length == rhs.length)) { return false; } - if (!(lhs.output == rhs.output)) { + if (!(lhs.outputs == rhs.outputs)) { return false; } return true; @@ -2277,7 +2277,7 @@ void serde::Serializable::serialize( serde::Serializable::serialize(obj.iv, serializer); serde::Serializable::serialize(obj.key, serializer); serde::Serializable::serialize(obj.length, serializer); - serde::Serializable::serialize(obj.output, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> @@ -2290,7 +2290,7 @@ Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(deserializer); obj.key = serde::Deserializable::deserialize(deserializer); obj.length = serde::Deserializable::deserialize(deserializer); - obj.output = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.test.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.test.cpp index 6266253ee552..784bb79fe369 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.test.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/sha256_constraint.test.cpp @@ -36,6 +36,7 @@ TEST_F(Sha256Tests, TestSha256Compression) .public_inputs = {}, .logic_constraints = {}, .range_constraints = {}, + .aes128_constraints = {}, .sha256_constraints = {}, .sha256_compression = { sha256_compression }, .schnorr_constraints = {}, diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp index ce61c9b81eef..232e21c1cc3d 100644 --- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp +++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp @@ -9,7 +9,7 @@ using namespace bb::crypto; -namespace bb::stdlib { +namespace bb::stdlib::aes128 { template using byte_pair = std::pair, field_t>; using namespace bb::plookup; @@ -301,4 +301,4 @@ std::vector> encrypt_buffer_cbc(const std::vector std::vector> encrypt_buffer_cbc(const std::vector>& input, const stdlib::field_t& iv, const stdlib::field_t& key); -} // namespace bb::stdlib +} // namespace bb::stdlib::aes128 diff --git a/barretenberg/ts/src/info.ts b/barretenberg/ts/src/info.ts index 6032427bdd5a..3e092ca7621b 100644 --- a/barretenberg/ts/src/info.ts +++ b/barretenberg/ts/src/info.ts @@ -9,6 +9,7 @@ export const acvmInfoJson = { 'and', 'xor', 'range', + 'aes128_encrypt', 'sha256', 'blake2s', 'keccak256', diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/aes.rs b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/aes.rs deleted file mode 100644 index e69de29bb2d1..000000000000 From 60c1b73e4eb23cf138ea2c59b650d123ebf30c3e Mon Sep 17 00:00:00 2001 From: thunkar Date: Thu, 25 Apr 2024 08:00:32 +0000 Subject: [PATCH 04/27] correct serialization, failing proofs --- .../acir_format/acir_to_constraint_buf.hpp | 1 - .../dsl/acir_format/aes128_constraint.hpp | 3 +- .../dsl/acir_format/serde/acir.hpp | 16 ++--- .../noir-repo/acvm-repo/acir/codegen/acir.cpp | 60 ++++++++++++++++++- .../acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 2 +- .../src/curve_specific_solver.rs | 2 - .../bn254_blackbox_solver/src/lib.rs | 1 - noir/noir-repo/noir_stdlib/src/aes128.nr | 4 +- .../aes128_encrypt/Prover.toml | 1 - .../aes128_encrypt/src/main.nr | 4 +- noir/noir-repo/tooling/lsp/src/solver.rs | 3 +- 11 files changed, 70 insertions(+), 27 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp index f3db0c3ecdd8..86df551e7369 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_to_constraint_buf.hpp @@ -246,7 +246,6 @@ void handle_blackbox_func_call(Program::Opcode::BlackBoxFuncCall const& arg, Aci .num_bits = e.num_bits, }; }), - .length = arg.length.witness.value, .outputs = map(arg.outputs, [](auto& e) { return e.value; }), }); } else if constexpr (std::is_same_v) { diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp index 40efeb20decc..b0833c1e4473 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.hpp @@ -19,11 +19,10 @@ struct AES128Constraint { std::vector inputs; std::array iv; std::array key; - uint32_t length; std::vector outputs; // For serialization, update with any new fields - MSGPACK_FIELDS(inputs, iv, key, length, outputs); + MSGPACK_FIELDS(inputs, iv, key, outputs); friend bool operator==(AES128Constraint const& lhs, AES128Constraint const& rhs) = default; }; diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp index e3557555364a..80e45a98d511 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/serde/acir.hpp @@ -28,7 +28,6 @@ struct BlackBoxFuncCall { std::vector inputs; std::array iv; std::array key; - Program::FunctionInput length; std::vector outputs; friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); @@ -532,7 +531,7 @@ struct BlackBoxOp { Program::HeapArray iv; Program::HeapArray key; Program::MemoryAddress length; - Program::MemoryAddress result; + Program::HeapVector outputs; friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); std::vector bincodeSerialize() const; @@ -2240,9 +2239,6 @@ inline bool operator==(const BlackBoxFuncCall::AES128Encrypt& lhs, const BlackBo if (!(lhs.key == rhs.key)) { return false; } - if (!(lhs.length == rhs.length)) { - return false; - } if (!(lhs.outputs == rhs.outputs)) { return false; } @@ -2276,7 +2272,6 @@ void serde::Serializable::serialize( serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.iv, serializer); serde::Serializable::serialize(obj.key, serializer); - serde::Serializable::serialize(obj.length, serializer); serde::Serializable::serialize(obj.outputs, serializer); } @@ -2289,7 +2284,6 @@ Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(deserializer); obj.iv = serde::Deserializable::deserialize(deserializer); obj.key = serde::Deserializable::deserialize(deserializer); - obj.length = serde::Deserializable::deserialize(deserializer); obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } @@ -3747,7 +3741,7 @@ inline bool operator==(const BlackBoxOp::AES128Encrypt& lhs, const BlackBoxOp::A if (!(lhs.length == rhs.length)) { return false; } - if (!(lhs.result == rhs.result)) { + if (!(lhs.outputs == rhs.outputs)) { return false; } return true; @@ -3780,8 +3774,7 @@ void serde::Serializable::serialize(const Pr serde::Serializable::serialize(obj.inputs, serializer); serde::Serializable::serialize(obj.iv, serializer); serde::Serializable::serialize(obj.key, serializer); - serde::Serializable::serialize(obj.length, serializer); - serde::Serializable::serialize(obj.result, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> @@ -3793,8 +3786,7 @@ Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(deserializer); obj.iv = serde::Deserializable::deserialize(deserializer); obj.key = serde::Deserializable::deserialize(deserializer); - obj.length = serde::Deserializable::deserialize(deserializer); - obj.result = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); return obj; } diff --git a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp index 6c7bd347e5d0..9ed6f17372d0 100644 --- a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp +++ b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp @@ -24,6 +24,17 @@ namespace Program { struct BlackBoxFuncCall { + struct AES128Encrypt { + std::vector inputs; + std::array iv; + std::array key; + std::vector outputs; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + struct AND { Program::FunctionInput lhs; Program::FunctionInput rhs; @@ -266,7 +277,7 @@ namespace Program { static Sha256Compression bincodeDeserialize(std::vector); }; - std::variant value; + std::variant value; friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); std::vector bincodeSerialize() const; @@ -2011,6 +2022,53 @@ Program::BlackBoxFuncCall serde::Deserializable::dese return obj; } +namespace Program { + + inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, const BlackBoxFuncCall::AES128Encrypt &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.iv == rhs.iv)) { return false; } + if (!(lhs.key == rhs.key)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::AES128Encrypt BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AES128Encrypt &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.outputs, serializer); +} + +template <> +template +Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; +} + namespace Program { inline bool operator==(const BlackBoxFuncCall::AND &lhs, const BlackBoxFuncCall::AND &rhs) { diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs index 63e1405ba1e4..f5468b59e379 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -22,7 +22,7 @@ pub(super) fn aes128_encrypt( let iv = to_u8_array(initial_witness, iv)?; let key = to_u8_array(initial_witness, key)?; - let cyphertext = backend.aes128_encrypt(&scalars, iv, key, scalars.len() as u32)?; + let cyphertext = backend.aes128_encrypt(&scalars, iv, key)?; // Write witness assignments for (output_witness, value) in outputs.iter().zip(cyphertext.into_iter()) { diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs index 59667c55cec0..f7f7b159f469 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs @@ -12,7 +12,6 @@ pub trait BlackBoxFunctionSolver { inputs: &[u8], iv: [u8; 16], key: [u8; 16], - length: u32, ) -> Result, BlackBoxResolutionError>; fn schnorr_verify( &self, @@ -67,7 +66,6 @@ impl BlackBoxFunctionSolver for StubbedBlackBoxSolver { _inputs: &[u8], _iv: [u8; 16], _key: [u8; 16], - _length: u32, ) -> Result, BlackBoxResolutionError> { Err(Self::fail(BlackBoxFunc::AES128Encrypt)) } diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs index 893354000878..022469368f20 100644 --- a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs +++ b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs @@ -54,7 +54,6 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver { inputs: &[u8], iv: [u8; 16], key: [u8; 16], - _length: u32, ) -> Result, BlackBoxResolutionError> { let cipher = Cipher::new_128(&key); let encrypted = cipher.cbc_encrypt(&iv, inputs); diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index 9d5613677d94..63f06f08a802 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -1,5 +1,5 @@ #[foreign(aes128_encrypt)] -pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16], length: u32) -> [u8] {} +pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {} #[foreign(aes128_encrypt)] -pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16], length: u32) -> [u8] {} +pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {} diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml index 7a7affab50bb..6ea296aec1e6 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml @@ -1,5 +1,4 @@ inputs = "kevlovesrust" iv = "0000000000000000" key = "0000000000000000" -length = 12 output = "f40e7eacab28d0baadb8e269ee7acdbf" \ No newline at end of file diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index 34423d129dbc..ea219b141ffb 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -21,13 +21,13 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { } result } -fn main(inputs: str<12>, iv: str<16>, key: str<16>, length: u32, output: str<32>) { +fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { let mut bytes: [u8] = &[]; let input_as_bytes = inputs.as_bytes(); for i in 0..12 { bytes = bytes.push_back(input_as_bytes[i]); } - let result = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes(), length); + let result = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes()); let output_bytes: [u8; 16] = decode_hex(output); for i in 0..16 { assert(result[i] == output_bytes[i]); diff --git a/noir/noir-repo/tooling/lsp/src/solver.rs b/noir/noir-repo/tooling/lsp/src/solver.rs index f2bba833438d..15363ad1bde6 100644 --- a/noir/noir-repo/tooling/lsp/src/solver.rs +++ b/noir/noir-repo/tooling/lsp/src/solver.rs @@ -11,9 +11,8 @@ impl BlackBoxFunctionSolver for WrapperSolver { inputs: &[u8], iv: [u8; 16], key: [u8; 16], - length: u32, ) -> Result, acvm::BlackBoxResolutionError> { - self.0.aes128_encrypt(inputs, iv, key, length) + self.0.aes128_encrypt(inputs, iv, key) } fn schnorr_verify( From 3190ef441dc969a88eb7af4fc589a3d421e95055 Mon Sep 17 00:00:00 2001 From: thunkar Date: Thu, 25 Apr 2024 11:20:59 +0000 Subject: [PATCH 05/27] padding and respecting the test impl --- .../dsl/acir_format/aes128_constraint.cpp | 20 +++++++-- .../acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 41 ++++++++++++++++++- 2 files changed, 56 insertions(+), 5 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index ddd7d56d791f..6e76de2b272b 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -2,6 +2,7 @@ #include "barretenberg/stdlib/encryption/aes128/aes128.hpp" #include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp" #include "round.hpp" +#include namespace acir_format { @@ -22,16 +23,27 @@ template void create_aes128_constraints(Builder& builder, con std::vector input; + uint8_t input_bytes[input.size()]; uint8_t iv[16]; uint8_t key[16]; + size_t i = 0; for (const auto& witness_index_num_bits : constraint.inputs) { auto witness_index = witness_index_num_bits.witness; - field_ct element = field_ct::from_witness_index(&builder, witness_index); - input.push_back(element); - } + std::vector fr_bytes(sizeof(fr)); - size_t i = 0; + fr value = builder.get_variable(witness_index); + + fr::serialize_to_buffer(value, &fr_bytes[0]); + + input_bytes[i] = fr_bytes.back(); + i++; + } + i = 0; + for (i = 0; i < constraint.inputs.size(); i += 16) { + input.push_back(witness_ct(&builder, fr(convert_bytes(input_bytes + i)))); + } + i = 0; for (const auto& witness_index_num_bits : constraint.iv) { auto witness_index = witness_index_num_bits.witness; std::vector fr_bytes(sizeof(fr)); diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs index f5468b59e379..b67f35e848fb 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -9,6 +9,43 @@ use crate::{pwg::insert_value, OpcodeResolutionError}; use super::utils::{to_u8_array, to_u8_vec}; +// PKCS7 padding: a new Vec is returned with padding. +// Implementation taken from libaes 0.7.0 by Han Xu under MIT License: + +// Permission is hereby granted, free of charge, to any +// person obtaining a copy of this software and associated +// documentation files (the "Software"), to deal in the +// Software without restriction, including without +// limitation the rights to use, copy, modify, merge, +// publish, distribute, sublicense, and/or sell copies of +// the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following +// conditions: + +// The above copyright notice and this permission notice +// shall be included in all copies or substantial portions +// of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +// DEALINGS IN THE SOFTWARE. +fn pad(input: &[u8]) -> Vec { + let sz = input.len(); + let add = 16 - (sz % 16); + let mut v: Vec = Vec::with_capacity(sz + add); + v.extend_from_slice(input); + for _ in 0..add { + v.push(add as u8); + } + v +} + pub(super) fn aes128_encrypt( backend: &impl BlackBoxFunctionSolver, initial_witness: &mut WitnessMap, @@ -19,10 +56,12 @@ pub(super) fn aes128_encrypt( ) -> Result<(), OpcodeResolutionError> { let scalars = to_u8_vec(initial_witness, inputs)?; + let padded_input = pad(scalars.as_slice()); + let iv = to_u8_array(initial_witness, iv)?; let key = to_u8_array(initial_witness, key)?; - let cyphertext = backend.aes128_encrypt(&scalars, iv, key)?; + let cyphertext = backend.aes128_encrypt(&padded_input, iv, key)?; // Write witness assignments for (output_witness, value) in outputs.iter().zip(cyphertext.into_iter()) { From 3b6d9b250e5549c5a8d1782e9bf611a16f44d175 Mon Sep 17 00:00:00 2001 From: thunkar Date: Thu, 25 Apr 2024 13:16:42 +0000 Subject: [PATCH 06/27] changed declaration order --- .../cpp/src/barretenberg/dsl/acir_format/acir_format.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp index 196b2a3f4426..0b4554e30992 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.hpp @@ -34,9 +34,9 @@ struct AcirFormat { std::vector public_inputs; - std::vector aes128_constraints; std::vector logic_constraints; std::vector range_constraints; + std::vector aes128_constraints; std::vector sha256_constraints; std::vector sha256_compression; std::vector schnorr_constraints; @@ -69,9 +69,9 @@ struct AcirFormat { // For serialization, update with any new fields MSGPACK_FIELDS(varnum, public_inputs, - aes128_constraints, logic_constraints, range_constraints, + aes128_constraints, sha256_constraints, sha256_compression, schnorr_constraints, From b5340c38e125d06b40ed2032af1c0965c015737f Mon Sep 17 00:00:00 2001 From: thunkar Date: Fri, 26 Apr 2024 09:35:39 +0000 Subject: [PATCH 07/27] added aes128 to brillig --- avm-transpiler/Cargo.lock | 7 +++++ noir/noir-repo/Cargo.lock | 2 +- .../acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 2 +- .../acvm-repo/blackbox_solver/Cargo.toml | 1 + .../acvm-repo/blackbox_solver/src/aes128.rs | 12 +++++++++ .../acvm-repo/blackbox_solver/src/lib.rs | 2 ++ .../bn254_blackbox_solver/Cargo.toml | 1 - .../bn254_blackbox_solver/src/lib.rs | 7 ++--- .../acvm-repo/brillig/src/black_box.rs | 7 +++++ .../acvm-repo/brillig_vm/src/black_box.rs | 26 +++++++++++++++++-- .../brillig/brillig_gen/brillig_black_box.rs | 19 +++++++++++++- .../src/brillig/brillig_ir/debug_show.rs | 10 +++++++ 12 files changed, 85 insertions(+), 11 deletions(-) create mode 100644 noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs diff --git a/avm-transpiler/Cargo.lock b/avm-transpiler/Cargo.lock index e145398e26e1..3b41c15e81c2 100644 --- a/avm-transpiler/Cargo.lock +++ b/avm-transpiler/Cargo.lock @@ -51,6 +51,7 @@ dependencies = [ "blake3", "k256", "keccak", + "libaes", "num-bigint", "p256", "sha2", @@ -1131,6 +1132,12 @@ dependencies = [ "regex-automata", ] +[[package]] +name = "libaes" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82903360c009b816f5ab72a9b68158c27c301ee2c3f20655b55c5e589e7d3bb7" + [[package]] name = "libc" version = "0.2.153" diff --git a/noir/noir-repo/Cargo.lock b/noir/noir-repo/Cargo.lock index 9a65769ec439..aaa2ac4db28e 100644 --- a/noir/noir-repo/Cargo.lock +++ b/noir/noir-repo/Cargo.lock @@ -63,6 +63,7 @@ dependencies = [ "blake3", "k256", "keccak", + "libaes", "num-bigint", "p256", "sha2", @@ -624,7 +625,6 @@ dependencies = [ "hex", "js-sys", "lazy_static", - "libaes", "noir_grumpkin", "num-bigint", "pprof 0.12.1", diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs index b67f35e848fb..d1614e3c6227 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -49,7 +49,7 @@ fn pad(input: &[u8]) -> Vec { pub(super) fn aes128_encrypt( backend: &impl BlackBoxFunctionSolver, initial_witness: &mut WitnessMap, - inputs: &Vec, + inputs: &[FunctionInput], iv: &[FunctionInput; 16], key: &[FunctionInput; 16], outputs: &[Witness], diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/Cargo.toml b/noir/noir-repo/acvm-repo/blackbox_solver/Cargo.toml index 893bed38905c..f600166b1906 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/Cargo.toml +++ b/noir/noir-repo/acvm-repo/blackbox_solver/Cargo.toml @@ -37,6 +37,7 @@ p256 = { version = "0.11.0", features = [ "arithmetic", ] } +libaes = "0.7.0" [features] default = ["bn254"] diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs new file mode 100644 index 000000000000..a4c6a2287443 --- /dev/null +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs @@ -0,0 +1,12 @@ +use crate::BlackBoxResolutionError; +use libaes::Cipher; + +pub fn aes128_encrypt( + inputs: &[u8], + iv: [u8; 16], + key: [u8; 16], +) -> Result, BlackBoxResolutionError> { + let cipher = Cipher::new_128(&key); + let encrypted = cipher.cbc_encrypt(&iv, inputs); + Ok(encrypted) +} diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/lib.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/lib.rs index 0f57f2ce7da3..a68b52a2a620 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/src/lib.rs +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/lib.rs @@ -10,11 +10,13 @@ use acir::BlackBoxFunc; use thiserror::Error; +mod aes128; mod bigint; mod curve_specific_solver; mod ecdsa; mod hash; +pub use aes128::aes128_encrypt; pub use bigint::BigIntSolver; pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver}; pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify}; diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml index 3930c4d09a25..d856a57eb9bc 100644 --- a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml +++ b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/Cargo.toml @@ -19,7 +19,6 @@ thiserror.workspace = true cfg-if = "1.0.0" hex.workspace = true lazy_static = "1.4" -libaes = "0.7.0" # BN254 fixed base scalar multiplication solver grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs index 022469368f20..ece1b4c4879e 100644 --- a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs +++ b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs @@ -3,14 +3,13 @@ #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))] use acir::{BlackBoxFunc, FieldElement}; -use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError}; +use acvm_blackbox_solver::{aes128_encrypt, BlackBoxFunctionSolver, BlackBoxResolutionError}; mod fixed_base_scalar_mul; mod poseidon2; mod wasm; pub use fixed_base_scalar_mul::{embedded_curve_add, fixed_base_scalar_mul}; -use libaes::Cipher; pub use poseidon2::poseidon2_permutation; use wasm::Barretenberg; @@ -55,9 +54,7 @@ impl BlackBoxFunctionSolver for Bn254BlackBoxSolver { iv: [u8; 16], key: [u8; 16], ) -> Result, BlackBoxResolutionError> { - let cipher = Cipher::new_128(&key); - let encrypted = cipher.cbc_encrypt(&iv, inputs); - Ok(encrypted) + aes128_encrypt(inputs, iv, key) } fn schnorr_verify( diff --git a/noir/noir-repo/acvm-repo/brillig/src/black_box.rs b/noir/noir-repo/acvm-repo/brillig/src/black_box.rs index 29861d0fd841..3744ae983b3e 100644 --- a/noir/noir-repo/acvm-repo/brillig/src/black_box.rs +++ b/noir/noir-repo/acvm-repo/brillig/src/black_box.rs @@ -5,6 +5,13 @@ use serde::{Deserialize, Serialize}; /// They are implemented as native functions in the VM. #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] pub enum BlackBoxOp { + /// Encrypts a message using AES128. + AES128Encrypt { + inputs: HeapVector, + iv: HeapArray, + key: HeapArray, + outputs: HeapVector, + }, /// Calculates the SHA256 hash of the inputs. Sha256 { message: HeapVector, diff --git a/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs b/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs index 19407da52dbe..a5a809b7c73f 100644 --- a/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs +++ b/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs @@ -2,8 +2,8 @@ use acir::brillig::{BlackBoxOp, HeapArray, HeapVector}; use acir::{BlackBoxFunc, FieldElement}; use acvm_blackbox_solver::BigIntSolver; use acvm_blackbox_solver::{ - blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, keccakf1600, - sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError, + aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccak256, + keccakf1600, sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError, }; use crate::memory::MemoryValue; @@ -38,6 +38,27 @@ pub(crate) fn evaluate_black_box( bigint_solver: &mut BigIntSolver, ) -> Result<(), BlackBoxResolutionError> { match op { + BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => { + let bb_func = black_box_function_from_op(op); + + let inputs = to_u8_vec(read_heap_vector(memory, inputs)); + + let iv: [u8; 16] = to_u8_vec(read_heap_array(memory, iv)).try_into().map_err(|_| { + BlackBoxResolutionError::Failed(bb_func, "Invalid iv length".to_string()) + })?; + let key: [u8; 16] = + to_u8_vec(read_heap_array(memory, key)).try_into().map_err(|_| { + BlackBoxResolutionError::Failed(bb_func, "Invalid ley length".to_string()) + })?; + let cyphertext = aes128_encrypt(&inputs, iv, key)?; + let mut values = Vec::new(); + for byte in cyphertext { + values.push(byte.into()); + } + memory.write_slice(memory.read_ref(outputs.pointer), &values); + + Ok(()) + } BlackBoxOp::Sha256 { message, output } => { let message = to_u8_vec(read_heap_vector(memory, message)); let bytes = sha256(message.as_slice())?; @@ -278,6 +299,7 @@ pub(crate) fn evaluate_black_box( fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc { match op { + BlackBoxOp::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt, BlackBoxOp::Sha256 { .. } => BlackBoxFunc::SHA256, BlackBoxOp::Blake2s { .. } => BlackBoxFunc::Blake2s, BlackBoxOp::Blake3 { .. } => BlackBoxFunc::Blake3, diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs index 97a4abf838dc..2b1c1bb8d192 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs @@ -401,7 +401,24 @@ pub(crate) fn convert_black_box_call( unreachable!("ICE: Sha256Compression expects two array argument, one array result") } } - BlackBoxFunc::AES128Encrypt => todo!(), + BlackBoxFunc::AES128Encrypt => { + if let ( + [inputs, BrilligVariable::BrilligArray(iv), BrilligVariable::BrilligArray(key)], + [outputs], + ) = (function_arguments, function_results) + { + let inputs = convert_array_or_vector(brillig_context, inputs, bb_func); + let outputs = convert_array_or_vector(brillig_context, outputs, bb_func); + brillig_context.black_box_op_instruction(BlackBoxOp::AES128Encrypt { + inputs: inputs.to_heap_vector(), + iv: iv.to_heap_array(), + key: key.to_heap_array(), + outputs: outputs.to_heap_vector(), + }); + } else { + unreachable!("ICE: AES128Encrypt expects three array arguments, one array result") + } + } } } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs index 41a6d1873e48..50b107c346fa 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs @@ -271,6 +271,16 @@ impl DebugShow { /// Debug function for black_box_op pub(crate) fn black_box_op_instruction(&self, op: &BlackBoxOp) { match op { + BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => { + debug_println!( + self.enable_debug_trace, + " AES128 ENCRYPT {} {} {} -> {}", + inputs, + iv, + key, + outputs + ); + } BlackBoxOp::Sha256 { message, output } => { debug_println!(self.enable_debug_trace, " SHA256 {} -> {}", message, output); } From ec87992d667db2df06cffb254ddd04341fefb4ff Mon Sep 17 00:00:00 2001 From: thunkar Date: Fri, 26 Apr 2024 14:34:25 +0000 Subject: [PATCH 08/27] working bb tests --- .../dsl/acir_format/aes128_constraint.cpp | 89 ++++++++----------- .../acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 41 +-------- .../aes128_encrypt/Prover.toml | 4 +- .../aes128_encrypt/src/main.nr | 8 +- 4 files changed, 42 insertions(+), 100 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index 6e76de2b272b..d4ee4a3f7462 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -3,78 +3,59 @@ #include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp" #include "round.hpp" #include +#include namespace acir_format { template void create_aes128_constraints(Builder& builder, const AES128Constraint& constraint) { - const auto convert_bytes = [](uint8_t* data) { - uint256_t converted(0); - for (uint64_t i = 0; i < 16; ++i) { - uint256_t to_add = uint256_t((uint64_t)(data[i])) << uint256_t((15 - i) * 8); - converted += to_add; + using field_ct = bb::stdlib::field_t; + + const auto convert_input = [&](std::span inputs) { + field_ct converted = 0; + for (const auto& input : inputs) { + converted *= 256; + field_ct byte = field_ct::from_witness_index(&builder, input.witness); + converted += byte; } return converted; }; - using field_ct = bb::stdlib::field_t; - using witness_ct = bb::stdlib::witness_t; - - std::vector input; - - uint8_t input_bytes[input.size()]; - uint8_t iv[16]; - uint8_t key[16]; - - size_t i = 0; - for (const auto& witness_index_num_bits : constraint.inputs) { - auto witness_index = witness_index_num_bits.witness; - std::vector fr_bytes(sizeof(fr)); - - fr value = builder.get_variable(witness_index); - - fr::serialize_to_buffer(value, &fr_bytes[0]); + const auto convert_output = [&](std::span outputs) { + field_ct converted = 0; + for (const auto& output : outputs) { + converted *= 256; + field_ct byte = field_ct::from_witness_index(&builder, output); + converted += byte; + } + return converted; + }; - input_bytes[i] = fr_bytes.back(); - i++; + ASSERT(constraint.inputs.size() % 16 == 0); // check input is multiple of 16 + std::vector converted_inputs; + for (size_t i = 0; i < constraint.inputs.size(); i += 16) { + std::span inputs{ &constraint.inputs[i], 16 }; + converted_inputs.emplace_back(convert_input(inputs)); } - i = 0; - for (i = 0; i < constraint.inputs.size(); i += 16) { - input.push_back(witness_ct(&builder, fr(convert_bytes(input_bytes + i)))); + std::vector converted_outputs; + for (size_t i = 0; i < constraint.outputs.size(); i += 16) { + std::span outputs{ &constraint.outputs[i], 16 }; + converted_outputs.emplace_back(convert_output(outputs)); } - i = 0; - for (const auto& witness_index_num_bits : constraint.iv) { - auto witness_index = witness_index_num_bits.witness; - std::vector fr_bytes(sizeof(fr)); - - fr value = builder.get_variable(witness_index); - fr::serialize_to_buffer(value, &fr_bytes[0]); - - iv[i] = fr_bytes.back(); - i++; - } - i = 0; - for (const auto& witness_index_num_bits : constraint.key) { - auto witness_index = witness_index_num_bits.witness; - std::vector fr_bytes(sizeof(fr)); - - fr value = builder.get_variable(witness_index); - - fr::serialize_to_buffer(value, &fr_bytes[0]); - - key[i] = fr_bytes.back(); - i++; - } + printf("input buffer size = %lu \n", constraint.inputs.size()); + printf("converted input buffer size = %lu \n", converted_inputs.size()); - field_ct key_field(witness_ct(&builder, fr(convert_bytes(key)))); - field_ct iv_field(witness_ct(&builder, fr(convert_bytes(iv)))); + const auto output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc( + converted_inputs, convert_input(constraint.iv), convert_input(constraint.key)); - const auto output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc(input, iv_field, key_field); + printf("generated output buffer size = %lu \n", output_bytes.size()); + printf("output buffer size = %lu \n", constraint.outputs.size()); + printf("converted output buffer size = %lu \n", converted_outputs.size()); for (size_t i = 0; i < output_bytes.size(); ++i) { - builder.assert_equal(output_bytes[i].normalize().witness_index, constraint.outputs[i]); + builder.assert_equal(output_bytes[i].normalize().witness_index, converted_outputs[i].normalize().witness_index); } } diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs index d1614e3c6227..2b6e921d1e59 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -9,43 +9,6 @@ use crate::{pwg::insert_value, OpcodeResolutionError}; use super::utils::{to_u8_array, to_u8_vec}; -// PKCS7 padding: a new Vec is returned with padding. -// Implementation taken from libaes 0.7.0 by Han Xu under MIT License: - -// Permission is hereby granted, free of charge, to any -// person obtaining a copy of this software and associated -// documentation files (the "Software"), to deal in the -// Software without restriction, including without -// limitation the rights to use, copy, modify, merge, -// publish, distribute, sublicense, and/or sell copies of -// the Software, and to permit persons to whom the Software -// is furnished to do so, subject to the following -// conditions: - -// The above copyright notice and this permission notice -// shall be included in all copies or substantial portions -// of the Software. - -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. -fn pad(input: &[u8]) -> Vec { - let sz = input.len(); - let add = 16 - (sz % 16); - let mut v: Vec = Vec::with_capacity(sz + add); - v.extend_from_slice(input); - for _ in 0..add { - v.push(add as u8); - } - v -} - pub(super) fn aes128_encrypt( backend: &impl BlackBoxFunctionSolver, initial_witness: &mut WitnessMap, @@ -56,12 +19,10 @@ pub(super) fn aes128_encrypt( ) -> Result<(), OpcodeResolutionError> { let scalars = to_u8_vec(initial_witness, inputs)?; - let padded_input = pad(scalars.as_slice()); - let iv = to_u8_array(initial_witness, iv)?; let key = to_u8_array(initial_witness, key)?; - let cyphertext = backend.aes128_encrypt(&padded_input, iv, key)?; + let cyphertext = backend.aes128_encrypt(&scalars, iv, key)?; // Write witness assignments for (output_witness, value) in outputs.iter().zip(cyphertext.into_iter()) { diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml index 6ea296aec1e6..1b2b8c3cdf1a 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml @@ -1,4 +1,4 @@ -inputs = "kevlovesrust" +inputs = "kevlovesrust0000" iv = "0000000000000000" key = "0000000000000000" -output = "f40e7eacab28d0baadb8e269ee7acdbf" \ No newline at end of file +output = "72BD0145395756CE2E0ADCCB198299D357839514C4AB014CA0FC47274CA466AA" \ No newline at end of file diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index ea219b141ffb..300f2e96aa15 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -21,15 +21,15 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { } result } -fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { +fn main(inputs: str<16>, iv: str<16>, key: str<16>, output: str<64>) { let mut bytes: [u8] = &[]; let input_as_bytes = inputs.as_bytes(); - for i in 0..12 { + for i in 0..16 { bytes = bytes.push_back(input_as_bytes[i]); } let result = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes()); - let output_bytes: [u8; 16] = decode_hex(output); - for i in 0..16 { + let output_bytes: [u8; 32] = decode_hex(output); + for i in 0..32 { assert(result[i] == output_bytes[i]); } } From c566e37b84970522258e9e51b679c9ade728f966 Mon Sep 17 00:00:00 2001 From: thunkar Date: Fri, 26 Apr 2024 20:56:40 +0000 Subject: [PATCH 09/27] noir padding --- .../dsl/acir_format/aes128_constraint.cpp | 2 ++ .../acvm-repo/blackbox_solver/src/aes128.rs | 3 ++- noir/noir-repo/noir_stdlib/src/aes128.nr | 23 ++++++++++++++++--- .../aes128_encrypt/Prover.toml | 4 ++-- .../aes128_encrypt/src/main.nr | 8 +++---- 5 files changed, 30 insertions(+), 10 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index d4ee4a3f7462..58874344f42f 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -33,11 +33,13 @@ template void create_aes128_constraints(Builder& builder, con }; ASSERT(constraint.inputs.size() % 16 == 0); // check input is multiple of 16 + std::vector converted_inputs; for (size_t i = 0; i < constraint.inputs.size(); i += 16) { std::span inputs{ &constraint.inputs[i], 16 }; converted_inputs.emplace_back(convert_input(inputs)); } + std::vector converted_outputs; for (size_t i = 0; i < constraint.outputs.size(); i += 16) { std::span outputs{ &constraint.outputs[i], 16 }; diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs index a4c6a2287443..3cc47353e27e 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs @@ -6,7 +6,8 @@ pub fn aes128_encrypt( iv: [u8; 16], key: [u8; 16], ) -> Result, BlackBoxResolutionError> { - let cipher = Cipher::new_128(&key); + let mut cipher = Cipher::new_128(&key); + cipher.set_auto_padding(false); let encrypted = cipher.cbc_encrypt(&iv, inputs); Ok(encrypted) } diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index 63f06f08a802..64f052a0c94b 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -1,5 +1,22 @@ -#[foreign(aes128_encrypt)] -pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {} +use crate::println; #[foreign(aes128_encrypt)] -pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {} +fn _aes128_encrypt(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {} + +// PKCS#7 padding +fn pad(input: [u8]) -> [u8] { + let mut padded = input; + let padding = 16 - (input.len() % 16); + for _i in 0..padding { + padded = padded.push_back(padding as u8); + } + padded +} + +pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] { + _aes128_encrypt(pad(input), iv, key) +} + +pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] { + _aes128_encrypt(pad(input.as_slice()), iv, key) +} diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml index 1b2b8c3cdf1a..b6b684790e1a 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/Prover.toml @@ -1,4 +1,4 @@ -inputs = "kevlovesrust0000" +inputs = "kevlovesrust" iv = "0000000000000000" key = "0000000000000000" -output = "72BD0145395756CE2E0ADCCB198299D357839514C4AB014CA0FC47274CA466AA" \ No newline at end of file +output = "F40E7EACAB28D0BAADB8E269EE7ACDBF" \ No newline at end of file diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index 300f2e96aa15..ea219b141ffb 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -21,15 +21,15 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { } result } -fn main(inputs: str<16>, iv: str<16>, key: str<16>, output: str<64>) { +fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { let mut bytes: [u8] = &[]; let input_as_bytes = inputs.as_bytes(); - for i in 0..16 { + for i in 0..12 { bytes = bytes.push_back(input_as_bytes[i]); } let result = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes()); - let output_bytes: [u8; 32] = decode_hex(output); - for i in 0..32 { + let output_bytes: [u8; 16] = decode_hex(output); + for i in 0..16 { assert(result[i] == output_bytes[i]); } } From f584bf85c1c6c62ec5145f255ef8b01804698f06 Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 08:35:18 +0000 Subject: [PATCH 10/27] correctly sized outputs --- .../dsl/acir_format/aes128_constraint.cpp | 7 ------- .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 11 +++++++---- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index 58874344f42f..5a04f615ca63 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -46,16 +46,9 @@ template void create_aes128_constraints(Builder& builder, con converted_outputs.emplace_back(convert_output(outputs)); } - printf("input buffer size = %lu \n", constraint.inputs.size()); - printf("converted input buffer size = %lu \n", converted_inputs.size()); - const auto output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc( converted_inputs, convert_input(constraint.iv), convert_input(constraint.key)); - printf("generated output buffer size = %lu \n", output_bytes.size()); - printf("output buffer size = %lu \n", constraint.outputs.size()); - printf("converted output buffer size = %lu \n", converted_outputs.size()); - for (size_t i = 0; i < output_bytes.size(); ++i) { builder.assert_equal(output_bytes[i].normalize().witness_index, converted_outputs[i].normalize().witness_index); } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs index ce60354256f5..843f7049d401 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs @@ -1301,14 +1301,17 @@ impl AcirContext { } BlackBoxFunc::AES128Encrypt => { let invalid_input = "aes128_encrypt - operation requires a plaintext to encrypt"; - let aes_block_size = 16; output_count = match inputs.first().expect(invalid_input) { AcirValue::Array(values) => { let input_size = values.len(); - Ok::( - input_size + (aes_block_size - (input_size % aes_block_size)), - ) + if input_size % 16 != 0 { + return Err(RuntimeError::InternalError(InternalError::General { + message: "aes128_encrypt input size must be a multiple of the block size (16)".to_string(), + call_stack: self.get_call_stack(), + })); + } + Ok::(input_size) } _ => { return Err(RuntimeError::InternalError(InternalError::General { From 26e7861503a476304dccf090fed0220879674478 Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 09:02:55 +0000 Subject: [PATCH 11/27] merge changes --- .../compiler/noirc_evaluator/src/brillig/brillig_ir.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs index ded41e02bdae..874576f8dafa 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs @@ -144,6 +144,14 @@ pub(crate) mod tests { pub(crate) struct DummyBlackBoxSolver; impl BlackBoxFunctionSolver for DummyBlackBoxSolver { + fn aes128_encrypt( + &self, + inputs: &[u8], + iv: [u8; 16], + key: [u8; 16], + ) -> Result, BlackBoxResolutionError> { + Ok(vec![0_u8; inputs.len()]) + } fn schnorr_verify( &self, _public_key_x: &FieldElement, From 50d7b40796b85682c4a3b0b212fb937030d354e7 Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 11:53:06 +0000 Subject: [PATCH 12/27] fixed tests --- .../noir-repo/acvm-repo/acir/codegen/acir.cpp | 60 ++++++++++++++++++- .../acir/tests/test_program_serialization.rs | 17 +++--- .../test/shared/fixed_base_scalar_mul.ts | 6 +- .../acvm-repo/acvm_js/test/shared/pedersen.ts | 4 +- .../acvm_js/test/shared/schnorr_verify.ts | 4 +- 5 files changed, 74 insertions(+), 17 deletions(-) diff --git a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp index 40b0d708418b..3b21b92142cd 100644 --- a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp +++ b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp @@ -629,6 +629,17 @@ namespace Program { struct BlackBoxOp { + struct AES128Encrypt { + Program::HeapVector inputs; + Program::HeapArray iv; + Program::HeapArray key; + Program::HeapVector outputs; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + struct Sha256 { Program::HeapVector message; Program::HeapArray output; @@ -831,7 +842,7 @@ namespace Program { static Sha256Compression bincodeDeserialize(std::vector); }; - std::variant value; + std::variant value; friend bool operator==(const BlackBoxOp&, const BlackBoxOp&); std::vector bincodeSerialize() const; @@ -3321,6 +3332,53 @@ Program::BlackBoxOp serde::Deserializable::deserialize(Dese return obj; } +namespace Program { + + inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, const BlackBoxOp::AES128Encrypt &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.iv == rhs.iv)) { return false; } + if (!(lhs.key == rhs.key)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } + + inline std::vector BlackBoxOp::AES128Encrypt::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::AES128Encrypt BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 +void serde::Serializable::serialize(const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.outputs, serializer); +} + +template <> +template +Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; +} + namespace Program { inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) { diff --git a/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs b/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs index c5912b61cf15..5e80e78272bb 100644 --- a/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs +++ b/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs @@ -77,9 +77,9 @@ fn fixed_base_scalar_mul_circuit() { let bytes = Program::serialize_program(&program); let expected_serialization: Vec = vec![ - 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, + 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 254, 118, 232, 29, 61, 35, 3, 19, 228, 137, 60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135, - 142, 139, 219, 91, 127, 117, 71, 2, 117, 84, 50, 98, 113, 0, 0, 0, + 142, 139, 219, 91, 127, 117, 71, 2, 140, 82, 246, 133, 113, 0, 0, 0, ]; assert_eq!(bytes, expected_serialization) @@ -105,11 +105,10 @@ fn pedersen_circuit() { let bytes = Program::serialize_program(&program); let expected_serialization: Vec = vec![ - 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 9, 10, 0, 0, 4, 115, 149, 255, 127, 88, 8, 133, - 213, 218, 137, 80, 144, 32, 182, 79, 213, 151, 173, 61, 5, 121, 245, 91, 103, 255, 191, 3, - 7, 16, 26, 112, 158, 113, 0, 0, 0, + 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 73, 10, 0, 0, 4, 180, 29, 252, 255, 193, 66, 40, + 76, 77, 179, 34, 20, 36, 136, 237, 83, 245, 101, 107, 79, 65, 94, 253, 214, 217, 255, 239, + 192, 1, 43, 124, 181, 238, 113, 0, 0, 0, ]; - assert_eq!(bytes, expected_serialization) } @@ -152,7 +151,7 @@ fn schnorr_verify_circuit() { let expected_serialization: Vec = vec![ 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 210, 85, 78, 67, 81, 24, 133, 209, 226, 238, 238, 238, 238, 238, 165, 148, 82, 102, 193, 252, 135, 64, 232, 78, 87, 147, 114, 147, 147, 5, - 47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241, 115, 236, 228, 111, 237, 181, + 47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241, 115, 236, 226, 111, 237, 181, 178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 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, @@ -164,8 +163,8 @@ fn schnorr_verify_circuit() { 180, 144, 14, 210, 64, 246, 95, 46, 212, 119, 207, 230, 217, 59, 91, 103, 231, 108, 156, 125, 183, 237, 186, 107, 207, 125, 59, 30, 218, 239, 216, 110, 167, 246, 58, 183, 211, 165, 125, 174, 237, 114, 107, 143, 123, 59, 60, 186, 255, 179, 187, 191, 186, 115, 209, 125, 75, - 238, 90, 118, 207, 138, 59, 54, 110, 214, 184, 91, 161, 233, 158, 255, 190, 63, 165, 188, - 93, 151, 233, 3, 0, 0, + 238, 90, 118, 207, 138, 59, 54, 110, 214, 184, 91, 161, 233, 158, 255, 190, 63, 71, 59, 68, + 130, 233, 3, 0, 0, ]; assert_eq!(bytes, expected_serialization) diff --git a/noir/noir-repo/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts b/noir/noir-repo/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts index 97b5041121a8..c6d185389ffd 100644 --- a/noir/noir-repo/acvm-repo/acvm_js/test/shared/fixed_base_scalar_mul.ts +++ b/noir/noir-repo/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, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 190, 118, 233, 29, 61, 35, 3, 19, 228, 137, - 60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135, 142, 139, 219, 91, 127, 117, 71, 2, 117, 84, 50, 98, 113, - 0, 0, 0, + 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 138, 81, 10, 0, 48, 8, 66, 87, 219, 254, 118, 232, 29, 61, 35, 3, 19, 228, 137, + 60, 91, 149, 139, 26, 119, 242, 145, 31, 117, 114, 163, 135, 142, 139, 219, 91, 127, 117, 71, 2, 140, 82, 246, 133, + 113, 0, 0, 0, ]); export const initialWitnessMap = new Map([ [1, '0x0000000000000000000000000000000000000000000000000000000000000001'], diff --git a/noir/noir-repo/acvm-repo/acvm_js/test/shared/pedersen.ts b/noir/noir-repo/acvm-repo/acvm_js/test/shared/pedersen.ts index e8ddc893d879..6e3ec403d650 100644 --- a/noir/noir-repo/acvm-repo/acvm_js/test/shared/pedersen.ts +++ b/noir/noir-repo/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, 9, 10, 0, 0, 4, 115, 149, 255, 127, 88, 8, 133, 213, 218, 137, 80, 144, 32, - 182, 79, 213, 151, 173, 61, 5, 121, 245, 91, 103, 255, 191, 3, 7, 16, 26, 112, 158, 113, 0, 0, 0, + 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 74, 73, 10, 0, 0, 4, 180, 29, 252, 255, 193, 66, 40, 76, 77, 179, 34, 20, 36, + 136, 237, 83, 245, 101, 107, 79, 65, 94, 253, 214, 217, 255, 239, 192, 1, 43, 124, 181, 238, 113, 0, 0, 0, ]); export const initialWitnessMap = new Map([[1, '0x0000000000000000000000000000000000000000000000000000000000000001']]); diff --git a/noir/noir-repo/acvm-repo/acvm_js/test/shared/schnorr_verify.ts b/noir/noir-repo/acvm-repo/acvm_js/test/shared/schnorr_verify.ts index a207aa12b2c1..05fcc47e3aa6 100644 --- a/noir/noir-repo/acvm-repo/acvm_js/test/shared/schnorr_verify.ts +++ b/noir/noir-repo/acvm-repo/acvm_js/test/shared/schnorr_verify.ts @@ -2,7 +2,7 @@ export const bytecode = Uint8Array.from([ 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 85, 210, 85, 78, 67, 81, 24, 133, 209, 226, 238, 238, 238, 238, 238, 165, 148, 82, 102, 193, 252, 135, 64, 232, 78, 87, 147, 114, 147, 147, 5, 47, 132, 252, 251, 107, 41, 212, 191, 159, 218, 107, 241, - 115, 236, 228, 111, 237, 181, 178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 135, 189, 236, 99, 63, 7, + 115, 236, 226, 111, 237, 181, 178, 173, 246, 186, 107, 175, 157, 29, 236, 100, 23, 27, 175, 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, 62, 243, 133, 175, 77, 59, 230, 123, @@ -11,7 +11,7 @@ export const bytecode = Uint8Array.from([ 210, 72, 250, 72, 27, 233, 34, 77, 164, 135, 180, 144, 14, 210, 64, 246, 95, 46, 212, 119, 207, 230, 217, 59, 91, 103, 231, 108, 156, 125, 183, 237, 186, 107, 207, 125, 59, 30, 218, 239, 216, 110, 167, 246, 58, 183, 211, 165, 125, 174, 237, 114, 107, 143, 123, 59, 60, 186, 255, 179, 187, 191, 186, 115, 209, 125, 75, 238, 90, 118, 207, 138, 59, 54, 110, - 214, 184, 91, 161, 233, 158, 255, 190, 63, 165, 188, 93, 151, 233, 3, 0, 0, + 214, 184, 91, 161, 233, 158, 255, 190, 63, 71, 59, 68, 130, 233, 3, 0, 0, ]); export const initialWitnessMap = new Map([ From 42d89a19b72c2001dbd0332158fa5c60af645900 Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 12:53:36 +0000 Subject: [PATCH 13/27] brillig fixes, comments --- .../dsl/acir_format/aes128_constraint.cpp | 6 +++++- .../brillig/brillig_gen/brillig_black_box.rs | 2 +- .../aes128_encrypt/src/main.nr | 19 ++++++++++++++++++ .../tooling/backend_interface/src/lib.rs | 20 +++++++++---------- 4 files changed, 35 insertions(+), 12 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index 5a04f615ca63..12afb1940b20 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -12,6 +12,7 @@ template void create_aes128_constraints(Builder& builder, con using field_ct = bb::stdlib::field_t; + // Packs 16 bytes from the inputs (plaintext, iv, key) into a field element const auto convert_input = [&](std::span inputs) { field_ct converted = 0; for (const auto& input : inputs) { @@ -22,6 +23,7 @@ template void create_aes128_constraints(Builder& builder, con return converted; }; + // Packs 16 bytes from the outputs (witness indexes) into a field element for comparison const auto convert_output = [&](std::span outputs) { field_ct converted = 0; for (const auto& output : outputs) { @@ -32,8 +34,10 @@ template void create_aes128_constraints(Builder& builder, con return converted; }; - ASSERT(constraint.inputs.size() % 16 == 0); // check input is multiple of 16 + // Check input is multiple of 16. Plaintext is expected to be prepadded, preferably using PKCS7 + ASSERT(constraint.inputs.size() % 16 == 0); + // Perform the conversions from array of bytes to field elements std::vector converted_inputs; for (size_t i = 0; i < constraint.inputs.size(); i += 16) { std::span inputs{ &constraint.inputs[i], 16 }; diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs index 2b1c1bb8d192..2c825863a896 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs @@ -404,7 +404,7 @@ pub(crate) fn convert_black_box_call( BlackBoxFunc::AES128Encrypt => { if let ( [inputs, BrilligVariable::BrilligArray(iv), BrilligVariable::BrilligArray(key)], - [outputs], + [_, outputs], ) = (function_arguments, function_results) { let inputs = convert_array_or_vector(brillig_context, inputs, bb_func); diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index ea219b141ffb..3d16344df453 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -21,6 +21,21 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { } result } + +unconstrained fn cipher_unconstrained(inputs: str<12>, iv: str<16>, key: str<16>) -> [u8; 16] { + let mut bytes: [u8] = &[]; + let input_as_bytes = inputs.as_bytes(); + for i in 0..12 { + bytes = bytes.push_back(input_as_bytes[i]); + } + let result_slice = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes()); + let mut result: [u8; 16] = [0; 16]; + for i in 0..16 { + result[i] = result_slice[i]; + } + result +} + fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { let mut bytes: [u8] = &[]; let input_as_bytes = inputs.as_bytes(); @@ -32,4 +47,8 @@ fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { for i in 0..16 { assert(result[i] == output_bytes[i]); } + let result_unconstrained = cipher_unconstrained(inputs, iv, key); + for i in 0..16 { + assert(result_unconstrained[i] == output_bytes[i]); + } } diff --git a/noir/noir-repo/tooling/backend_interface/src/lib.rs b/noir/noir-repo/tooling/backend_interface/src/lib.rs index eab98852555a..04de47c366ea 100644 --- a/noir/noir-repo/tooling/backend_interface/src/lib.rs +++ b/noir/noir-repo/tooling/backend_interface/src/lib.rs @@ -135,16 +135,16 @@ impl Backend { } } -#[cfg(test)] -mod backend { - use crate::{Backend, BackendError}; +// #[cfg(test)] +// mod backend { +// use crate::{Backend, BackendError}; - #[test] - fn raises_error_on_missing_binary() { - let bad_backend = Backend::new("i_don't_exist".to_string()); +// #[test] +// fn raises_error_on_missing_binary() { +// let bad_backend = Backend::new("i_don't_exist".to_string()); - let binary_path = bad_backend.assert_binary_exists(); +// let binary_path = bad_backend.assert_binary_exists(); - assert!(matches!(binary_path, Err(BackendError::MissingBinary))); - } -} +// assert!(matches!(binary_path, Err(BackendError::MissingBinary))); +// } +// } From 327462916af53e127532ed99de735b3cd1fd0297 Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 12:58:25 +0000 Subject: [PATCH 14/27] comments from review --- .../acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 7 +++---- .../acvm-repo/acvm/src/pwg/blackbox/mod.rs | 6 +++--- .../blackbox_solver/src/curve_specific_solver.rs | 14 -------------- .../acvm-repo/bn254_blackbox_solver/src/lib.rs | 11 +---------- noir/noir-repo/tooling/lsp/src/solver.rs | 9 --------- 5 files changed, 7 insertions(+), 40 deletions(-) diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs index 2b6e921d1e59..ba07a98aeefe 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -3,14 +3,13 @@ use acir::{ native_types::{Witness, WitnessMap}, FieldElement, }; -use acvm_blackbox_solver::BlackBoxFunctionSolver; +use acvm_blackbox_solver::aes128_encrypt; use crate::{pwg::insert_value, OpcodeResolutionError}; use super::utils::{to_u8_array, to_u8_vec}; -pub(super) fn aes128_encrypt( - backend: &impl BlackBoxFunctionSolver, +pub(super) fn solve_aes128_encryption_opcode( initial_witness: &mut WitnessMap, inputs: &[FunctionInput], iv: &[FunctionInput; 16], @@ -22,7 +21,7 @@ pub(super) fn aes128_encrypt( let iv = to_u8_array(initial_witness, iv)?; let key = to_u8_array(initial_witness, key)?; - let cyphertext = backend.aes128_encrypt(&scalars, iv, key)?; + let cyphertext = aes128_encrypt(&scalars, iv, key)?; // Write witness assignments for (output_witness, value) in outputs.iter().zip(cyphertext.into_iter()) { diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs index f4671cd628e5..da3725fd925d 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/mod.rs @@ -6,8 +6,8 @@ use acir::{ use acvm_blackbox_solver::{blake2s, blake3, keccak256, keccakf1600, sha256}; use self::{ - aes128::aes128_encrypt, bigint::AcvmBigIntSolver, hash::solve_poseidon2_permutation_opcode, - pedersen::pedersen_hash, + aes128::solve_aes128_encryption_opcode, bigint::AcvmBigIntSolver, + hash::solve_poseidon2_permutation_opcode, pedersen::pedersen_hash, }; use super::{insert_value, OpcodeNotSolvable, OpcodeResolutionError}; @@ -72,7 +72,7 @@ pub(crate) fn solve( match bb_func { BlackBoxFuncCall::AES128Encrypt { inputs, iv, key, outputs } => { - aes128_encrypt(backend, initial_witness, inputs, iv, key, outputs) + solve_aes128_encryption_opcode(initial_witness, inputs, iv, key, outputs) } BlackBoxFuncCall::AND { lhs, rhs, output } => and(initial_witness, lhs, rhs, output), BlackBoxFuncCall::XOR { lhs, rhs, output } => xor(initial_witness, lhs, rhs, output), diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs index f7f7b159f469..fab67467d9ab 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/curve_specific_solver.rs @@ -7,12 +7,6 @@ use crate::BlackBoxResolutionError; /// /// Returns an [`BlackBoxResolutionError`] if the backend does not support the given [`acir::BlackBoxFunc`]. pub trait BlackBoxFunctionSolver { - fn aes128_encrypt( - &self, - inputs: &[u8], - iv: [u8; 16], - key: [u8; 16], - ) -> Result, BlackBoxResolutionError>; fn schnorr_verify( &self, public_key_x: &FieldElement, @@ -61,14 +55,6 @@ impl StubbedBlackBoxSolver { } impl BlackBoxFunctionSolver for StubbedBlackBoxSolver { - fn aes128_encrypt( - &self, - _inputs: &[u8], - _iv: [u8; 16], - _key: [u8; 16], - ) -> Result, BlackBoxResolutionError> { - Err(Self::fail(BlackBoxFunc::AES128Encrypt)) - } fn schnorr_verify( &self, _public_key_x: &FieldElement, diff --git a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs index ece1b4c4879e..25b10252a784 100644 --- a/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs +++ b/noir/noir-repo/acvm-repo/bn254_blackbox_solver/src/lib.rs @@ -3,7 +3,7 @@ #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))] use acir::{BlackBoxFunc, FieldElement}; -use acvm_blackbox_solver::{aes128_encrypt, BlackBoxFunctionSolver, BlackBoxResolutionError}; +use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError}; mod fixed_base_scalar_mul; mod poseidon2; @@ -48,15 +48,6 @@ impl Default for Bn254BlackBoxSolver { } impl BlackBoxFunctionSolver for Bn254BlackBoxSolver { - fn aes128_encrypt( - &self, - inputs: &[u8], - iv: [u8; 16], - key: [u8; 16], - ) -> Result, BlackBoxResolutionError> { - aes128_encrypt(inputs, iv, key) - } - fn schnorr_verify( &self, public_key_x: &FieldElement, diff --git a/noir/noir-repo/tooling/lsp/src/solver.rs b/noir/noir-repo/tooling/lsp/src/solver.rs index 15363ad1bde6..0fea9b16b54a 100644 --- a/noir/noir-repo/tooling/lsp/src/solver.rs +++ b/noir/noir-repo/tooling/lsp/src/solver.rs @@ -6,15 +6,6 @@ use acvm::BlackBoxFunctionSolver; pub(super) struct WrapperSolver(pub(super) Box); impl BlackBoxFunctionSolver for WrapperSolver { - fn aes128_encrypt( - &self, - inputs: &[u8], - iv: [u8; 16], - key: [u8; 16], - ) -> Result, acvm::BlackBoxResolutionError> { - self.0.aes128_encrypt(inputs, iv, key) - } - fn schnorr_verify( &self, public_key_x: &acvm::FieldElement, From b67547ea973379b03bf6436e5dee2bd4a2f21581 Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 13:04:29 +0000 Subject: [PATCH 15/27] removed fn from trait --- .../compiler/noirc_evaluator/src/brillig/brillig_ir.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs index 874576f8dafa..ded41e02bdae 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs @@ -144,14 +144,6 @@ pub(crate) mod tests { pub(crate) struct DummyBlackBoxSolver; impl BlackBoxFunctionSolver for DummyBlackBoxSolver { - fn aes128_encrypt( - &self, - inputs: &[u8], - iv: [u8; 16], - key: [u8; 16], - ) -> Result, BlackBoxResolutionError> { - Ok(vec![0_u8; inputs.len()]) - } fn schnorr_verify( &self, _public_key_x: &FieldElement, From d68a6cdc70b0a9eef430c2f4e937694a73768f6e Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 13:24:05 +0000 Subject: [PATCH 16/27] temporarily removed brillig test --- .../aes128_encrypt/src/main.nr | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index 3d16344df453..d9bc212a325e 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -22,20 +22,6 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { result } -unconstrained fn cipher_unconstrained(inputs: str<12>, iv: str<16>, key: str<16>) -> [u8; 16] { - let mut bytes: [u8] = &[]; - let input_as_bytes = inputs.as_bytes(); - for i in 0..12 { - bytes = bytes.push_back(input_as_bytes[i]); - } - let result_slice = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes()); - let mut result: [u8; 16] = [0; 16]; - for i in 0..16 { - result[i] = result_slice[i]; - } - result -} - fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { let mut bytes: [u8] = &[]; let input_as_bytes = inputs.as_bytes(); @@ -47,8 +33,4 @@ fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { for i in 0..16 { assert(result[i] == output_bytes[i]); } - let result_unconstrained = cipher_unconstrained(inputs, iv, key); - for i in 0..16 { - assert(result_unconstrained[i] == output_bytes[i]); - } } From 5b1520cfbaa6aac2bbb3dbcae71174efeab3ca2e Mon Sep 17 00:00:00 2001 From: thunkar Date: Mon, 29 Apr 2024 14:55:01 +0000 Subject: [PATCH 17/27] fixed brillig memory corruption ft alvaro --- .../acvm-repo/brillig_vm/src/black_box.rs | 8 +++----- .../brillig/brillig_gen/brillig_black_box.rs | 8 ++++++-- .../aes128_encrypt/src/main.nr | 13 ++++++++++++ .../tooling/backend_interface/src/lib.rs | 20 +++++++++---------- 4 files changed, 32 insertions(+), 17 deletions(-) diff --git a/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs b/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs index a5a809b7c73f..f382505a092e 100644 --- a/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs +++ b/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs @@ -51,11 +51,9 @@ pub(crate) fn evaluate_black_box( BlackBoxResolutionError::Failed(bb_func, "Invalid ley length".to_string()) })?; let cyphertext = aes128_encrypt(&inputs, iv, key)?; - let mut values = Vec::new(); - for byte in cyphertext { - values.push(byte.into()); - } - memory.write_slice(memory.read_ref(outputs.pointer), &values); + + memory.write(outputs.size, cyphertext.len().into()); + memory.write_slice(memory.read_ref(outputs.pointer), &to_value_vec(&cyphertext)); Ok(()) } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs index 2c825863a896..0231dac1d62c 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_black_box.rs @@ -404,17 +404,21 @@ pub(crate) fn convert_black_box_call( BlackBoxFunc::AES128Encrypt => { if let ( [inputs, BrilligVariable::BrilligArray(iv), BrilligVariable::BrilligArray(key)], - [_, outputs], + [BrilligVariable::SingleAddr(out_len), outputs], ) = (function_arguments, function_results) { let inputs = convert_array_or_vector(brillig_context, inputs, bb_func); let outputs = convert_array_or_vector(brillig_context, outputs, bb_func); + let output_vec = outputs.to_heap_vector(); brillig_context.black_box_op_instruction(BlackBoxOp::AES128Encrypt { inputs: inputs.to_heap_vector(), iv: iv.to_heap_array(), key: key.to_heap_array(), - outputs: outputs.to_heap_vector(), + outputs: output_vec, }); + brillig_context.mov_instruction(out_len.address, output_vec.size); + // Returns slice, so we need to allocate memory for it after the fact + brillig_context.increase_free_memory_pointer_instruction(output_vec.size); } else { unreachable!("ICE: AES128Encrypt expects three array arguments, one array result") } diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index d9bc212a325e..f1113b098fd9 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -22,6 +22,15 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { result } +unconstrained fn cipher(plaintext: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] { + let slice_res = std::aes128::aes128_encrypt_slice(plaintext, iv, key); + let mut result = [0; 16]; + for i in 0..16 { + result[i] = slice_res[i]; + } + result +} + fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { let mut bytes: [u8] = &[]; let input_as_bytes = inputs.as_bytes(); @@ -33,4 +42,8 @@ fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { for i in 0..16 { assert(result[i] == output_bytes[i]); } + let unconstrained_result = cipher(bytes, iv.as_bytes(), key.as_bytes()); + for i in 0..16 { + assert(unconstrained_result[i] == output_bytes[i]); + } } diff --git a/noir/noir-repo/tooling/backend_interface/src/lib.rs b/noir/noir-repo/tooling/backend_interface/src/lib.rs index 04de47c366ea..eab98852555a 100644 --- a/noir/noir-repo/tooling/backend_interface/src/lib.rs +++ b/noir/noir-repo/tooling/backend_interface/src/lib.rs @@ -135,16 +135,16 @@ impl Backend { } } -// #[cfg(test)] -// mod backend { -// use crate::{Backend, BackendError}; +#[cfg(test)] +mod backend { + use crate::{Backend, BackendError}; -// #[test] -// fn raises_error_on_missing_binary() { -// let bad_backend = Backend::new("i_don't_exist".to_string()); + #[test] + fn raises_error_on_missing_binary() { + let bad_backend = Backend::new("i_don't_exist".to_string()); -// let binary_path = bad_backend.assert_binary_exists(); + let binary_path = bad_backend.assert_binary_exists(); -// assert!(matches!(binary_path, Err(BackendError::MissingBinary))); -// } -// } + assert!(matches!(binary_path, Err(BackendError::MissingBinary))); + } +} From a977aee9543710e53097131eb534ef357128b8e5 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 07:21:02 +0000 Subject: [PATCH 18/27] comments from PR --- .../cpp/src/barretenberg/dsl/acir_format/acir_format.cpp | 2 +- .../src/barretenberg/dsl/acir_format/aes128_constraint.cpp | 6 +----- noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs | 4 ++-- noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs | 6 +++--- 4 files changed, 7 insertions(+), 11 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp index 9dd1a65b432e..e9f46e0e1ea8 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp @@ -31,7 +31,7 @@ void build_constraints(Builder& builder, AcirFormat const& constraint_system, bo builder.create_range_constraint(constraint.witness, constraint.num_bits, ""); } - // Add keccak constraints + // Add aes128 constraints for (const auto& constraint : constraint_system.aes128_constraints) { create_aes128_constraints(builder, constraint); } diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index 12afb1940b20..86f2855c4839 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -1,9 +1,5 @@ #include "aes128_constraint.hpp" #include "barretenberg/stdlib/encryption/aes128/aes128.hpp" -#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp" -#include "round.hpp" -#include -#include namespace acir_format { @@ -50,7 +46,7 @@ template void create_aes128_constraints(Builder& builder, con converted_outputs.emplace_back(convert_output(outputs)); } - const auto output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc( + const std::vector output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc( converted_inputs, convert_input(constraint.iv), convert_input(constraint.key)); for (size_t i = 0; i < output_bytes.size(); ++i) { diff --git a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs index ba07a98aeefe..c02c59a174fd 100644 --- a/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs +++ b/noir/noir-repo/acvm-repo/acvm/src/pwg/blackbox/aes128.rs @@ -21,10 +21,10 @@ pub(super) fn solve_aes128_encryption_opcode( let iv = to_u8_array(initial_witness, iv)?; let key = to_u8_array(initial_witness, key)?; - let cyphertext = aes128_encrypt(&scalars, iv, key)?; + let ciphertext = aes128_encrypt(&scalars, iv, key)?; // Write witness assignments - for (output_witness, value) in outputs.iter().zip(cyphertext.into_iter()) { + for (output_witness, value) in outputs.iter().zip(ciphertext.into_iter()) { insert_value(output_witness, FieldElement::from(value as u128), initial_witness)?; } diff --git a/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs b/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs index f382505a092e..aa618fc60e9f 100644 --- a/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs +++ b/noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs @@ -50,10 +50,10 @@ pub(crate) fn evaluate_black_box( to_u8_vec(read_heap_array(memory, key)).try_into().map_err(|_| { BlackBoxResolutionError::Failed(bb_func, "Invalid ley length".to_string()) })?; - let cyphertext = aes128_encrypt(&inputs, iv, key)?; + let ciphertext = aes128_encrypt(&inputs, iv, key)?; - memory.write(outputs.size, cyphertext.len().into()); - memory.write_slice(memory.read_ref(outputs.pointer), &to_value_vec(&cyphertext)); + memory.write(outputs.size, ciphertext.len().into()); + memory.write_slice(memory.read_ref(outputs.pointer), &to_value_vec(&ciphertext)); Ok(()) } From 8a5e43eb2e6bea53a68bc4b07f631298a088dda0 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 09:42:54 +0000 Subject: [PATCH 19/27] handle dynamicarray --- .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs index d0ead6de8acd..0ab02f95ad4a 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs @@ -1326,18 +1326,9 @@ impl AcirContext { } BlackBoxFunc::AES128Encrypt => { let invalid_input = "aes128_encrypt - operation requires a plaintext to encrypt"; - - output_count = match inputs.first().expect(invalid_input) { - AcirValue::Array(values) => { - let input_size = values.len(); - if input_size % 16 != 0 { - return Err(RuntimeError::InternalError(InternalError::General { - message: "aes128_encrypt input size must be a multiple of the block size (16)".to_string(), - call_stack: self.get_call_stack(), - })); - } - Ok::(input_size) - } + let input_size = match inputs.first().expect(invalid_input) { + AcirValue::Array(values) => Ok::(values.len()), + AcirValue::DynamicArray(dyn_array) => Ok::(dyn_array.len), _ => { return Err(RuntimeError::InternalError(InternalError::General { message: "aes128_encrypt requires an array of inputs".to_string(), @@ -1345,6 +1336,15 @@ impl AcirContext { })); } }?; + if input_size % 16 != 0 { + return Err(RuntimeError::InternalError(InternalError::General { + message: + "aes128_encrypt input size must be a multiple of the block size (16)" + .to_string(), + call_stack: self.get_call_stack(), + })); + } + output_count = input_size; (vec![], vec![FieldElement::from(output_count as u128)]) } _ => (vec![], vec![]), From 84b050adc946edfc9aa14e98a4b9610b782b0893 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 12:26:00 +0000 Subject: [PATCH 20/27] perf optmizations --- .../dsl/acir_format/aes128_constraint.cpp | 30 ++++++++++++++----- .../acvm-repo/blackbox_solver/src/aes128.rs | 3 +- .../src/ssa/acir_gen/acir_ir/acir_variable.rs | 10 +------ noir/noir-repo/noir_stdlib/src/aes128.nr | 21 ++----------- .../aes128_encrypt/src/main.nr | 13 +++----- noir/noir-repo/test_programs/rebuild.sh | 14 ++++----- 6 files changed, 38 insertions(+), 53 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp index 86f2855c4839..48777aa8136c 100644 --- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp +++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/aes128_constraint.cpp @@ -1,5 +1,8 @@ #include "aes128_constraint.hpp" #include "barretenberg/stdlib/encryption/aes128/aes128.hpp" +#include +#include +#include namespace acir_format { @@ -9,11 +12,16 @@ template void create_aes128_constraints(Builder& builder, con using field_ct = bb::stdlib::field_t; // Packs 16 bytes from the inputs (plaintext, iv, key) into a field element - const auto convert_input = [&](std::span inputs) { + const auto convert_input = [&](std::span inputs, size_t padding) { field_ct converted = 0; - for (const auto& input : inputs) { + for (size_t i = 0; i < 16 - padding; ++i) { converted *= 256; - field_ct byte = field_ct::from_witness_index(&builder, input.witness); + field_ct byte = field_ct::from_witness_index(&builder, inputs[i].witness); + converted += byte; + } + for (size_t i = 0; i < padding; ++i) { + converted *= 256; + field_ct byte = padding; converted += byte; } return converted; @@ -30,14 +38,20 @@ template void create_aes128_constraints(Builder& builder, con return converted; }; - // Check input is multiple of 16. Plaintext is expected to be prepadded, preferably using PKCS7 - ASSERT(constraint.inputs.size() % 16 == 0); + const size_t padding_size = 16 - constraint.inputs.size() % 16; // Perform the conversions from array of bytes to field elements std::vector converted_inputs; for (size_t i = 0; i < constraint.inputs.size(); i += 16) { - std::span inputs{ &constraint.inputs[i], 16 }; - converted_inputs.emplace_back(convert_input(inputs)); + field_ct to_add; + if (i + 16 > constraint.inputs.size()) { + to_add = convert_input( + std::span{ &constraint.inputs[i], 16 - padding_size }, + padding_size); + } else { + to_add = convert_input(std::span{ &constraint.inputs[i], 16 }, 0); + } + converted_inputs.emplace_back(to_add); } std::vector converted_outputs; @@ -47,7 +61,7 @@ template void create_aes128_constraints(Builder& builder, con } const std::vector output_bytes = bb::stdlib::aes128::encrypt_buffer_cbc( - converted_inputs, convert_input(constraint.iv), convert_input(constraint.key)); + converted_inputs, convert_input(constraint.iv, 0), convert_input(constraint.key, 0)); for (size_t i = 0; i < output_bytes.size(); ++i) { builder.assert_equal(output_bytes[i].normalize().witness_index, converted_outputs[i].normalize().witness_index); diff --git a/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs b/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs index 3cc47353e27e..a4c6a2287443 100644 --- a/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs +++ b/noir/noir-repo/acvm-repo/blackbox_solver/src/aes128.rs @@ -6,8 +6,7 @@ pub fn aes128_encrypt( iv: [u8; 16], key: [u8; 16], ) -> Result, BlackBoxResolutionError> { - let mut cipher = Cipher::new_128(&key); - cipher.set_auto_padding(false); + let cipher = Cipher::new_128(&key); let encrypted = cipher.cbc_encrypt(&iv, inputs); Ok(encrypted) } diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs index 0ab02f95ad4a..407cdf0a17f6 100644 --- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs +++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/acir_ir/acir_variable.rs @@ -1336,15 +1336,7 @@ impl AcirContext { })); } }?; - if input_size % 16 != 0 { - return Err(RuntimeError::InternalError(InternalError::General { - message: - "aes128_encrypt input size must be a multiple of the block size (16)" - .to_string(), - call_stack: self.get_call_stack(), - })); - } - output_count = input_size; + output_count = input_size + (16 - input_size % 16); (vec![], vec![FieldElement::from(output_count as u128)]) } _ => (vec![], vec![]), diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index 64f052a0c94b..f78fe7cc6b0c 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -1,22 +1,7 @@ use crate::println; #[foreign(aes128_encrypt)] -fn _aes128_encrypt(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {} +pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {} -// PKCS#7 padding -fn pad(input: [u8]) -> [u8] { - let mut padded = input; - let padding = 16 - (input.len() % 16); - for _i in 0..padding { - padded = padded.push_back(padding as u8); - } - padded -} - -pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] { - _aes128_encrypt(pad(input), iv, key) -} - -pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] { - _aes128_encrypt(pad(input.as_slice()), iv, key) -} +#[foreign(aes128_encrypt)] +pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {} diff --git a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr index f1113b098fd9..f6ed0f309c32 100644 --- a/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr +++ b/noir/noir-repo/test_programs/execution_success/aes128_encrypt/src/main.nr @@ -22,8 +22,8 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { result } -unconstrained fn cipher(plaintext: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] { - let slice_res = std::aes128::aes128_encrypt_slice(plaintext, iv, key); +unconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] { + let slice_res = std::aes128::aes128_encrypt(plaintext, iv, key); let mut result = [0; 16]; for i in 0..16 { result[i] = slice_res[i]; @@ -32,17 +32,12 @@ unconstrained fn cipher(plaintext: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8; 16 } fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) { - let mut bytes: [u8] = &[]; - let input_as_bytes = inputs.as_bytes(); - for i in 0..12 { - bytes = bytes.push_back(input_as_bytes[i]); - } - let result = std::aes128::aes128_encrypt_slice(bytes, iv.as_bytes(), key.as_bytes()); + let result = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); let output_bytes: [u8; 16] = decode_hex(output); for i in 0..16 { assert(result[i] == output_bytes[i]); } - let unconstrained_result = cipher(bytes, iv.as_bytes(), key.as_bytes()); + let unconstrained_result = cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); for i in 0..16 { assert(unconstrained_result[i] == output_bytes[i]); } diff --git a/noir/noir-repo/test_programs/rebuild.sh b/noir/noir-repo/test_programs/rebuild.sh index a3137920fd51..7ad11300e5df 100755 --- a/noir/noir-repo/test_programs/rebuild.sh +++ b/noir/noir-repo/test_programs/rebuild.sh @@ -36,13 +36,13 @@ rm -rf $current_dir/acir_artifacts mkdir -p $current_dir/acir_artifacts # Gather directories to process. -dirs_to_process=() -for dir in $base_path/*; do - if [[ ! -d $dir ]] || [[ " ${excluded_dirs[@]} " =~ " $(basename "$dir") " ]]; then - continue - fi - dirs_to_process+=("$dir") -done +dirs_to_process=("$base_path/aes128_encrypt") +# for dir in $base_path/*; do +# if [[ ! -d $dir ]] || [[ " ${excluded_dirs[@]} " =~ " $(basename "$dir") " ]]; then +# continue +# fi +# dirs_to_process+=("$dir") +# done # Process each directory in parallel pids=() From 6b17570807974f4263baeb7323625ea2e74b2fe6 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 14:17:53 +0000 Subject: [PATCH 21/27] reverted change, removed _as_slice version --- noir/noir-repo/noir_stdlib/src/aes128.nr | 3 --- noir/noir-repo/test_programs/rebuild.sh | 14 +++++++------- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index f78fe7cc6b0c..cc2df0ce5c03 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -2,6 +2,3 @@ use crate::println; #[foreign(aes128_encrypt)] pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {} - -#[foreign(aes128_encrypt)] -pub fn aes128_encrypt_slice(input: [u8], iv: [u8; 16], key: [u8; 16]) -> [u8] {} diff --git a/noir/noir-repo/test_programs/rebuild.sh b/noir/noir-repo/test_programs/rebuild.sh index 7ad11300e5df..a3137920fd51 100755 --- a/noir/noir-repo/test_programs/rebuild.sh +++ b/noir/noir-repo/test_programs/rebuild.sh @@ -36,13 +36,13 @@ rm -rf $current_dir/acir_artifacts mkdir -p $current_dir/acir_artifacts # Gather directories to process. -dirs_to_process=("$base_path/aes128_encrypt") -# for dir in $base_path/*; do -# if [[ ! -d $dir ]] || [[ " ${excluded_dirs[@]} " =~ " $(basename "$dir") " ]]; then -# continue -# fi -# dirs_to_process+=("$dir") -# done +dirs_to_process=() +for dir in $base_path/*; do + if [[ ! -d $dir ]] || [[ " ${excluded_dirs[@]} " =~ " $(basename "$dir") " ]]; then + continue + fi + dirs_to_process+=("$dir") +done # Process each directory in parallel pids=() From 53ef841389c80a97f841997669769c8a89e443e9 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 14:47:46 +0000 Subject: [PATCH 22/27] added docs --- noir/noir-repo/acvm-repo/acir/README.md | 6 ++++ .../acir/tests/test_program_serialization.rs | 4 +-- .../noir/standard_library/black_box_fns.md | 1 + .../cryptographic_primitives/ciphers.mdx | 28 +++++++++++++++++++ noir/noir-repo/noir_stdlib/src/aes128.nr | 2 ++ 5 files changed, 39 insertions(+), 2 deletions(-) create mode 100644 noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx diff --git a/noir/noir-repo/acvm-repo/acir/README.md b/noir/noir-repo/acvm-repo/acir/README.md index e72f7ea178d8..8f484ff2728f 100644 --- a/noir/noir-repo/acvm-repo/acir/README.md +++ b/noir/noir-repo/acvm-repo/acir/README.md @@ -76,6 +76,12 @@ Some more advanced computations assume that the proving system has an 'embedded The black box functions supported by ACIR are: +**AES128Encrypt**: ciphers the provided plaintext using AES128 in CBC mode, padding the input using PKCS#7. +- inputs: byte array [u8; N] +- iv: initialization vector [u8; 16] +- key: user key [u8; 16] +- outputs: byte vector [u8] of length `input.len() + (16 - input.len() % 16)`` + **AND**: performs the bitwise AND of lhs and rhs. bit_size must be the same for both inputs. - lhs: (witness, bit_size) - rhs: (witness, bit_size) diff --git a/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs b/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs index 839c4d33373e..4abb8196e18e 100644 --- a/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs +++ b/noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs @@ -108,9 +108,9 @@ fn variable_base_scalar_mul_circuit() { let bytes = Program::serialize_program(&program); let expected_serialization: Vec = vec![ - 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 139, 65, 10, 0, 32, 8, 4, 213, 172, 46, 61, 186, + 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 139, 65, 10, 0, 32, 8, 4, 213, 172, 78, 253, 185, 167, 103, 52, 65, 185, 176, 140, 44, 142, 202, 73, 143, 42, 247, 230, 128, 51, 106, 176, - 64, 135, 53, 218, 112, 252, 113, 141, 223, 187, 9, 155, 36, 231, 203, 2, 176, 218, 19, 62, + 64, 135, 53, 218, 112, 252, 113, 141, 223, 187, 9, 155, 36, 231, 203, 2, 189, 15, 68, 136, 137, 0, 0, 0, ]; diff --git a/noir/noir-repo/docs/docs/noir/standard_library/black_box_fns.md b/noir/noir-repo/docs/docs/noir/standard_library/black_box_fns.md index be8c65679c31..8ebbc1d22d6b 100644 --- a/noir/noir-repo/docs/docs/noir/standard_library/black_box_fns.md +++ b/noir/noir-repo/docs/docs/noir/standard_library/black_box_fns.md @@ -12,6 +12,7 @@ The ACVM spec defines a set of blackbox functions which backends will be expecte Here is a list of the current black box functions: +- [AES128](./cryptographic_primitives/ciphers.mdx#aes128) - [SHA256](./cryptographic_primitives/hashes.mdx#sha256) - [Schnorr signature verification](./cryptographic_primitives/schnorr.mdx) - [Blake2s](./cryptographic_primitives/hashes.mdx#blake2s) diff --git a/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx b/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx new file mode 100644 index 000000000000..0103791d2e43 --- /dev/null +++ b/noir/noir-repo/docs/docs/noir/standard_library/cryptographic_primitives/ciphers.mdx @@ -0,0 +1,28 @@ +--- +title: Ciphers +description: + Learn about the implemented ciphers ready to use for any Noir project +keywords: + [ciphers, Noir project, aes128, encrypt] +sidebar_position: 0 +--- + +import BlackBoxInfo from '@site/src/components/Notes/_blackbox.mdx'; + +## aes128 + +Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is automatically performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`. + +#include_code aes128 noir_stdlib/src/aes128.nr rust + +```rust +fn main() { + let input: [u8; 4] = [0, 12, 3, 15] // Random bytes, will be padded to 16 bytes. + let iv: [u8; 16] = [0; 16]; // Initialisation vector + let key: [u8; 16] = [0; 16] // AES key + let ciphertext = std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()); // In this case, the output length will be 16 bytes. +} +``` + + + \ No newline at end of file diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index cc2df0ce5c03..82f5cdbae605 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -1,4 +1,6 @@ use crate::println; +// docs:start:aes128 #[foreign(aes128_encrypt)] pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {} +// docs:end:aes128 From 90c72fde87ee742337ca258d37f79a5ca301680d Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 15:01:05 +0000 Subject: [PATCH 23/27] updated codegen --- .../noir-repo/acvm-repo/acir/codegen/acir.cpp | 12025 +++++++--------- 1 file changed, 5065 insertions(+), 6960 deletions(-) diff --git a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp index 5b88c7bb9bfb..a3f051b4b367 100644 --- a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp +++ b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp @@ -1,8999 +1,7104 @@ #pragma once -#include "bincode.hpp" #include "serde.hpp" +#include "bincode.hpp" namespace Program { -struct Witness { - uint32_t value; - - friend bool operator==(const Witness &, const Witness &); - std::vector bincodeSerialize() const; - static Witness bincodeDeserialize(std::vector); -}; - -struct FunctionInput { - Program::Witness witness; - uint32_t num_bits; - - friend bool operator==(const FunctionInput &, const FunctionInput &); - std::vector bincodeSerialize() const; - static FunctionInput bincodeDeserialize(std::vector); -}; - -struct BlackBoxFuncCall { - - struct AES128Encrypt { - std::vector inputs; - std::array iv; - std::array key; - std::vector outputs; - - friend bool operator==(const AES128Encrypt &, const AES128Encrypt &); - std::vector bincodeSerialize() const; - static AES128Encrypt bincodeDeserialize(std::vector); - }; - - struct AND { - Program::FunctionInput lhs; - Program::FunctionInput rhs; - Program::Witness output; - - friend bool operator==(const AND &, const AND &); - std::vector bincodeSerialize() const; - static AND bincodeDeserialize(std::vector); - }; - - struct XOR { - Program::FunctionInput lhs; - Program::FunctionInput rhs; - Program::Witness output; - - friend bool operator==(const XOR &, const XOR &); - std::vector bincodeSerialize() const; - static XOR bincodeDeserialize(std::vector); - }; - - struct RANGE { - Program::FunctionInput input; - - friend bool operator==(const RANGE &, const RANGE &); - std::vector bincodeSerialize() const; - static RANGE bincodeDeserialize(std::vector); - }; - - struct SHA256 { - std::vector inputs; - std::array outputs; - - friend bool operator==(const SHA256 &, const SHA256 &); - std::vector bincodeSerialize() const; - static SHA256 bincodeDeserialize(std::vector); - }; - - struct Blake2s { - std::vector inputs; - std::array outputs; - - friend bool operator==(const Blake2s &, const Blake2s &); - std::vector bincodeSerialize() const; - static Blake2s bincodeDeserialize(std::vector); - }; - - struct Blake3 { - std::vector inputs; - std::array outputs; - - friend bool operator==(const Blake3 &, const Blake3 &); - std::vector bincodeSerialize() const; - static Blake3 bincodeDeserialize(std::vector); - }; - - struct SchnorrVerify { - Program::FunctionInput public_key_x; - Program::FunctionInput public_key_y; - std::array signature; - std::vector message; - Program::Witness output; - - friend bool operator==(const SchnorrVerify &, const SchnorrVerify &); - std::vector bincodeSerialize() const; - static SchnorrVerify bincodeDeserialize(std::vector); - }; - - struct PedersenCommitment { - std::vector inputs; - uint32_t domain_separator; - std::array outputs; - - friend bool operator==(const PedersenCommitment &, - const PedersenCommitment &); - std::vector bincodeSerialize() const; - static PedersenCommitment bincodeDeserialize(std::vector); - }; - - struct PedersenHash { - std::vector inputs; - uint32_t domain_separator; - Program::Witness output; - - friend bool operator==(const PedersenHash &, const PedersenHash &); - std::vector bincodeSerialize() const; - static PedersenHash bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256k1 { - std::array public_key_x; - std::array public_key_y; - std::array signature; - std::array hashed_message; - Program::Witness output; - - friend bool operator==(const EcdsaSecp256k1 &, const EcdsaSecp256k1 &); - std::vector bincodeSerialize() const; - static EcdsaSecp256k1 bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256r1 { - std::array public_key_x; - std::array public_key_y; - std::array signature; - std::array hashed_message; - Program::Witness output; - - friend bool operator==(const EcdsaSecp256r1 &, const EcdsaSecp256r1 &); - std::vector bincodeSerialize() const; - static EcdsaSecp256r1 bincodeDeserialize(std::vector); - }; - - struct FixedBaseScalarMul { - Program::FunctionInput low; - Program::FunctionInput high; - std::array outputs; - - friend bool operator==(const FixedBaseScalarMul &, - const FixedBaseScalarMul &); - std::vector bincodeSerialize() const; - static FixedBaseScalarMul bincodeDeserialize(std::vector); - }; - - struct VariableBaseScalarMul { - Program::FunctionInput point_x; - Program::FunctionInput point_y; - Program::FunctionInput scalar_low; - Program::FunctionInput scalar_high; - std::array outputs; - - friend bool operator==(const VariableBaseScalarMul &, - const VariableBaseScalarMul &); - std::vector bincodeSerialize() const; - static VariableBaseScalarMul bincodeDeserialize(std::vector); - }; - - struct EmbeddedCurveAdd { - Program::FunctionInput input1_x; - Program::FunctionInput input1_y; - Program::FunctionInput input2_x; - Program::FunctionInput input2_y; - std::array outputs; - - friend bool operator==(const EmbeddedCurveAdd &, const EmbeddedCurveAdd &); - std::vector bincodeSerialize() const; - static EmbeddedCurveAdd bincodeDeserialize(std::vector); - }; - - struct Keccak256 { - std::vector inputs; - Program::FunctionInput var_message_size; - std::array outputs; - - friend bool operator==(const Keccak256 &, const Keccak256 &); - std::vector bincodeSerialize() const; - static Keccak256 bincodeDeserialize(std::vector); - }; - - struct Keccakf1600 { - std::array inputs; - std::array outputs; - - friend bool operator==(const Keccakf1600 &, const Keccakf1600 &); - std::vector bincodeSerialize() const; - static Keccakf1600 bincodeDeserialize(std::vector); - }; - - struct RecursiveAggregation { - std::vector verification_key; - std::vector proof; - std::vector public_inputs; - Program::FunctionInput key_hash; - - friend bool operator==(const RecursiveAggregation &, - const RecursiveAggregation &); - std::vector bincodeSerialize() const; - static RecursiveAggregation bincodeDeserialize(std::vector); - }; - - struct BigIntAdd { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntAdd &, const BigIntAdd &); - std::vector bincodeSerialize() const; - static BigIntAdd bincodeDeserialize(std::vector); - }; - - struct BigIntSub { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntSub &, const BigIntSub &); - std::vector bincodeSerialize() const; - static BigIntSub bincodeDeserialize(std::vector); - }; - - struct BigIntMul { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntMul &, const BigIntMul &); - std::vector bincodeSerialize() const; - static BigIntMul bincodeDeserialize(std::vector); - }; - - struct BigIntDiv { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntDiv &, const BigIntDiv &); - std::vector bincodeSerialize() const; - static BigIntDiv bincodeDeserialize(std::vector); - }; - - struct BigIntFromLeBytes { - std::vector inputs; - std::vector modulus; - uint32_t output; - - friend bool operator==(const BigIntFromLeBytes &, - const BigIntFromLeBytes &); - std::vector bincodeSerialize() const; - static BigIntFromLeBytes bincodeDeserialize(std::vector); - }; - - struct BigIntToLeBytes { - uint32_t input; - std::vector outputs; - - friend bool operator==(const BigIntToLeBytes &, const BigIntToLeBytes &); - std::vector bincodeSerialize() const; - static BigIntToLeBytes bincodeDeserialize(std::vector); - }; - - struct Poseidon2Permutation { - std::vector inputs; - std::vector outputs; - uint32_t len; - - friend bool operator==(const Poseidon2Permutation &, - const Poseidon2Permutation &); - std::vector bincodeSerialize() const; - static Poseidon2Permutation bincodeDeserialize(std::vector); - }; - - struct Sha256Compression { - std::array inputs; - std::array hash_values; - std::array outputs; - - friend bool operator==(const Sha256Compression &, - const Sha256Compression &); - std::vector bincodeSerialize() const; - static Sha256Compression bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BlackBoxFuncCall &, const BlackBoxFuncCall &); - std::vector bincodeSerialize() const; - static BlackBoxFuncCall bincodeDeserialize(std::vector); -}; - -struct BlockId { - uint32_t value; - - friend bool operator==(const BlockId &, const BlockId &); - std::vector bincodeSerialize() const; - static BlockId bincodeDeserialize(std::vector); -}; - -struct Expression { - std::vector> - mul_terms; - std::vector> linear_combinations; - std::string q_c; - - friend bool operator==(const Expression &, const Expression &); - std::vector bincodeSerialize() const; - static Expression bincodeDeserialize(std::vector); -}; - -struct BrilligInputs { - - struct Single { - Program::Expression value; - - friend bool operator==(const Single &, const Single &); - std::vector bincodeSerialize() const; - static Single bincodeDeserialize(std::vector); - }; - - struct Array { - std::vector value; - - friend bool operator==(const Array &, const Array &); - std::vector bincodeSerialize() const; - static Array bincodeDeserialize(std::vector); - }; - - struct MemoryArray { - Program::BlockId value; - - friend bool operator==(const MemoryArray &, const MemoryArray &); - std::vector bincodeSerialize() const; - static MemoryArray bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const BrilligInputs &, const BrilligInputs &); - std::vector bincodeSerialize() const; - static BrilligInputs bincodeDeserialize(std::vector); -}; - -struct BrilligOutputs { - - struct Simple { - Program::Witness value; - - friend bool operator==(const Simple &, const Simple &); - std::vector bincodeSerialize() const; - static Simple bincodeDeserialize(std::vector); - }; - - struct Array { - std::vector value; - - friend bool operator==(const Array &, const Array &); - std::vector bincodeSerialize() const; - static Array bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const BrilligOutputs &, const BrilligOutputs &); - std::vector bincodeSerialize() const; - static BrilligOutputs bincodeDeserialize(std::vector); -}; - -struct Directive { - - struct ToLeRadix { - Program::Expression a; - std::vector b; - uint32_t radix; - - friend bool operator==(const ToLeRadix &, const ToLeRadix &); - std::vector bincodeSerialize() const; - static ToLeRadix bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const Directive &, const Directive &); - std::vector bincodeSerialize() const; - static Directive bincodeDeserialize(std::vector); -}; - -struct MemOp { - Program::Expression operation; - Program::Expression index; - Program::Expression value; - - friend bool operator==(const MemOp &, const MemOp &); - std::vector bincodeSerialize() const; - static MemOp bincodeDeserialize(std::vector); -}; - -struct Opcode { - - struct AssertZero { - Program::Expression value; - - friend bool operator==(const AssertZero &, const AssertZero &); - std::vector bincodeSerialize() const; - static AssertZero bincodeDeserialize(std::vector); - }; - - struct BlackBoxFuncCall { - Program::BlackBoxFuncCall value; - - friend bool operator==(const BlackBoxFuncCall &, const BlackBoxFuncCall &); - std::vector bincodeSerialize() const; - static BlackBoxFuncCall bincodeDeserialize(std::vector); - }; - - struct Directive { - Program::Directive value; - - friend bool operator==(const Directive &, const Directive &); - std::vector bincodeSerialize() const; - static Directive bincodeDeserialize(std::vector); - }; - - struct MemoryOp { - Program::BlockId block_id; - Program::MemOp op; - std::optional predicate; - - friend bool operator==(const MemoryOp &, const MemoryOp &); - std::vector bincodeSerialize() const; - static MemoryOp bincodeDeserialize(std::vector); - }; - - struct MemoryInit { - Program::BlockId block_id; - std::vector init; - - friend bool operator==(const MemoryInit &, const MemoryInit &); - std::vector bincodeSerialize() const; - static MemoryInit bincodeDeserialize(std::vector); - }; - - struct BrilligCall { - uint32_t id; - std::vector inputs; - std::vector outputs; - std::optional predicate; - - friend bool operator==(const BrilligCall &, const BrilligCall &); - std::vector bincodeSerialize() const; - static BrilligCall bincodeDeserialize(std::vector); - }; - - struct Call { - uint32_t id; - std::vector inputs; - std::vector outputs; - std::optional predicate; - - friend bool operator==(const Call &, const Call &); - std::vector bincodeSerialize() const; - static Call bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const Opcode &, const Opcode &); - std::vector bincodeSerialize() const; - static Opcode bincodeDeserialize(std::vector); -}; - -struct BinaryFieldOp { - - struct Add { - friend bool operator==(const Add &, const Add &); - std::vector bincodeSerialize() const; - static Add bincodeDeserialize(std::vector); - }; - - struct Sub { - friend bool operator==(const Sub &, const Sub &); - std::vector bincodeSerialize() const; - static Sub bincodeDeserialize(std::vector); - }; - - struct Mul { - friend bool operator==(const Mul &, const Mul &); - std::vector bincodeSerialize() const; - static Mul bincodeDeserialize(std::vector); - }; - - struct Div { - friend bool operator==(const Div &, const Div &); - std::vector bincodeSerialize() const; - static Div bincodeDeserialize(std::vector); - }; - - struct IntegerDiv { - friend bool operator==(const IntegerDiv &, const IntegerDiv &); - std::vector bincodeSerialize() const; - static IntegerDiv bincodeDeserialize(std::vector); - }; - - struct Equals { - friend bool operator==(const Equals &, const Equals &); - std::vector bincodeSerialize() const; - static Equals bincodeDeserialize(std::vector); - }; - - struct LessThan { - friend bool operator==(const LessThan &, const LessThan &); - std::vector bincodeSerialize() const; - static LessThan bincodeDeserialize(std::vector); - }; - - struct LessThanEquals { - friend bool operator==(const LessThanEquals &, const LessThanEquals &); - std::vector bincodeSerialize() const; - static LessThanEquals bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BinaryFieldOp &, const BinaryFieldOp &); - std::vector bincodeSerialize() const; - static BinaryFieldOp bincodeDeserialize(std::vector); -}; - -struct BinaryIntOp { - - struct Add { - friend bool operator==(const Add &, const Add &); - std::vector bincodeSerialize() const; - static Add bincodeDeserialize(std::vector); - }; - - struct Sub { - friend bool operator==(const Sub &, const Sub &); - std::vector bincodeSerialize() const; - static Sub bincodeDeserialize(std::vector); - }; - - struct Mul { - friend bool operator==(const Mul &, const Mul &); - std::vector bincodeSerialize() const; - static Mul bincodeDeserialize(std::vector); - }; - - struct Div { - friend bool operator==(const Div &, const Div &); - std::vector bincodeSerialize() const; - static Div bincodeDeserialize(std::vector); - }; - - struct Equals { - friend bool operator==(const Equals &, const Equals &); - std::vector bincodeSerialize() const; - static Equals bincodeDeserialize(std::vector); - }; - - struct LessThan { - friend bool operator==(const LessThan &, const LessThan &); - std::vector bincodeSerialize() const; - static LessThan bincodeDeserialize(std::vector); - }; - - struct LessThanEquals { - friend bool operator==(const LessThanEquals &, const LessThanEquals &); - std::vector bincodeSerialize() const; - static LessThanEquals bincodeDeserialize(std::vector); - }; - - struct And { - friend bool operator==(const And &, const And &); - std::vector bincodeSerialize() const; - static And bincodeDeserialize(std::vector); - }; - - struct Or { - friend bool operator==(const Or &, const Or &); - std::vector bincodeSerialize() const; - static Or bincodeDeserialize(std::vector); - }; - - struct Xor { - friend bool operator==(const Xor &, const Xor &); - std::vector bincodeSerialize() const; - static Xor bincodeDeserialize(std::vector); - }; - - struct Shl { - friend bool operator==(const Shl &, const Shl &); - std::vector bincodeSerialize() const; - static Shl bincodeDeserialize(std::vector); - }; - - struct Shr { - friend bool operator==(const Shr &, const Shr &); - std::vector bincodeSerialize() const; - static Shr bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BinaryIntOp &, const BinaryIntOp &); - std::vector bincodeSerialize() const; - static BinaryIntOp bincodeDeserialize(std::vector); -}; - -struct MemoryAddress { - uint64_t value; - - friend bool operator==(const MemoryAddress &, const MemoryAddress &); - std::vector bincodeSerialize() const; - static MemoryAddress bincodeDeserialize(std::vector); -}; - -struct HeapArray { - Program::MemoryAddress pointer; - uint64_t size; - - friend bool operator==(const HeapArray &, const HeapArray &); - std::vector bincodeSerialize() const; - static HeapArray bincodeDeserialize(std::vector); -}; - -struct HeapVector { - Program::MemoryAddress pointer; - Program::MemoryAddress size; - - friend bool operator==(const HeapVector &, const HeapVector &); - std::vector bincodeSerialize() const; - static HeapVector bincodeDeserialize(std::vector); -}; - -struct BlackBoxOp { - - struct AES128Encrypt { - Program::HeapVector inputs; - Program::HeapArray iv; - Program::HeapArray key; - Program::HeapVector outputs; - - friend bool operator==(const AES128Encrypt &, const AES128Encrypt &); - std::vector bincodeSerialize() const; - static AES128Encrypt bincodeDeserialize(std::vector); - }; - - struct Sha256 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Sha256 &, const Sha256 &); - std::vector bincodeSerialize() const; - static Sha256 bincodeDeserialize(std::vector); - }; - - struct Blake2s { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Blake2s &, const Blake2s &); - std::vector bincodeSerialize() const; - static Blake2s bincodeDeserialize(std::vector); - }; - - struct Blake3 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Blake3 &, const Blake3 &); - std::vector bincodeSerialize() const; - static Blake3 bincodeDeserialize(std::vector); - }; - - struct Keccak256 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Keccak256 &, const Keccak256 &); - std::vector bincodeSerialize() const; - static Keccak256 bincodeDeserialize(std::vector); - }; - - struct Keccakf1600 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Keccakf1600 &, const Keccakf1600 &); - std::vector bincodeSerialize() const; - static Keccakf1600 bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256k1 { - 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 bincodeSerialize() const; - static EcdsaSecp256k1 bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256r1 { - 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 bincodeSerialize() const; - static EcdsaSecp256r1 bincodeDeserialize(std::vector); - }; - - struct SchnorrVerify { - 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 bincodeSerialize() const; - static SchnorrVerify bincodeDeserialize(std::vector); - }; - - struct PedersenCommitment { - Program::HeapVector inputs; - Program::MemoryAddress domain_separator; - Program::HeapArray output; - - friend bool operator==(const PedersenCommitment &, - const PedersenCommitment &); - std::vector bincodeSerialize() const; - static PedersenCommitment bincodeDeserialize(std::vector); - }; - - struct PedersenHash { - Program::HeapVector inputs; - Program::MemoryAddress domain_separator; - Program::MemoryAddress output; - - friend bool operator==(const PedersenHash &, const PedersenHash &); - std::vector bincodeSerialize() const; - static PedersenHash bincodeDeserialize(std::vector); - }; - - struct FixedBaseScalarMul { - Program::MemoryAddress low; - Program::MemoryAddress high; - Program::HeapArray result; - - friend bool operator==(const FixedBaseScalarMul &, - const FixedBaseScalarMul &); - std::vector bincodeSerialize() const; - static FixedBaseScalarMul bincodeDeserialize(std::vector); - }; - - struct VariableBaseScalarMul { - Program::MemoryAddress point_x; - Program::MemoryAddress point_y; - Program::MemoryAddress scalar_low; - Program::MemoryAddress scalar_high; - Program::HeapArray result; - - friend bool operator==(const VariableBaseScalarMul &, - const VariableBaseScalarMul &); - std::vector bincodeSerialize() const; - static VariableBaseScalarMul bincodeDeserialize(std::vector); - }; - - struct EmbeddedCurveAdd { - 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 bincodeSerialize() const; - static EmbeddedCurveAdd bincodeDeserialize(std::vector); - }; - - struct BigIntAdd { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntAdd &, const BigIntAdd &); - std::vector bincodeSerialize() const; - static BigIntAdd bincodeDeserialize(std::vector); - }; - - struct BigIntSub { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntSub &, const BigIntSub &); - std::vector bincodeSerialize() const; - static BigIntSub bincodeDeserialize(std::vector); - }; - - struct BigIntMul { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntMul &, const BigIntMul &); - std::vector bincodeSerialize() const; - static BigIntMul bincodeDeserialize(std::vector); - }; - - struct BigIntDiv { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntDiv &, const BigIntDiv &); - std::vector bincodeSerialize() const; - static BigIntDiv bincodeDeserialize(std::vector); - }; - - struct BigIntFromLeBytes { - Program::HeapVector inputs; - Program::HeapVector modulus; - Program::MemoryAddress output; - - friend bool operator==(const BigIntFromLeBytes &, - const BigIntFromLeBytes &); - std::vector bincodeSerialize() const; - static BigIntFromLeBytes bincodeDeserialize(std::vector); - }; - - struct BigIntToLeBytes { - Program::MemoryAddress input; - Program::HeapVector output; - - friend bool operator==(const BigIntToLeBytes &, const BigIntToLeBytes &); - std::vector bincodeSerialize() const; - static BigIntToLeBytes bincodeDeserialize(std::vector); - }; - - struct Poseidon2Permutation { - Program::HeapVector message; - Program::HeapArray output; - Program::MemoryAddress len; - - friend bool operator==(const Poseidon2Permutation &, - const Poseidon2Permutation &); - std::vector bincodeSerialize() const; - static Poseidon2Permutation bincodeDeserialize(std::vector); - }; - - struct Sha256Compression { - Program::HeapVector input; - Program::HeapVector hash_values; - Program::HeapArray output; - - friend bool operator==(const Sha256Compression &, - const Sha256Compression &); - std::vector bincodeSerialize() const; - static Sha256Compression bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BlackBoxOp &, const BlackBoxOp &); - std::vector bincodeSerialize() const; - static BlackBoxOp bincodeDeserialize(std::vector); -}; - -struct HeapValueType; - -struct HeapValueType { - - struct Simple { - uint32_t value; - - friend bool operator==(const Simple &, const Simple &); - std::vector bincodeSerialize() const; - static Simple bincodeDeserialize(std::vector); - }; - - struct Array { - std::vector value_types; - uint64_t size; - - friend bool operator==(const Array &, const Array &); - std::vector bincodeSerialize() const; - static Array bincodeDeserialize(std::vector); - }; - - struct Vector { - std::vector value_types; - - friend bool operator==(const Vector &, const Vector &); - std::vector bincodeSerialize() const; - static Vector bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const HeapValueType &, const HeapValueType &); - std::vector bincodeSerialize() const; - static HeapValueType bincodeDeserialize(std::vector); -}; - -struct ValueOrArray { - - struct MemoryAddress { - Program::MemoryAddress value; - - friend bool operator==(const MemoryAddress &, const MemoryAddress &); - std::vector bincodeSerialize() const; - static MemoryAddress bincodeDeserialize(std::vector); - }; - - struct HeapArray { - Program::HeapArray value; - - friend bool operator==(const HeapArray &, const HeapArray &); - std::vector bincodeSerialize() const; - static HeapArray bincodeDeserialize(std::vector); - }; - - struct HeapVector { - Program::HeapVector value; - - friend bool operator==(const HeapVector &, const HeapVector &); - std::vector bincodeSerialize() const; - static HeapVector bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const ValueOrArray &, const ValueOrArray &); - std::vector bincodeSerialize() const; - static ValueOrArray bincodeDeserialize(std::vector); -}; - -struct BrilligOpcode { - - struct BinaryFieldOp { - Program::MemoryAddress destination; - Program::BinaryFieldOp op; - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - - friend bool operator==(const BinaryFieldOp &, const BinaryFieldOp &); - std::vector bincodeSerialize() const; - static BinaryFieldOp bincodeDeserialize(std::vector); - }; - - struct BinaryIntOp { - Program::MemoryAddress destination; - Program::BinaryIntOp op; - uint32_t bit_size; - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - - friend bool operator==(const BinaryIntOp &, const BinaryIntOp &); - std::vector bincodeSerialize() const; - static BinaryIntOp bincodeDeserialize(std::vector); - }; - - struct Cast { - Program::MemoryAddress destination; - Program::MemoryAddress source; - uint32_t bit_size; - - friend bool operator==(const Cast &, const Cast &); - std::vector bincodeSerialize() const; - static Cast bincodeDeserialize(std::vector); - }; - - struct JumpIfNot { - Program::MemoryAddress condition; - uint64_t location; - - friend bool operator==(const JumpIfNot &, const JumpIfNot &); - std::vector bincodeSerialize() const; - static JumpIfNot bincodeDeserialize(std::vector); - }; - - struct JumpIf { - Program::MemoryAddress condition; - uint64_t location; - - friend bool operator==(const JumpIf &, const JumpIf &); - std::vector bincodeSerialize() const; - static JumpIf bincodeDeserialize(std::vector); - }; - - struct Jump { - uint64_t location; - - friend bool operator==(const Jump &, const Jump &); - std::vector bincodeSerialize() const; - static Jump bincodeDeserialize(std::vector); - }; - - struct CalldataCopy { - Program::MemoryAddress destination_address; - uint64_t size; - uint64_t offset; - - friend bool operator==(const CalldataCopy &, const CalldataCopy &); - std::vector bincodeSerialize() const; - static CalldataCopy bincodeDeserialize(std::vector); - }; - - struct Call { - uint64_t location; - - friend bool operator==(const Call &, const Call &); - std::vector bincodeSerialize() const; - static Call bincodeDeserialize(std::vector); - }; - - struct Const { - Program::MemoryAddress destination; - uint32_t bit_size; - std::string value; - - friend bool operator==(const Const &, const Const &); - std::vector bincodeSerialize() const; - static Const bincodeDeserialize(std::vector); - }; - - struct Return { - friend bool operator==(const Return &, const Return &); - std::vector bincodeSerialize() const; - static Return bincodeDeserialize(std::vector); - }; - - struct ForeignCall { - std::string function; - std::vector destinations; - std::vector destination_value_types; - std::vector inputs; - std::vector input_value_types; - - friend bool operator==(const ForeignCall &, const ForeignCall &); - std::vector bincodeSerialize() const; - static ForeignCall bincodeDeserialize(std::vector); - }; - - struct Mov { - Program::MemoryAddress destination; - Program::MemoryAddress source; - - friend bool operator==(const Mov &, const Mov &); - std::vector bincodeSerialize() const; - static Mov bincodeDeserialize(std::vector); - }; - - 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 bincodeSerialize() const; - static ConditionalMov bincodeDeserialize(std::vector); - }; - - struct Load { - Program::MemoryAddress destination; - Program::MemoryAddress source_pointer; - - friend bool operator==(const Load &, const Load &); - std::vector bincodeSerialize() const; - static Load bincodeDeserialize(std::vector); - }; - - struct Store { - Program::MemoryAddress destination_pointer; - Program::MemoryAddress source; - - friend bool operator==(const Store &, const Store &); - std::vector bincodeSerialize() const; - static Store bincodeDeserialize(std::vector); - }; - - struct BlackBox { - Program::BlackBoxOp value; - - friend bool operator==(const BlackBox &, const BlackBox &); - std::vector bincodeSerialize() const; - static BlackBox bincodeDeserialize(std::vector); - }; - - struct Trap { - Program::HeapArray revert_data; - - friend bool operator==(const Trap &, const Trap &); - std::vector bincodeSerialize() const; - static Trap bincodeDeserialize(std::vector); - }; - - struct Stop { - uint64_t return_data_offset; - uint64_t return_data_size; - - friend bool operator==(const Stop &, const Stop &); - std::vector bincodeSerialize() const; - static Stop bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BrilligOpcode &, const BrilligOpcode &); - std::vector bincodeSerialize() const; - static BrilligOpcode bincodeDeserialize(std::vector); -}; - -struct ExpressionOrMemory { - - struct Expression { - Program::Expression value; - - friend bool operator==(const Expression &, const Expression &); - std::vector bincodeSerialize() const; - static Expression bincodeDeserialize(std::vector); - }; - - struct Memory { - Program::BlockId value; - - friend bool operator==(const Memory &, const Memory &); - std::vector bincodeSerialize() const; - static Memory bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const ExpressionOrMemory &, - const ExpressionOrMemory &); - std::vector bincodeSerialize() const; - static ExpressionOrMemory bincodeDeserialize(std::vector); -}; - -struct AssertionPayload { - - struct StaticString { - std::string value; - - friend bool operator==(const StaticString &, const StaticString &); - std::vector bincodeSerialize() const; - static StaticString bincodeDeserialize(std::vector); - }; - - struct Dynamic { - std::tuple> value; - - friend bool operator==(const Dynamic &, const Dynamic &); - std::vector bincodeSerialize() const; - static Dynamic bincodeDeserialize(std::vector); - }; + struct Witness { + uint32_t value; + + friend bool operator==(const Witness&, const Witness&); + std::vector bincodeSerialize() const; + static Witness bincodeDeserialize(std::vector); + }; + + struct FunctionInput { + Program::Witness witness; + uint32_t num_bits; + + friend bool operator==(const FunctionInput&, const FunctionInput&); + std::vector bincodeSerialize() const; + static FunctionInput bincodeDeserialize(std::vector); + }; + + struct BlackBoxFuncCall { + + struct AES128Encrypt { + std::vector inputs; + std::array iv; + std::array key; + std::vector outputs; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + + struct AND { + Program::FunctionInput lhs; + Program::FunctionInput rhs; + Program::Witness output; + + friend bool operator==(const AND&, const AND&); + std::vector bincodeSerialize() const; + static AND bincodeDeserialize(std::vector); + }; + + struct XOR { + Program::FunctionInput lhs; + Program::FunctionInput rhs; + Program::Witness output; + + friend bool operator==(const XOR&, const XOR&); + std::vector bincodeSerialize() const; + static XOR bincodeDeserialize(std::vector); + }; + + struct RANGE { + Program::FunctionInput input; + + friend bool operator==(const RANGE&, const RANGE&); + std::vector bincodeSerialize() const; + static RANGE bincodeDeserialize(std::vector); + }; + + struct SHA256 { + std::vector inputs; + std::array outputs; + + friend bool operator==(const SHA256&, const SHA256&); + std::vector bincodeSerialize() const; + static SHA256 bincodeDeserialize(std::vector); + }; + + struct Blake2s { + std::vector inputs; + std::array outputs; + + friend bool operator==(const Blake2s&, const Blake2s&); + std::vector bincodeSerialize() const; + static Blake2s bincodeDeserialize(std::vector); + }; + + struct Blake3 { + std::vector inputs; + std::array outputs; + + friend bool operator==(const Blake3&, const Blake3&); + std::vector bincodeSerialize() const; + static Blake3 bincodeDeserialize(std::vector); + }; + + struct SchnorrVerify { + Program::FunctionInput public_key_x; + Program::FunctionInput public_key_y; + std::array signature; + std::vector message; + Program::Witness output; + + friend bool operator==(const SchnorrVerify&, const SchnorrVerify&); + std::vector bincodeSerialize() const; + static SchnorrVerify bincodeDeserialize(std::vector); + }; + + struct PedersenCommitment { + std::vector inputs; + uint32_t domain_separator; + std::array outputs; + + friend bool operator==(const PedersenCommitment&, const PedersenCommitment&); + std::vector bincodeSerialize() const; + static PedersenCommitment bincodeDeserialize(std::vector); + }; + + struct PedersenHash { + std::vector inputs; + uint32_t domain_separator; + Program::Witness output; + + friend bool operator==(const PedersenHash&, const PedersenHash&); + std::vector bincodeSerialize() const; + static PedersenHash bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256k1 { + std::array public_key_x; + std::array public_key_y; + std::array signature; + std::array hashed_message; + Program::Witness output; + + friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&); + std::vector bincodeSerialize() const; + static EcdsaSecp256k1 bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256r1 { + std::array public_key_x; + std::array public_key_y; + std::array signature; + std::array hashed_message; + Program::Witness output; + + friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&); + std::vector bincodeSerialize() const; + static EcdsaSecp256r1 bincodeDeserialize(std::vector); + }; + + struct FixedBaseScalarMul { + Program::FunctionInput low; + Program::FunctionInput high; + std::array outputs; + + friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&); + std::vector bincodeSerialize() const; + static FixedBaseScalarMul bincodeDeserialize(std::vector); + }; + + struct VariableBaseScalarMul { + Program::FunctionInput point_x; + Program::FunctionInput point_y; + Program::FunctionInput scalar_low; + Program::FunctionInput scalar_high; + std::array outputs; + + friend bool operator==(const VariableBaseScalarMul&, const VariableBaseScalarMul&); + std::vector bincodeSerialize() const; + static VariableBaseScalarMul bincodeDeserialize(std::vector); + }; + + struct EmbeddedCurveAdd { + Program::FunctionInput input1_x; + Program::FunctionInput input1_y; + Program::FunctionInput input2_x; + Program::FunctionInput input2_y; + std::array outputs; + + friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&); + std::vector bincodeSerialize() const; + static EmbeddedCurveAdd bincodeDeserialize(std::vector); + }; + + struct Keccak256 { + std::vector inputs; + Program::FunctionInput var_message_size; + std::array outputs; + + friend bool operator==(const Keccak256&, const Keccak256&); + std::vector bincodeSerialize() const; + static Keccak256 bincodeDeserialize(std::vector); + }; + + struct Keccakf1600 { + std::array inputs; + std::array outputs; + + friend bool operator==(const Keccakf1600&, const Keccakf1600&); + std::vector bincodeSerialize() const; + static Keccakf1600 bincodeDeserialize(std::vector); + }; + + struct RecursiveAggregation { + std::vector verification_key; + std::vector proof; + std::vector public_inputs; + Program::FunctionInput key_hash; + + friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&); + std::vector bincodeSerialize() const; + static RecursiveAggregation bincodeDeserialize(std::vector); + }; + + struct BigIntAdd { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntAdd&, const BigIntAdd&); + std::vector bincodeSerialize() const; + static BigIntAdd bincodeDeserialize(std::vector); + }; + + struct BigIntSub { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntSub&, const BigIntSub&); + std::vector bincodeSerialize() const; + static BigIntSub bincodeDeserialize(std::vector); + }; + + struct BigIntMul { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntMul&, const BigIntMul&); + std::vector bincodeSerialize() const; + static BigIntMul bincodeDeserialize(std::vector); + }; + + struct BigIntDiv { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntDiv&, const BigIntDiv&); + std::vector bincodeSerialize() const; + static BigIntDiv bincodeDeserialize(std::vector); + }; + + struct BigIntFromLeBytes { + std::vector inputs; + std::vector modulus; + uint32_t output; + + friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&); + std::vector bincodeSerialize() const; + static BigIntFromLeBytes bincodeDeserialize(std::vector); + }; + + struct BigIntToLeBytes { + uint32_t input; + std::vector outputs; + + friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&); + std::vector bincodeSerialize() const; + static BigIntToLeBytes bincodeDeserialize(std::vector); + }; + + struct Poseidon2Permutation { + std::vector inputs; + std::vector outputs; + uint32_t len; + + friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&); + std::vector bincodeSerialize() const; + static Poseidon2Permutation bincodeDeserialize(std::vector); + }; + + struct Sha256Compression { + std::array inputs; + std::array hash_values; + std::array outputs; + + friend bool operator==(const Sha256Compression&, const Sha256Compression&); + std::vector bincodeSerialize() const; + static Sha256Compression bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); + std::vector bincodeSerialize() const; + static BlackBoxFuncCall bincodeDeserialize(std::vector); + }; + + struct BlockId { + uint32_t value; + + friend bool operator==(const BlockId&, const BlockId&); + std::vector bincodeSerialize() const; + static BlockId bincodeDeserialize(std::vector); + }; + + struct Expression { + std::vector> mul_terms; + std::vector> linear_combinations; + std::string q_c; + + friend bool operator==(const Expression&, const Expression&); + std::vector bincodeSerialize() const; + static Expression bincodeDeserialize(std::vector); + }; + + struct BrilligInputs { + + struct Single { + Program::Expression value; + + friend bool operator==(const Single&, const Single&); + std::vector bincodeSerialize() const; + static Single bincodeDeserialize(std::vector); + }; + + struct Array { + std::vector value; + + friend bool operator==(const Array&, const Array&); + std::vector bincodeSerialize() const; + static Array bincodeDeserialize(std::vector); + }; + + struct MemoryArray { + Program::BlockId value; + + friend bool operator==(const MemoryArray&, const MemoryArray&); + std::vector bincodeSerialize() const; + static MemoryArray bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BrilligInputs&, const BrilligInputs&); + std::vector bincodeSerialize() const; + static BrilligInputs bincodeDeserialize(std::vector); + }; + + struct BrilligOutputs { + + struct Simple { + Program::Witness value; + + friend bool operator==(const Simple&, const Simple&); + std::vector bincodeSerialize() const; + static Simple bincodeDeserialize(std::vector); + }; + + struct Array { + std::vector value; + + friend bool operator==(const Array&, const Array&); + std::vector bincodeSerialize() const; + static Array bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BrilligOutputs&, const BrilligOutputs&); + std::vector bincodeSerialize() const; + static BrilligOutputs bincodeDeserialize(std::vector); + }; + + struct Directive { + + struct ToLeRadix { + Program::Expression a; + std::vector b; + uint32_t radix; + + friend bool operator==(const ToLeRadix&, const ToLeRadix&); + std::vector bincodeSerialize() const; + static ToLeRadix bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const Directive&, const Directive&); + std::vector bincodeSerialize() const; + static Directive bincodeDeserialize(std::vector); + }; + + struct MemOp { + Program::Expression operation; + Program::Expression index; + Program::Expression value; + + friend bool operator==(const MemOp&, const MemOp&); + std::vector bincodeSerialize() const; + static MemOp bincodeDeserialize(std::vector); + }; + + struct Opcode { + + struct AssertZero { + Program::Expression value; + + friend bool operator==(const AssertZero&, const AssertZero&); + std::vector bincodeSerialize() const; + static AssertZero bincodeDeserialize(std::vector); + }; + + struct BlackBoxFuncCall { + Program::BlackBoxFuncCall value; + + friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); + std::vector bincodeSerialize() const; + static BlackBoxFuncCall bincodeDeserialize(std::vector); + }; + + struct Directive { + Program::Directive value; + + friend bool operator==(const Directive&, const Directive&); + std::vector bincodeSerialize() const; + static Directive bincodeDeserialize(std::vector); + }; + + struct MemoryOp { + Program::BlockId block_id; + Program::MemOp op; + std::optional predicate; + + friend bool operator==(const MemoryOp&, const MemoryOp&); + std::vector bincodeSerialize() const; + static MemoryOp bincodeDeserialize(std::vector); + }; + + struct MemoryInit { + Program::BlockId block_id; + std::vector init; + + friend bool operator==(const MemoryInit&, const MemoryInit&); + std::vector bincodeSerialize() const; + static MemoryInit bincodeDeserialize(std::vector); + }; + + struct BrilligCall { + uint32_t id; + std::vector inputs; + std::vector outputs; + std::optional predicate; + + friend bool operator==(const BrilligCall&, const BrilligCall&); + std::vector bincodeSerialize() const; + static BrilligCall bincodeDeserialize(std::vector); + }; + + struct Call { + uint32_t id; + std::vector inputs; + std::vector outputs; + std::optional predicate; + + friend bool operator==(const Call&, const Call&); + std::vector bincodeSerialize() const; + static Call bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const Opcode&, const Opcode&); + std::vector bincodeSerialize() const; + static Opcode bincodeDeserialize(std::vector); + }; + + struct BinaryFieldOp { + + struct Add { + friend bool operator==(const Add&, const Add&); + std::vector bincodeSerialize() const; + static Add bincodeDeserialize(std::vector); + }; + + struct Sub { + friend bool operator==(const Sub&, const Sub&); + std::vector bincodeSerialize() const; + static Sub bincodeDeserialize(std::vector); + }; + + struct Mul { + friend bool operator==(const Mul&, const Mul&); + std::vector bincodeSerialize() const; + static Mul bincodeDeserialize(std::vector); + }; + + struct Div { + friend bool operator==(const Div&, const Div&); + std::vector bincodeSerialize() const; + static Div bincodeDeserialize(std::vector); + }; + + struct IntegerDiv { + friend bool operator==(const IntegerDiv&, const IntegerDiv&); + std::vector bincodeSerialize() const; + static IntegerDiv bincodeDeserialize(std::vector); + }; + + struct Equals { + friend bool operator==(const Equals&, const Equals&); + std::vector bincodeSerialize() const; + static Equals bincodeDeserialize(std::vector); + }; + + struct LessThan { + friend bool operator==(const LessThan&, const LessThan&); + std::vector bincodeSerialize() const; + static LessThan bincodeDeserialize(std::vector); + }; + + struct LessThanEquals { + friend bool operator==(const LessThanEquals&, const LessThanEquals&); + std::vector bincodeSerialize() const; + static LessThanEquals bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&); + std::vector bincodeSerialize() const; + static BinaryFieldOp bincodeDeserialize(std::vector); + }; + + struct BinaryIntOp { + + struct Add { + friend bool operator==(const Add&, const Add&); + std::vector bincodeSerialize() const; + static Add bincodeDeserialize(std::vector); + }; + + struct Sub { + friend bool operator==(const Sub&, const Sub&); + std::vector bincodeSerialize() const; + static Sub bincodeDeserialize(std::vector); + }; + + struct Mul { + friend bool operator==(const Mul&, const Mul&); + std::vector bincodeSerialize() const; + static Mul bincodeDeserialize(std::vector); + }; + + struct Div { + friend bool operator==(const Div&, const Div&); + std::vector bincodeSerialize() const; + static Div bincodeDeserialize(std::vector); + }; + + struct Equals { + friend bool operator==(const Equals&, const Equals&); + std::vector bincodeSerialize() const; + static Equals bincodeDeserialize(std::vector); + }; + + struct LessThan { + friend bool operator==(const LessThan&, const LessThan&); + std::vector bincodeSerialize() const; + static LessThan bincodeDeserialize(std::vector); + }; + + struct LessThanEquals { + friend bool operator==(const LessThanEquals&, const LessThanEquals&); + std::vector bincodeSerialize() const; + static LessThanEquals bincodeDeserialize(std::vector); + }; + + struct And { + friend bool operator==(const And&, const And&); + std::vector bincodeSerialize() const; + static And bincodeDeserialize(std::vector); + }; + + struct Or { + friend bool operator==(const Or&, const Or&); + std::vector bincodeSerialize() const; + static Or bincodeDeserialize(std::vector); + }; + + struct Xor { + friend bool operator==(const Xor&, const Xor&); + std::vector bincodeSerialize() const; + static Xor bincodeDeserialize(std::vector); + }; + + struct Shl { + friend bool operator==(const Shl&, const Shl&); + std::vector bincodeSerialize() const; + static Shl bincodeDeserialize(std::vector); + }; + + struct Shr { + friend bool operator==(const Shr&, const Shr&); + std::vector bincodeSerialize() const; + static Shr bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BinaryIntOp&, const BinaryIntOp&); + std::vector bincodeSerialize() const; + static BinaryIntOp bincodeDeserialize(std::vector); + }; + + struct MemoryAddress { + uint64_t value; + + friend bool operator==(const MemoryAddress&, const MemoryAddress&); + std::vector bincodeSerialize() const; + static MemoryAddress bincodeDeserialize(std::vector); + }; + + struct HeapArray { + Program::MemoryAddress pointer; + uint64_t size; + + friend bool operator==(const HeapArray&, const HeapArray&); + std::vector bincodeSerialize() const; + static HeapArray bincodeDeserialize(std::vector); + }; + + struct HeapVector { + Program::MemoryAddress pointer; + Program::MemoryAddress size; + + friend bool operator==(const HeapVector&, const HeapVector&); + std::vector bincodeSerialize() const; + static HeapVector bincodeDeserialize(std::vector); + }; + + struct BlackBoxOp { + + struct AES128Encrypt { + Program::HeapVector inputs; + Program::HeapArray iv; + Program::HeapArray key; + Program::HeapVector outputs; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + + struct Sha256 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Sha256&, const Sha256&); + std::vector bincodeSerialize() const; + static Sha256 bincodeDeserialize(std::vector); + }; + + struct Blake2s { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Blake2s&, const Blake2s&); + std::vector bincodeSerialize() const; + static Blake2s bincodeDeserialize(std::vector); + }; + + struct Blake3 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Blake3&, const Blake3&); + std::vector bincodeSerialize() const; + static Blake3 bincodeDeserialize(std::vector); + }; + + struct Keccak256 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Keccak256&, const Keccak256&); + std::vector bincodeSerialize() const; + static Keccak256 bincodeDeserialize(std::vector); + }; + + struct Keccakf1600 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Keccakf1600&, const Keccakf1600&); + std::vector bincodeSerialize() const; + static Keccakf1600 bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256k1 { + 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 bincodeSerialize() const; + static EcdsaSecp256k1 bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256r1 { + 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 bincodeSerialize() const; + static EcdsaSecp256r1 bincodeDeserialize(std::vector); + }; + + struct SchnorrVerify { + 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 bincodeSerialize() const; + static SchnorrVerify bincodeDeserialize(std::vector); + }; + + struct PedersenCommitment { + Program::HeapVector inputs; + Program::MemoryAddress domain_separator; + Program::HeapArray output; + + friend bool operator==(const PedersenCommitment&, const PedersenCommitment&); + std::vector bincodeSerialize() const; + static PedersenCommitment bincodeDeserialize(std::vector); + }; + + struct PedersenHash { + Program::HeapVector inputs; + Program::MemoryAddress domain_separator; + Program::MemoryAddress output; + + friend bool operator==(const PedersenHash&, const PedersenHash&); + std::vector bincodeSerialize() const; + static PedersenHash bincodeDeserialize(std::vector); + }; + + struct FixedBaseScalarMul { + Program::MemoryAddress low; + Program::MemoryAddress high; + Program::HeapArray result; + + friend bool operator==(const FixedBaseScalarMul&, const FixedBaseScalarMul&); + std::vector bincodeSerialize() const; + static FixedBaseScalarMul bincodeDeserialize(std::vector); + }; + + struct VariableBaseScalarMul { + Program::MemoryAddress point_x; + Program::MemoryAddress point_y; + Program::MemoryAddress scalar_low; + Program::MemoryAddress scalar_high; + Program::HeapArray result; + + friend bool operator==(const VariableBaseScalarMul&, const VariableBaseScalarMul&); + std::vector bincodeSerialize() const; + static VariableBaseScalarMul bincodeDeserialize(std::vector); + }; + + struct EmbeddedCurveAdd { + 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 bincodeSerialize() const; + static EmbeddedCurveAdd bincodeDeserialize(std::vector); + }; + + struct BigIntAdd { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntAdd&, const BigIntAdd&); + std::vector bincodeSerialize() const; + static BigIntAdd bincodeDeserialize(std::vector); + }; + + struct BigIntSub { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntSub&, const BigIntSub&); + std::vector bincodeSerialize() const; + static BigIntSub bincodeDeserialize(std::vector); + }; + + struct BigIntMul { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntMul&, const BigIntMul&); + std::vector bincodeSerialize() const; + static BigIntMul bincodeDeserialize(std::vector); + }; + + struct BigIntDiv { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntDiv&, const BigIntDiv&); + std::vector bincodeSerialize() const; + static BigIntDiv bincodeDeserialize(std::vector); + }; + + struct BigIntFromLeBytes { + Program::HeapVector inputs; + Program::HeapVector modulus; + Program::MemoryAddress output; + + friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&); + std::vector bincodeSerialize() const; + static BigIntFromLeBytes bincodeDeserialize(std::vector); + }; + + struct BigIntToLeBytes { + Program::MemoryAddress input; + Program::HeapVector output; + + friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&); + std::vector bincodeSerialize() const; + static BigIntToLeBytes bincodeDeserialize(std::vector); + }; + + struct Poseidon2Permutation { + Program::HeapVector message; + Program::HeapArray output; + Program::MemoryAddress len; + + friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&); + std::vector bincodeSerialize() const; + static Poseidon2Permutation bincodeDeserialize(std::vector); + }; + + struct Sha256Compression { + Program::HeapVector input; + Program::HeapVector hash_values; + Program::HeapArray output; + + friend bool operator==(const Sha256Compression&, const Sha256Compression&); + std::vector bincodeSerialize() const; + static Sha256Compression bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BlackBoxOp&, const BlackBoxOp&); + std::vector bincodeSerialize() const; + static BlackBoxOp bincodeDeserialize(std::vector); + }; + + struct HeapValueType; + + struct HeapValueType { + + struct Simple { + uint32_t value; + + friend bool operator==(const Simple&, const Simple&); + std::vector bincodeSerialize() const; + static Simple bincodeDeserialize(std::vector); + }; + + struct Array { + std::vector value_types; + uint64_t size; + + friend bool operator==(const Array&, const Array&); + std::vector bincodeSerialize() const; + static Array bincodeDeserialize(std::vector); + }; + + struct Vector { + std::vector value_types; + + friend bool operator==(const Vector&, const Vector&); + std::vector bincodeSerialize() const; + static Vector bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const HeapValueType&, const HeapValueType&); + std::vector bincodeSerialize() const; + static HeapValueType bincodeDeserialize(std::vector); + }; + + struct ValueOrArray { + + struct MemoryAddress { + Program::MemoryAddress value; + + friend bool operator==(const MemoryAddress&, const MemoryAddress&); + std::vector bincodeSerialize() const; + static MemoryAddress bincodeDeserialize(std::vector); + }; + + struct HeapArray { + Program::HeapArray value; + + friend bool operator==(const HeapArray&, const HeapArray&); + std::vector bincodeSerialize() const; + static HeapArray bincodeDeserialize(std::vector); + }; + + struct HeapVector { + Program::HeapVector value; + + friend bool operator==(const HeapVector&, const HeapVector&); + std::vector bincodeSerialize() const; + static HeapVector bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const ValueOrArray&, const ValueOrArray&); + std::vector bincodeSerialize() const; + static ValueOrArray bincodeDeserialize(std::vector); + }; + + struct BrilligOpcode { + + struct BinaryFieldOp { + Program::MemoryAddress destination; + Program::BinaryFieldOp op; + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + + friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&); + std::vector bincodeSerialize() const; + static BinaryFieldOp bincodeDeserialize(std::vector); + }; + + struct BinaryIntOp { + Program::MemoryAddress destination; + Program::BinaryIntOp op; + uint32_t bit_size; + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + + friend bool operator==(const BinaryIntOp&, const BinaryIntOp&); + std::vector bincodeSerialize() const; + static BinaryIntOp bincodeDeserialize(std::vector); + }; + + struct Cast { + Program::MemoryAddress destination; + Program::MemoryAddress source; + uint32_t bit_size; + + friend bool operator==(const Cast&, const Cast&); + std::vector bincodeSerialize() const; + static Cast bincodeDeserialize(std::vector); + }; + + struct JumpIfNot { + Program::MemoryAddress condition; + uint64_t location; + + friend bool operator==(const JumpIfNot&, const JumpIfNot&); + std::vector bincodeSerialize() const; + static JumpIfNot bincodeDeserialize(std::vector); + }; + + struct JumpIf { + Program::MemoryAddress condition; + uint64_t location; + + friend bool operator==(const JumpIf&, const JumpIf&); + std::vector bincodeSerialize() const; + static JumpIf bincodeDeserialize(std::vector); + }; + + struct Jump { + uint64_t location; + + friend bool operator==(const Jump&, const Jump&); + std::vector bincodeSerialize() const; + static Jump bincodeDeserialize(std::vector); + }; + + struct CalldataCopy { + Program::MemoryAddress destination_address; + uint64_t size; + uint64_t offset; + + friend bool operator==(const CalldataCopy&, const CalldataCopy&); + std::vector bincodeSerialize() const; + static CalldataCopy bincodeDeserialize(std::vector); + }; + + struct Call { + uint64_t location; + + friend bool operator==(const Call&, const Call&); + std::vector bincodeSerialize() const; + static Call bincodeDeserialize(std::vector); + }; + + struct Const { + Program::MemoryAddress destination; + uint32_t bit_size; + std::string value; + + friend bool operator==(const Const&, const Const&); + std::vector bincodeSerialize() const; + static Const bincodeDeserialize(std::vector); + }; + + struct Return { + friend bool operator==(const Return&, const Return&); + std::vector bincodeSerialize() const; + static Return bincodeDeserialize(std::vector); + }; + + struct ForeignCall { + std::string function; + std::vector destinations; + std::vector destination_value_types; + std::vector inputs; + std::vector input_value_types; + + friend bool operator==(const ForeignCall&, const ForeignCall&); + std::vector bincodeSerialize() const; + static ForeignCall bincodeDeserialize(std::vector); + }; + + struct Mov { + Program::MemoryAddress destination; + Program::MemoryAddress source; + + friend bool operator==(const Mov&, const Mov&); + std::vector bincodeSerialize() const; + static Mov bincodeDeserialize(std::vector); + }; + + 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 bincodeSerialize() const; + static ConditionalMov bincodeDeserialize(std::vector); + }; + + struct Load { + Program::MemoryAddress destination; + Program::MemoryAddress source_pointer; + + friend bool operator==(const Load&, const Load&); + std::vector bincodeSerialize() const; + static Load bincodeDeserialize(std::vector); + }; + + struct Store { + Program::MemoryAddress destination_pointer; + Program::MemoryAddress source; + + friend bool operator==(const Store&, const Store&); + std::vector bincodeSerialize() const; + static Store bincodeDeserialize(std::vector); + }; + + struct BlackBox { + Program::BlackBoxOp value; + + friend bool operator==(const BlackBox&, const BlackBox&); + std::vector bincodeSerialize() const; + static BlackBox bincodeDeserialize(std::vector); + }; + + struct Trap { + Program::HeapArray revert_data; + + friend bool operator==(const Trap&, const Trap&); + std::vector bincodeSerialize() const; + static Trap bincodeDeserialize(std::vector); + }; + + struct Stop { + uint64_t return_data_offset; + uint64_t return_data_size; + + friend bool operator==(const Stop&, const Stop&); + std::vector bincodeSerialize() const; + static Stop bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BrilligOpcode&, const BrilligOpcode&); + std::vector bincodeSerialize() const; + static BrilligOpcode bincodeDeserialize(std::vector); + }; + + struct ExpressionOrMemory { - std::variant value; + struct Expression { + Program::Expression value; + + friend bool operator==(const Expression&, const Expression&); + std::vector bincodeSerialize() const; + static Expression bincodeDeserialize(std::vector); + }; + + struct Memory { + Program::BlockId value; + + friend bool operator==(const Memory&, const Memory&); + std::vector bincodeSerialize() const; + static Memory bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const ExpressionOrMemory&, const ExpressionOrMemory&); + std::vector bincodeSerialize() const; + static ExpressionOrMemory bincodeDeserialize(std::vector); + }; - friend bool operator==(const AssertionPayload &, const AssertionPayload &); - std::vector bincodeSerialize() const; - static AssertionPayload bincodeDeserialize(std::vector); -}; + struct AssertionPayload { + + struct StaticString { + std::string value; -struct ExpressionWidth { + friend bool operator==(const StaticString&, const StaticString&); + std::vector bincodeSerialize() const; + static StaticString bincodeDeserialize(std::vector); + }; + + struct Dynamic { + std::tuple> value; + + friend bool operator==(const Dynamic&, const Dynamic&); + std::vector bincodeSerialize() const; + static Dynamic bincodeDeserialize(std::vector); + }; - struct Unbounded { - friend bool operator==(const Unbounded &, const Unbounded &); - std::vector bincodeSerialize() const; - static Unbounded bincodeDeserialize(std::vector); - }; + std::variant value; - struct Bounded { - uint64_t width; + friend bool operator==(const AssertionPayload&, const AssertionPayload&); + std::vector bincodeSerialize() const; + static AssertionPayload bincodeDeserialize(std::vector); + }; - friend bool operator==(const Bounded &, const Bounded &); - std::vector bincodeSerialize() const; - static Bounded bincodeDeserialize(std::vector); - }; + struct ExpressionWidth { - std::variant value; + struct Unbounded { + friend bool operator==(const Unbounded&, const Unbounded&); + std::vector bincodeSerialize() const; + static Unbounded bincodeDeserialize(std::vector); + }; - friend bool operator==(const ExpressionWidth &, const ExpressionWidth &); - std::vector bincodeSerialize() const; - static ExpressionWidth bincodeDeserialize(std::vector); -}; + struct Bounded { + uint64_t width; -struct OpcodeLocation { + friend bool operator==(const Bounded&, const Bounded&); + std::vector bincodeSerialize() const; + static Bounded bincodeDeserialize(std::vector); + }; - struct Acir { - uint64_t value; + std::variant value; - friend bool operator==(const Acir &, const Acir &); - std::vector bincodeSerialize() const; - static Acir bincodeDeserialize(std::vector); - }; + friend bool operator==(const ExpressionWidth&, const ExpressionWidth&); + std::vector bincodeSerialize() const; + static ExpressionWidth bincodeDeserialize(std::vector); + }; - struct Brillig { - uint64_t acir_index; - uint64_t brillig_index; + struct OpcodeLocation { - friend bool operator==(const Brillig &, const Brillig &); - std::vector bincodeSerialize() const; - static Brillig bincodeDeserialize(std::vector); - }; + struct Acir { + uint64_t value; - std::variant value; + friend bool operator==(const Acir&, const Acir&); + std::vector bincodeSerialize() const; + static Acir bincodeDeserialize(std::vector); + }; - friend bool operator==(const OpcodeLocation &, const OpcodeLocation &); - std::vector bincodeSerialize() const; - static OpcodeLocation bincodeDeserialize(std::vector); -}; + struct Brillig { + uint64_t acir_index; + uint64_t brillig_index; -struct PublicInputs { - std::vector value; + friend bool operator==(const Brillig&, const Brillig&); + std::vector bincodeSerialize() const; + static Brillig bincodeDeserialize(std::vector); + }; - friend bool operator==(const PublicInputs &, const PublicInputs &); - std::vector bincodeSerialize() const; - static PublicInputs bincodeDeserialize(std::vector); -}; + std::variant value; -struct Circuit { - uint32_t current_witness_index; - std::vector opcodes; - Program::ExpressionWidth expression_width; - std::vector private_parameters; - Program::PublicInputs public_parameters; - Program::PublicInputs return_values; - std::vector> - assert_messages; - bool recursive; + friend bool operator==(const OpcodeLocation&, const OpcodeLocation&); + std::vector bincodeSerialize() const; + static OpcodeLocation bincodeDeserialize(std::vector); + }; - friend bool operator==(const Circuit &, const Circuit &); - std::vector bincodeSerialize() const; - static Circuit bincodeDeserialize(std::vector); -}; + struct PublicInputs { + std::vector value; -struct BrilligBytecode { - std::vector bytecode; + friend bool operator==(const PublicInputs&, const PublicInputs&); + std::vector bincodeSerialize() const; + static PublicInputs bincodeDeserialize(std::vector); + }; - friend bool operator==(const BrilligBytecode &, const BrilligBytecode &); - std::vector bincodeSerialize() const; - static BrilligBytecode bincodeDeserialize(std::vector); -}; + struct Circuit { + uint32_t current_witness_index; + std::vector opcodes; + Program::ExpressionWidth expression_width; + std::vector private_parameters; + Program::PublicInputs public_parameters; + Program::PublicInputs return_values; + std::vector> assert_messages; + bool recursive; -struct Program { - std::vector functions; - std::vector unconstrained_functions; + friend bool operator==(const Circuit&, const Circuit&); + std::vector bincodeSerialize() const; + static Circuit bincodeDeserialize(std::vector); + }; - friend bool operator==(const Program &, const Program &); - std::vector bincodeSerialize() const; - static Program bincodeDeserialize(std::vector); -}; + struct BrilligBytecode { + std::vector bytecode; + + friend bool operator==(const BrilligBytecode&, const BrilligBytecode&); + std::vector bincodeSerialize() const; + static BrilligBytecode bincodeDeserialize(std::vector); + }; + + struct Program { + std::vector functions; + std::vector unconstrained_functions; + + friend bool operator==(const Program&, const Program&); + std::vector bincodeSerialize() const; + static Program bincodeDeserialize(std::vector); + }; } // end of namespace Program + namespace Program { -inline bool operator==(const AssertionPayload &lhs, - const AssertionPayload &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const AssertionPayload &lhs, const AssertionPayload &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector AssertionPayload::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector AssertionPayload::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline AssertionPayload -AssertionPayload::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline AssertionPayload AssertionPayload::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::AssertionPayload &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::AssertionPayload &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::AssertionPayload -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::AssertionPayload obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::AssertionPayload serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::AssertionPayload obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const AssertionPayload::StaticString &lhs, - const AssertionPayload::StaticString &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const AssertionPayload::StaticString &lhs, const AssertionPayload::StaticString &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -AssertionPayload::StaticString::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector AssertionPayload::StaticString::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline AssertionPayload::StaticString -AssertionPayload::StaticString::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline AssertionPayload::StaticString AssertionPayload::StaticString::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::AssertionPayload::StaticString &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::AssertionPayload::StaticString &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::AssertionPayload::StaticString -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::AssertionPayload::StaticString obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::AssertionPayload::StaticString serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::AssertionPayload::StaticString obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const AssertionPayload::Dynamic &lhs, - const AssertionPayload::Dynamic &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const AssertionPayload::Dynamic &lhs, const AssertionPayload::Dynamic &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -AssertionPayload::Dynamic::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector AssertionPayload::Dynamic::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline AssertionPayload::Dynamic -AssertionPayload::Dynamic::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline AssertionPayload::Dynamic AssertionPayload::Dynamic::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::AssertionPayload::Dynamic -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::AssertionPayload::Dynamic obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::AssertionPayload::Dynamic serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::AssertionPayload::Dynamic obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BinaryFieldOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp -BinaryFieldOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp BinaryFieldOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BinaryFieldOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BinaryFieldOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BinaryFieldOp obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BinaryFieldOp obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Add &lhs, - const BinaryFieldOp::Add &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Add &lhs, const BinaryFieldOp::Add &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Add::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Add::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Add -BinaryFieldOp::Add::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Add BinaryFieldOp::Add::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Add &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Add &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Add -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Add obj; - return obj; +Program::BinaryFieldOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Add obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Sub &lhs, - const BinaryFieldOp::Sub &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Sub &lhs, const BinaryFieldOp::Sub &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Sub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Sub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Sub -BinaryFieldOp::Sub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Sub BinaryFieldOp::Sub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Sub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Sub obj; - return obj; +Program::BinaryFieldOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Sub obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Mul &lhs, - const BinaryFieldOp::Mul &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Mul &lhs, const BinaryFieldOp::Mul &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Mul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Mul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Mul -BinaryFieldOp::Mul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Mul BinaryFieldOp::Mul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Mul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Mul obj; - return obj; +Program::BinaryFieldOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Mul obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Div &lhs, - const BinaryFieldOp::Div &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Div &lhs, const BinaryFieldOp::Div &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Div::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Div::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Div -BinaryFieldOp::Div::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Div BinaryFieldOp::Div::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Div &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Div &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Div -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Div obj; - return obj; +Program::BinaryFieldOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Div obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, - const BinaryFieldOp::IntegerDiv &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) { + return true; + } -inline std::vector -BinaryFieldOp::IntegerDiv::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::IntegerDiv::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::IntegerDiv -BinaryFieldOp::IntegerDiv::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::IntegerDiv BinaryFieldOp::IntegerDiv::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::IntegerDiv -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::IntegerDiv obj; - return obj; +Program::BinaryFieldOp::IntegerDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::IntegerDiv obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Equals &lhs, - const BinaryFieldOp::Equals &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Equals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Equals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Equals -BinaryFieldOp::Equals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Equals BinaryFieldOp::Equals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Equals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Equals obj; - return obj; +Program::BinaryFieldOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Equals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::LessThan &lhs, - const BinaryFieldOp::LessThan &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) { + return true; + } -inline std::vector BinaryFieldOp::LessThan::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::LessThan::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::LessThan -BinaryFieldOp::LessThan::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::LessThan BinaryFieldOp::LessThan::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::LessThan -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::LessThan obj; - return obj; +Program::BinaryFieldOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::LessThan obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, - const BinaryFieldOp::LessThanEquals &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) { + return true; + } -inline std::vector -BinaryFieldOp::LessThanEquals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::LessThanEquals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::LessThanEquals -BinaryFieldOp::LessThanEquals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::LessThanEquals BinaryFieldOp::LessThanEquals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::LessThanEquals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::LessThanEquals obj; - return obj; +Program::BinaryFieldOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::LessThanEquals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BinaryIntOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp BinaryIntOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp BinaryIntOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BinaryIntOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BinaryIntOp serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BinaryIntOp obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BinaryIntOp obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Add &lhs, - const BinaryIntOp::Add &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Add &lhs, const BinaryIntOp::Add &rhs) { + return true; + } -inline std::vector BinaryIntOp::Add::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Add::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Add -BinaryIntOp::Add::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Add BinaryIntOp::Add::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Add &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Add &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Add -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Add obj; - return obj; +Program::BinaryIntOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Add obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Sub &lhs, - const BinaryIntOp::Sub &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Sub &lhs, const BinaryIntOp::Sub &rhs) { + return true; + } -inline std::vector BinaryIntOp::Sub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Sub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Sub -BinaryIntOp::Sub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Sub BinaryIntOp::Sub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Sub &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Sub &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Sub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Sub obj; - return obj; +Program::BinaryIntOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Sub obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Mul &lhs, - const BinaryIntOp::Mul &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Mul &lhs, const BinaryIntOp::Mul &rhs) { + return true; + } -inline std::vector BinaryIntOp::Mul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Mul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Mul -BinaryIntOp::Mul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Mul BinaryIntOp::Mul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Mul &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Mul &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Mul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Mul obj; - return obj; +Program::BinaryIntOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Mul obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Div &lhs, - const BinaryIntOp::Div &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Div &lhs, const BinaryIntOp::Div &rhs) { + return true; + } -inline std::vector BinaryIntOp::Div::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Div::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Div -BinaryIntOp::Div::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Div BinaryIntOp::Div::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Div &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Div &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Div -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Div obj; - return obj; +Program::BinaryIntOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Div obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Equals &lhs, - const BinaryIntOp::Equals &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Equals &lhs, const BinaryIntOp::Equals &rhs) { + return true; + } -inline std::vector BinaryIntOp::Equals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Equals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Equals -BinaryIntOp::Equals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Equals BinaryIntOp::Equals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Equals &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Equals &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Equals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Equals obj; - return obj; +Program::BinaryIntOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Equals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::LessThan &lhs, - const BinaryIntOp::LessThan &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::LessThan &lhs, const BinaryIntOp::LessThan &rhs) { + return true; + } -inline std::vector BinaryIntOp::LessThan::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::LessThan::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::LessThan -BinaryIntOp::LessThan::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::LessThan BinaryIntOp::LessThan::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::LessThan -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::LessThan obj; - return obj; +Program::BinaryIntOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::LessThan obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, - const BinaryIntOp::LessThanEquals &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, const BinaryIntOp::LessThanEquals &rhs) { + return true; + } -inline std::vector -BinaryIntOp::LessThanEquals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::LessThanEquals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::LessThanEquals -BinaryIntOp::LessThanEquals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::LessThanEquals BinaryIntOp::LessThanEquals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::LessThanEquals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::LessThanEquals obj; - return obj; +Program::BinaryIntOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::LessThanEquals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::And &lhs, - const BinaryIntOp::And &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::And &lhs, const BinaryIntOp::And &rhs) { + return true; + } -inline std::vector BinaryIntOp::And::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::And::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::And -BinaryIntOp::And::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::And BinaryIntOp::And::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::And &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::And &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::And -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::And obj; - return obj; +Program::BinaryIntOp::And serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::And obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) { + return true; + } -inline std::vector BinaryIntOp::Or::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Or::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Or -BinaryIntOp::Or::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Or BinaryIntOp::Or::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Or &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Or &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Or -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Or obj; - return obj; +Program::BinaryIntOp::Or serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Or obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Xor &lhs, - const BinaryIntOp::Xor &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Xor &lhs, const BinaryIntOp::Xor &rhs) { + return true; + } -inline std::vector BinaryIntOp::Xor::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Xor::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Xor -BinaryIntOp::Xor::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Xor BinaryIntOp::Xor::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Xor &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Xor &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Xor -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Xor obj; - return obj; +Program::BinaryIntOp::Xor serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Xor obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Shl &lhs, - const BinaryIntOp::Shl &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Shl &lhs, const BinaryIntOp::Shl &rhs) { + return true; + } -inline std::vector BinaryIntOp::Shl::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Shl::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Shl -BinaryIntOp::Shl::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Shl BinaryIntOp::Shl::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Shl &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Shl &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Shl -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Shl obj; - return obj; +Program::BinaryIntOp::Shl serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Shl obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Shr &lhs, - const BinaryIntOp::Shr &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Shr &lhs, const BinaryIntOp::Shr &rhs) { + return true; + } -inline std::vector BinaryIntOp::Shr::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Shr::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Shr -BinaryIntOp::Shr::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Shr BinaryIntOp::Shr::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Shr &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Shr &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Shr -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Shr obj; - return obj; +Program::BinaryIntOp::Shr serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Shr obj; + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall &lhs, - const BlackBoxFuncCall &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall &lhs, const BlackBoxFuncCall &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall -BlackBoxFuncCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall BlackBoxFuncCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BlackBoxFuncCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BlackBoxFuncCall obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BlackBoxFuncCall obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, - const BlackBoxFuncCall::AES128Encrypt &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.iv == rhs.iv)) { - return false; - } - if (!(lhs.key == rhs.key)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, const BlackBoxFuncCall::AES128Encrypt &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.iv == rhs.iv)) { return false; } + if (!(lhs.key == rhs.key)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::AES128Encrypt -BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::AES128Encrypt BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::AES128Encrypt &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.iv, serializer); - serde::Serializable::serialize(obj.key, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AES128Encrypt &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::AES128Encrypt -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::AES128Encrypt obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.iv = serde::Deserializable::deserialize(deserializer); - obj.key = serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::AND &lhs, - const BlackBoxFuncCall::AND &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::AND &lhs, const BlackBoxFuncCall::AND &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::AND::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::AND::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::AND -BlackBoxFuncCall::AND::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::AND BlackBoxFuncCall::AND::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::AND -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::AND obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::AND serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::AND obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::XOR &lhs, - const BlackBoxFuncCall::XOR &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::XOR &lhs, const BlackBoxFuncCall::XOR &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::XOR::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::XOR::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::XOR -BlackBoxFuncCall::XOR::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::XOR BlackBoxFuncCall::XOR::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::XOR -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::XOR obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::XOR serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::XOR obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, - const BlackBoxFuncCall::RANGE &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, const BlackBoxFuncCall::RANGE &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::RANGE::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::RANGE::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::RANGE -BlackBoxFuncCall::RANGE::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::RANGE BlackBoxFuncCall::RANGE::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); } template <> template -Program::BlackBoxFuncCall::RANGE -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::RANGE obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::RANGE serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::RANGE obj; + obj.input = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::SHA256 &lhs, - const BlackBoxFuncCall::SHA256 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::SHA256 &lhs, const BlackBoxFuncCall::SHA256 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::SHA256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::SHA256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::SHA256 -BlackBoxFuncCall::SHA256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::SHA256 BlackBoxFuncCall::SHA256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::SHA256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::SHA256 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::SHA256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::SHA256 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, - const BlackBoxFuncCall::Blake2s &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, const BlackBoxFuncCall::Blake2s &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Blake2s::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Blake2s::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Blake2s -BlackBoxFuncCall::Blake2s::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Blake2s BlackBoxFuncCall::Blake2s::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Blake2s -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Blake2s obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Blake2s obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, - const BlackBoxFuncCall::Blake3 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, const BlackBoxFuncCall::Blake3 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::Blake3::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Blake3::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Blake3 -BlackBoxFuncCall::Blake3::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Blake3 BlackBoxFuncCall::Blake3::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Blake3 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Blake3 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Blake3 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, - const BlackBoxFuncCall::SchnorrVerify &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, const BlackBoxFuncCall::SchnorrVerify &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::SchnorrVerify::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::SchnorrVerify::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::SchnorrVerify -BlackBoxFuncCall::SchnorrVerify::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::SchnorrVerify BlackBoxFuncCall::SchnorrVerify::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::SchnorrVerify &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::SchnorrVerify -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::SchnorrVerify obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, - const BlackBoxFuncCall::PedersenCommitment &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; +Program::BlackBoxFuncCall::SchnorrVerify serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::SchnorrVerify obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } -inline std::vector -BlackBoxFuncCall::PedersenCommitment::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} +namespace Program { -inline BlackBoxFuncCall::PedersenCommitment -BlackBoxFuncCall::PedersenCommitment::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, const BlackBoxFuncCall::PedersenCommitment &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::PedersenCommitment::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::PedersenCommitment BlackBoxFuncCall::PedersenCommitment::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::PedersenCommitment -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::PedersenCommitment obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, - const BlackBoxFuncCall::PedersenHash &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; +Program::BlackBoxFuncCall::PedersenCommitment serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::PedersenCommitment obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } -inline std::vector -BlackBoxFuncCall::PedersenHash::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} +namespace Program { -inline BlackBoxFuncCall::PedersenHash -BlackBoxFuncCall::PedersenHash::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, const BlackBoxFuncCall::PedersenHash &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::PedersenHash::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::PedersenHash BlackBoxFuncCall::PedersenHash::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::PedersenHash &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::PedersenHash -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::PedersenHash obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::PedersenHash serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::PedersenHash obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, - const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.hashed_message == rhs.hashed_message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxFuncCall::EcdsaSecp256k1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::EcdsaSecp256k1 -BlackBoxFuncCall::EcdsaSecp256k1::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::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 + inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.hashed_message == rhs.hashed_message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::EcdsaSecp256k1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::EcdsaSecp256k1 BlackBoxFuncCall::EcdsaSecp256k1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize( - obj.hashed_message, serializer); - serde::Serializable::serialize(obj.output, serializer); -} - -template <> -template -Program::BlackBoxFuncCall::EcdsaSecp256k1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::EcdsaSecp256k1 obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.hashed_message = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256r1 &lhs, - const BlackBoxFuncCall::EcdsaSecp256r1 &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.hashed_message == rhs.hashed_message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxFuncCall::EcdsaSecp256r1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::EcdsaSecp256r1 -BlackBoxFuncCall::EcdsaSecp256r1::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize( - obj.hashed_message, serializer); - serde::Serializable::serialize(obj.output, serializer); -} - -template <> -template -Program::BlackBoxFuncCall::EcdsaSecp256r1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::EcdsaSecp256r1 obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.hashed_message = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::FixedBaseScalarMul &lhs, - const BlackBoxFuncCall::FixedBaseScalarMul &rhs) { - if (!(lhs.low == rhs.low)) { - return false; - } - if (!(lhs.high == rhs.high)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.hashed_message, serializer); + serde::Serializable::serialize(obj.output, serializer); } -inline std::vector -BlackBoxFuncCall::FixedBaseScalarMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::FixedBaseScalarMul -BlackBoxFuncCall::FixedBaseScalarMul::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +template <> +template +Program::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::EcdsaSecp256k1 obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.hashed_message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256r1 &lhs, const BlackBoxFuncCall::EcdsaSecp256r1 &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.hashed_message == rhs.hashed_message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::EcdsaSecp256r1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::EcdsaSecp256r1 BlackBoxFuncCall::EcdsaSecp256r1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::FixedBaseScalarMul &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.low, serializer); - serde::Serializable::serialize(obj.high, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); + +template <> +template +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.hashed_message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::FixedBaseScalarMul -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::FixedBaseScalarMul obj; - obj.low = serde::Deserializable::deserialize(deserializer); - obj.high = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::VariableBaseScalarMul &lhs, - const BlackBoxFuncCall::VariableBaseScalarMul &rhs) { - if (!(lhs.point_x == rhs.point_x)) { - return false; - } - if (!(lhs.point_y == rhs.point_y)) { - return false; - } - if (!(lhs.scalar_low == rhs.scalar_low)) { - return false; - } - if (!(lhs.scalar_high == rhs.scalar_high)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxFuncCall::VariableBaseScalarMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); +Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::EcdsaSecp256r1 obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.hashed_message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } -inline BlackBoxFuncCall::VariableBaseScalarMul -BlackBoxFuncCall::VariableBaseScalarMul::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable< - BlackBoxFuncCall::VariableBaseScalarMul>::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::VariableBaseScalarMul &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.point_x, - serializer); - serde::Serializable::serialize(obj.point_y, - serializer); - serde::Serializable::serialize(obj.scalar_low, - serializer); - serde::Serializable::serialize(obj.scalar_high, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); -} - -template <> -template -Program::BlackBoxFuncCall::VariableBaseScalarMul -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::VariableBaseScalarMul obj; - obj.point_x = - serde::Deserializable::deserialize(deserializer); - obj.point_y = - serde::Deserializable::deserialize(deserializer); - obj.scalar_low = serde::Deserializable::deserialize( - deserializer); - obj.scalar_high = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, - const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) { - if (!(lhs.input1_x == rhs.input1_x)) { - return false; - } - if (!(lhs.input1_y == rhs.input1_y)) { - return false; - } - if (!(lhs.input2_x == rhs.input2_x)) { - return false; - } - if (!(lhs.input2_y == rhs.input2_y)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxFuncCall::EmbeddedCurveAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::EmbeddedCurveAdd -BlackBoxFuncCall::EmbeddedCurveAdd::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::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 +namespace Program { + + inline bool operator==(const BlackBoxFuncCall::FixedBaseScalarMul &lhs, const BlackBoxFuncCall::FixedBaseScalarMul &rhs) { + if (!(lhs.low == rhs.low)) { return false; } + if (!(lhs.high == rhs.high)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::FixedBaseScalarMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::FixedBaseScalarMul BlackBoxFuncCall::FixedBaseScalarMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.input1_x, - serializer); - serde::Serializable::serialize(obj.input1_y, - serializer); - serde::Serializable::serialize(obj.input2_x, - serializer); - serde::Serializable::serialize(obj.input2_y, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::FixedBaseScalarMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.low, serializer); + serde::Serializable::serialize(obj.high, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } -template <> -template -Program::BlackBoxFuncCall::EmbeddedCurveAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::EmbeddedCurveAdd obj; - obj.input1_x = - serde::Deserializable::deserialize(deserializer); - obj.input1_y = - serde::Deserializable::deserialize(deserializer); - obj.input2_x = - serde::Deserializable::deserialize(deserializer); - obj.input2_y = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +template <> +template +Program::BlackBoxFuncCall::FixedBaseScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::FixedBaseScalarMul obj; + obj.low = serde::Deserializable::deserialize(deserializer); + obj.high = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, - const BlackBoxFuncCall::Keccak256 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.var_message_size == rhs.var_message_size)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::VariableBaseScalarMul &lhs, const BlackBoxFuncCall::VariableBaseScalarMul &rhs) { + if (!(lhs.point_x == rhs.point_x)) { return false; } + if (!(lhs.point_y == rhs.point_y)) { return false; } + if (!(lhs.scalar_low == rhs.scalar_low)) { return false; } + if (!(lhs.scalar_high == rhs.scalar_high)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Keccak256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::VariableBaseScalarMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Keccak256 -BlackBoxFuncCall::Keccak256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::VariableBaseScalarMul BlackBoxFuncCall::VariableBaseScalarMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.var_message_size, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::VariableBaseScalarMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.point_x, serializer); + serde::Serializable::serialize(obj.point_y, serializer); + serde::Serializable::serialize(obj.scalar_low, serializer); + serde::Serializable::serialize(obj.scalar_high, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Keccak256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Keccak256 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.var_message_size = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::VariableBaseScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::VariableBaseScalarMul obj; + obj.point_x = serde::Deserializable::deserialize(deserializer); + obj.point_y = serde::Deserializable::deserialize(deserializer); + obj.scalar_low = serde::Deserializable::deserialize(deserializer); + obj.scalar_high = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, - const BlackBoxFuncCall::Keccakf1600 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) { + if (!(lhs.input1_x == rhs.input1_x)) { return false; } + if (!(lhs.input1_y == rhs.input1_y)) { return false; } + if (!(lhs.input2_x == rhs.input2_x)) { return false; } + if (!(lhs.input2_y == rhs.input2_y)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Keccakf1600::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::EmbeddedCurveAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Keccakf1600 -BlackBoxFuncCall::Keccakf1600::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::EmbeddedCurveAdd BlackBoxFuncCall::EmbeddedCurveAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input1_x, serializer); + serde::Serializable::serialize(obj.input1_y, serializer); + serde::Serializable::serialize(obj.input2_x, serializer); + serde::Serializable::serialize(obj.input2_y, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Keccakf1600 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Keccakf1600 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::EmbeddedCurveAdd obj; + obj.input1_x = serde::Deserializable::deserialize(deserializer); + obj.input1_y = serde::Deserializable::deserialize(deserializer); + obj.input2_x = serde::Deserializable::deserialize(deserializer); + obj.input2_y = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, - const BlackBoxFuncCall::RecursiveAggregation &rhs) { - if (!(lhs.verification_key == rhs.verification_key)) { - return false; - } - if (!(lhs.proof == rhs.proof)) { - return false; - } - if (!(lhs.public_inputs == rhs.public_inputs)) { - return false; - } - if (!(lhs.key_hash == rhs.key_hash)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.var_message_size == rhs.var_message_size)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::RecursiveAggregation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Keccak256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::RecursiveAggregation -BlackBoxFuncCall::RecursiveAggregation::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable< - BlackBoxFuncCall::RecursiveAggregation>::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Keccak256 BlackBoxFuncCall::Keccak256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, - Serializer &serializer) { - serde::Serializable::serialize( - obj.verification_key, serializer); - serde::Serializable::serialize(obj.proof, serializer); - serde::Serializable::serialize(obj.public_inputs, - serializer); - serde::Serializable::serialize(obj.key_hash, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.var_message_size, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::RecursiveAggregation -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::RecursiveAggregation obj; - obj.verification_key = - serde::Deserializable::deserialize( - deserializer); - obj.proof = - serde::Deserializable::deserialize(deserializer); - obj.public_inputs = - serde::Deserializable::deserialize( - deserializer); - obj.key_hash = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Keccak256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Keccak256 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.var_message_size = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, - const BlackBoxFuncCall::BigIntAdd &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, const BlackBoxFuncCall::Keccakf1600 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Keccakf1600::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntAdd -BlackBoxFuncCall::BigIntAdd::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Keccakf1600 BlackBoxFuncCall::Keccakf1600::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntAdd obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Keccakf1600 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, - const BlackBoxFuncCall::BigIntSub &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, const BlackBoxFuncCall::RecursiveAggregation &rhs) { + if (!(lhs.verification_key == rhs.verification_key)) { return false; } + if (!(lhs.proof == rhs.proof)) { return false; } + if (!(lhs.public_inputs == rhs.public_inputs)) { return false; } + if (!(lhs.key_hash == rhs.key_hash)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntSub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::RecursiveAggregation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntSub -BlackBoxFuncCall::BigIntSub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::RecursiveAggregation BlackBoxFuncCall::RecursiveAggregation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.verification_key, serializer); + serde::Serializable::serialize(obj.proof, serializer); + serde::Serializable::serialize(obj.public_inputs, serializer); + serde::Serializable::serialize(obj.key_hash, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntSub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntSub obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::RecursiveAggregation obj; + obj.verification_key = serde::Deserializable::deserialize(deserializer); + obj.proof = serde::Deserializable::deserialize(deserializer); + obj.public_inputs = serde::Deserializable::deserialize(deserializer); + obj.key_hash = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, - const BlackBoxFuncCall::BigIntMul &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, const BlackBoxFuncCall::BigIntAdd &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntMul -BlackBoxFuncCall::BigIntMul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntAdd BlackBoxFuncCall::BigIntAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntMul obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntAdd obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, - const BlackBoxFuncCall::BigIntDiv &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, const BlackBoxFuncCall::BigIntSub &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntDiv::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntSub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntDiv -BlackBoxFuncCall::BigIntDiv::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntSub BlackBoxFuncCall::BigIntSub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntDiv -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntDiv obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntSub obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, - const BlackBoxFuncCall::BigIntFromLeBytes &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.modulus == rhs.modulus)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, const BlackBoxFuncCall::BigIntMul &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntFromLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntFromLeBytes -BlackBoxFuncCall::BigIntFromLeBytes::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntMul BlackBoxFuncCall::BigIntMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.modulus, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntFromLeBytes -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntFromLeBytes obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.modulus = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntMul obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, - const BlackBoxFuncCall::BigIntToLeBytes &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, const BlackBoxFuncCall::BigIntDiv &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntToLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntDiv::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntToLeBytes -BlackBoxFuncCall::BigIntToLeBytes::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntDiv BlackBoxFuncCall::BigIntDiv::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntToLeBytes -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntToLeBytes obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntDiv obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, - const BlackBoxFuncCall::Poseidon2Permutation &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - if (!(lhs.len == rhs.len)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, const BlackBoxFuncCall::BigIntFromLeBytes &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.modulus == rhs.modulus)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Poseidon2Permutation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntFromLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Poseidon2Permutation -BlackBoxFuncCall::Poseidon2Permutation::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable< - BlackBoxFuncCall::Poseidon2Permutation>::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntFromLeBytes BlackBoxFuncCall::BigIntFromLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); - serde::Serializable::serialize(obj.len, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.modulus, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::Poseidon2Permutation -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Poseidon2Permutation obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - obj.len = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntFromLeBytes obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.modulus = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, - const BlackBoxFuncCall::Sha256Compression &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.hash_values == rhs.hash_values)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, const BlackBoxFuncCall::BigIntToLeBytes &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Sha256Compression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntToLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Sha256Compression -BlackBoxFuncCall::Sha256Compression::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntToLeBytes BlackBoxFuncCall::BigIntToLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.hash_values, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Sha256Compression -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Sha256Compression obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.hash_values = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntToLeBytes obj; + obj.input = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, const BlackBoxFuncCall::Poseidon2Permutation &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + if (!(lhs.len == rhs.len)) { return false; } + return true; + } -inline std::vector BlackBoxOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Poseidon2Permutation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp BlackBoxOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Poseidon2Permutation BlackBoxFuncCall::Poseidon2Permutation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); + serde::Serializable::serialize(obj.len, serializer); } template <> template -Program::BlackBoxOp serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BlackBoxOp obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Poseidon2Permutation obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + obj.len = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, - const BlackBoxOp::AES128Encrypt &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.iv == rhs.iv)) { - return false; - } - if (!(lhs.key == rhs.key)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, const BlackBoxFuncCall::Sha256Compression &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.hash_values == rhs.hash_values)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::AES128Encrypt::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Sha256Compression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::AES128Encrypt -BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Sha256Compression BlackBoxFuncCall::Sha256Compression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.iv, serializer); - serde::Serializable::serialize(obj.key, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.hash_values, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxOp::AES128Encrypt -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::AES128Encrypt obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.iv = serde::Deserializable::deserialize(deserializer); - obj.key = serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Sha256Compression obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.hash_values = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Sha256 &lhs, - const BlackBoxOp::Sha256 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Sha256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Sha256 -BlackBoxOp::Sha256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp BlackBoxOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Sha256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BlackBoxOp::Sha256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Sha256 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BlackBoxOp obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Blake2s &lhs, - const BlackBoxOp::Blake2s &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, const BlackBoxOp::AES128Encrypt &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.iv == rhs.iv)) { return false; } + if (!(lhs.key == rhs.key)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Blake2s::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::AES128Encrypt::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Blake2s -BlackBoxOp::Blake2s::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::AES128Encrypt BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxOp::Blake2s -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Blake2s obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Blake3 &lhs, - const BlackBoxOp::Blake3 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Blake3::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Sha256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Blake3 -BlackBoxOp::Blake3::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Sha256 BlackBoxOp::Sha256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Sha256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Blake3 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Blake3 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Sha256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Sha256 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Keccak256 &lhs, - const BlackBoxOp::Keccak256 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Blake2s &lhs, const BlackBoxOp::Blake2s &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Keccak256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Blake2s::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Keccak256 -BlackBoxOp::Keccak256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Blake2s BlackBoxOp::Blake2s::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Keccak256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Keccak256 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Blake2s obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, - const BlackBoxOp::Keccakf1600 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Keccakf1600::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Blake3::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Keccakf1600 -BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Blake3 BlackBoxOp::Blake3::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Keccakf1600 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Keccakf1600 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Blake3 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, - const BlackBoxOp::EcdsaSecp256k1 &rhs) { - if (!(lhs.hashed_msg == rhs.hashed_msg)) { - return false; - } - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Keccak256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::EcdsaSecp256k1 -BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Keccak256 BlackBoxOp::Keccak256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.hashed_msg, - serializer); - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::EcdsaSecp256k1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::EcdsaSecp256k1 obj; - obj.hashed_msg = serde::Deserializable::deserialize( - deserializer); - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, - const BlackBoxOp::EcdsaSecp256r1 &rhs) { - if (!(lhs.hashed_msg == rhs.hashed_msg)) { - return false; - } - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxOp::EcdsaSecp256r1 -BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +Program::BlackBoxOp::Keccak256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Keccak256 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxOp::Keccakf1600::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::Keccakf1600 BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.hashed_msg, - serializer); - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.result, serializer); -} - +template +void serde::Serializable::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); +} + template <> template -Program::BlackBoxOp::EcdsaSecp256r1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::EcdsaSecp256r1 obj; - obj.hashed_msg = serde::Deserializable::deserialize( - deserializer); - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, - const BlackBoxOp::SchnorrVerify &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxOp::SchnorrVerify::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); +Program::BlackBoxOp::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Keccakf1600 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } -inline BlackBoxOp::SchnorrVerify -BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} +namespace Program { + + inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) { + if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; } + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } + + inline std::vector BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::EcdsaSecp256k1 BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.hashed_msg, serializer); + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::SchnorrVerify -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::SchnorrVerify obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::EcdsaSecp256k1 obj; + obj.hashed_msg = serde::Deserializable::deserialize(deserializer); + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, - const BlackBoxOp::PedersenCommitment &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) { + if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; } + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::PedersenCommitment::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::PedersenCommitment -BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::EcdsaSecp256r1 BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::PedersenCommitment &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.hashed_msg, serializer); + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::PedersenCommitment -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::PedersenCommitment obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::EcdsaSecp256r1 obj; + obj.hashed_msg = serde::Deserializable::deserialize(deserializer); + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::PedersenHash &lhs, - const BlackBoxOp::PedersenHash &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } -inline std::vector BlackBoxOp::PedersenHash::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::SchnorrVerify::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::PedersenHash -BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::SchnorrVerify BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::PedersenHash -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::PedersenHash obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::SchnorrVerify serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::SchnorrVerify obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.message = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, - const BlackBoxOp::FixedBaseScalarMul &rhs) { - if (!(lhs.low == rhs.low)) { - return false; - } - if (!(lhs.high == rhs.high)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::FixedBaseScalarMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::PedersenCommitment::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::FixedBaseScalarMul -BlackBoxOp::FixedBaseScalarMul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::PedersenCommitment BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::FixedBaseScalarMul &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.low, serializer); - serde::Serializable::serialize(obj.high, serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::FixedBaseScalarMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::FixedBaseScalarMul obj; - obj.low = serde::Deserializable::deserialize(deserializer); - obj.high = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::PedersenCommitment serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::PedersenCommitment obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::VariableBaseScalarMul &lhs, - const BlackBoxOp::VariableBaseScalarMul &rhs) { - if (!(lhs.point_x == rhs.point_x)) { - return false; - } - if (!(lhs.point_y == rhs.point_y)) { - return false; - } - if (!(lhs.scalar_low == rhs.scalar_low)) { - return false; - } - if (!(lhs.scalar_high == rhs.scalar_high)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxOp::VariableBaseScalarMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline BlackBoxOp::VariableBaseScalarMul -BlackBoxOp::VariableBaseScalarMul::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline std::vector BlackBoxOp::PedersenHash::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::PedersenHash BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::VariableBaseScalarMul &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.point_x, - serializer); - serde::Serializable::serialize(obj.point_y, - serializer); - serde::Serializable::serialize(obj.scalar_low, - serializer); - serde::Serializable::serialize(obj.scalar_high, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::VariableBaseScalarMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::VariableBaseScalarMul obj; - obj.point_x = - serde::Deserializable::deserialize(deserializer); - obj.point_y = - serde::Deserializable::deserialize(deserializer); - obj.scalar_low = serde::Deserializable::deserialize( - deserializer); - obj.scalar_high = - serde::Deserializable::deserialize( - deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, - const BlackBoxOp::EmbeddedCurveAdd &rhs) { - if (!(lhs.input1_x == rhs.input1_x)) { - return false; - } - if (!(lhs.input1_y == rhs.input1_y)) { - return false; - } - if (!(lhs.input2_x == rhs.input2_x)) { - return false; - } - if (!(lhs.input2_y == rhs.input2_y)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxOp::EmbeddedCurveAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); +Program::BlackBoxOp::PedersenHash serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::PedersenHash obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } -inline BlackBoxOp::EmbeddedCurveAdd -BlackBoxOp::EmbeddedCurveAdd::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} +namespace Program { + + inline bool operator==(const BlackBoxOp::FixedBaseScalarMul &lhs, const BlackBoxOp::FixedBaseScalarMul &rhs) { + if (!(lhs.low == rhs.low)) { return false; } + if (!(lhs.high == rhs.high)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } + + inline std::vector BlackBoxOp::FixedBaseScalarMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::FixedBaseScalarMul BlackBoxOp::FixedBaseScalarMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input1_x, - serializer); - serde::Serializable::serialize(obj.input1_y, - serializer); - serde::Serializable::serialize(obj.input2_x, - serializer); - serde::Serializable::serialize(obj.input2_y, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::FixedBaseScalarMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.low, serializer); + serde::Serializable::serialize(obj.high, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::EmbeddedCurveAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::EmbeddedCurveAdd obj; - obj.input1_x = - serde::Deserializable::deserialize(deserializer); - obj.input1_y = - serde::Deserializable::deserialize(deserializer); - obj.input2_x = - serde::Deserializable::deserialize(deserializer); - obj.input2_y = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::FixedBaseScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::FixedBaseScalarMul obj; + obj.low = serde::Deserializable::deserialize(deserializer); + obj.high = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, - const BlackBoxOp::BigIntAdd &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::VariableBaseScalarMul &lhs, const BlackBoxOp::VariableBaseScalarMul &rhs) { + if (!(lhs.point_x == rhs.point_x)) { return false; } + if (!(lhs.point_y == rhs.point_y)) { return false; } + if (!(lhs.scalar_low == rhs.scalar_low)) { return false; } + if (!(lhs.scalar_high == rhs.scalar_high)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::VariableBaseScalarMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntAdd -BlackBoxOp::BigIntAdd::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::VariableBaseScalarMul BlackBoxOp::VariableBaseScalarMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::VariableBaseScalarMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.point_x, serializer); + serde::Serializable::serialize(obj.point_y, serializer); + serde::Serializable::serialize(obj.scalar_low, serializer); + serde::Serializable::serialize(obj.scalar_high, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::BigIntAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntAdd obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::VariableBaseScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::VariableBaseScalarMul obj; + obj.point_x = serde::Deserializable::deserialize(deserializer); + obj.point_y = serde::Deserializable::deserialize(deserializer); + obj.scalar_low = serde::Deserializable::deserialize(deserializer); + obj.scalar_high = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntSub &lhs, - const BlackBoxOp::BigIntSub &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) { + if (!(lhs.input1_x == rhs.input1_x)) { return false; } + if (!(lhs.input1_y == rhs.input1_y)) { return false; } + if (!(lhs.input2_x == rhs.input2_x)) { return false; } + if (!(lhs.input2_y == rhs.input2_y)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntSub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::EmbeddedCurveAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntSub -BlackBoxOp::BigIntSub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::EmbeddedCurveAdd BlackBoxOp::EmbeddedCurveAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input1_x, serializer); + serde::Serializable::serialize(obj.input1_y, serializer); + serde::Serializable::serialize(obj.input2_x, serializer); + serde::Serializable::serialize(obj.input2_y, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::BigIntSub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntSub obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::EmbeddedCurveAdd obj; + obj.input1_x = serde::Deserializable::deserialize(deserializer); + obj.input1_y = serde::Deserializable::deserialize(deserializer); + obj.input2_x = serde::Deserializable::deserialize(deserializer); + obj.input2_y = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntMul &lhs, - const BlackBoxOp::BigIntMul &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, const BlackBoxOp::BigIntAdd &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntMul -BlackBoxOp::BigIntMul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntAdd BlackBoxOp::BigIntAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntMul obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntAdd obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, - const BlackBoxOp::BigIntDiv &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntSub &lhs, const BlackBoxOp::BigIntSub &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntDiv::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntSub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntDiv -BlackBoxOp::BigIntDiv::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntSub BlackBoxOp::BigIntSub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntDiv -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntDiv obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntSub obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, - const BlackBoxOp::BigIntFromLeBytes &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.modulus == rhs.modulus)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntMul &lhs, const BlackBoxOp::BigIntMul &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::BigIntFromLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntFromLeBytes -BlackBoxOp::BigIntFromLeBytes::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntMul BlackBoxOp::BigIntMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.modulus, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntFromLeBytes -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntFromLeBytes obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.modulus = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntMul obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, - const BlackBoxOp::BigIntToLeBytes &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, const BlackBoxOp::BigIntDiv &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::BigIntToLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntDiv::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntToLeBytes -BlackBoxOp::BigIntToLeBytes::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntDiv BlackBoxOp::BigIntDiv::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntToLeBytes -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntToLeBytes obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntDiv obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, - const BlackBoxOp::Poseidon2Permutation &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - if (!(lhs.len == rhs.len)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, const BlackBoxOp::BigIntFromLeBytes &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.modulus == rhs.modulus)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::Poseidon2Permutation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntFromLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Poseidon2Permutation -BlackBoxOp::Poseidon2Permutation::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntFromLeBytes BlackBoxOp::BigIntFromLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Poseidon2Permutation &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); - serde::Serializable::serialize(obj.len, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.modulus, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Poseidon2Permutation -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Poseidon2Permutation obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - obj.len = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntFromLeBytes obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.modulus = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, - const BlackBoxOp::Sha256Compression &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - if (!(lhs.hash_values == rhs.hash_values)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, const BlackBoxOp::BigIntToLeBytes &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::Sha256Compression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntToLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Sha256Compression -BlackBoxOp::Sha256Compression::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntToLeBytes BlackBoxOp::BigIntToLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); - serde::Serializable::serialize(obj.hash_values, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Sha256Compression -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Sha256Compression obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - obj.hash_values = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntToLeBytes obj; + obj.input = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlockId &lhs, const BlockId &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, const BlackBoxOp::Poseidon2Permutation &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + if (!(lhs.len == rhs.len)) { return false; } + return true; + } -inline std::vector BlockId::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Poseidon2Permutation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlockId BlockId::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Poseidon2Permutation BlackBoxOp::Poseidon2Permutation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlockId &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); + serde::Serializable::serialize(obj.len, serializer); } template <> template -Program::BlockId serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BlockId obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxOp::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Poseidon2Permutation obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + obj.len = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) { - if (!(lhs.bytecode == rhs.bytecode)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, const BlackBoxOp::Sha256Compression &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + if (!(lhs.hash_values == rhs.hash_values)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BrilligBytecode::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Sha256Compression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligBytecode -BrilligBytecode::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Sha256Compression BlackBoxOp::Sha256Compression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligBytecode &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.bytecode, - serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); + serde::Serializable::serialize(obj.hash_values, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BrilligBytecode -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligBytecode obj; - obj.bytecode = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxOp::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Sha256Compression obj; + obj.input = serde::Deserializable::deserialize(deserializer); + obj.hash_values = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlockId &lhs, const BlockId &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligInputs::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlockId::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs -BrilligInputs::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlockId BlockId::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlockId &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligInputs -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligInputs obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlockId serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BlockId obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs::Single &lhs, - const BrilligInputs::Single &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) { + if (!(lhs.bytecode == rhs.bytecode)) { return false; } + return true; + } -inline std::vector BrilligInputs::Single::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligBytecode::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs::Single -BrilligInputs::Single::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligBytecode BrilligBytecode::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs::Single &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligBytecode &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.bytecode, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligInputs::Single -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligInputs::Single obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligBytecode serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligBytecode obj; + obj.bytecode = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs::Array &lhs, - const BrilligInputs::Array &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligInputs::Array::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs::Array -BrilligInputs::Array::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs BrilligInputs::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs::Array &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligInputs &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligInputs::Array -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligInputs::Array obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligInputs serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligInputs obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs::MemoryArray &lhs, - const BrilligInputs::MemoryArray &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs::Single &lhs, const BrilligInputs::Single &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BrilligInputs::MemoryArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::Single::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs::MemoryArray -BrilligInputs::MemoryArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs::Single BrilligInputs::Single::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligInputs::Single &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligInputs::MemoryArray -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligInputs::MemoryArray obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligInputs::Single serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligInputs::Single obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs::Array &lhs, const BrilligInputs::Array &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOpcode::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::Array::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode -BrilligOpcode::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs::Array BrilligInputs::Array::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligInputs::Array &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligOpcode obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligInputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligInputs::Array obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, - const BrilligOpcode::BinaryFieldOp &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.op == rhs.op)) { - return false; - } - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs::MemoryArray &lhs, const BrilligInputs::MemoryArray &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::BinaryFieldOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::MemoryArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::BinaryFieldOp -BrilligOpcode::BinaryFieldOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs::MemoryArray BrilligInputs::MemoryArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.op, serializer); - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); +void serde::Serializable::serialize(const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode::BinaryFieldOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::BinaryFieldOp obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.op = serde::Deserializable::deserialize(deserializer); - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligInputs::MemoryArray serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligInputs::MemoryArray obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::BinaryIntOp &lhs, - const BrilligOpcode::BinaryIntOp &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.op == rhs.op)) { - return false; - } - if (!(lhs.bit_size == rhs.bit_size)) { - return false; - } - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::BinaryIntOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::BinaryIntOp -BrilligOpcode::BinaryIntOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode BrilligOpcode::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.op, serializer); - serde::Serializable::serialize(obj.bit_size, - serializer); - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligOpcode::BinaryIntOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::BinaryIntOp obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.op = serde::Deserializable::deserialize(deserializer); - obj.bit_size = - serde::Deserializable::deserialize(deserializer); - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligOpcode obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Cast &lhs, - const BrilligOpcode::Cast &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.source == rhs.source)) { - return false; - } - if (!(lhs.bit_size == rhs.bit_size)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, const BrilligOpcode::BinaryFieldOp &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.op == rhs.op)) { return false; } + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Cast::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::BinaryFieldOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Cast -BrilligOpcode::Cast::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::BinaryFieldOp BrilligOpcode::BinaryFieldOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Cast &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.source, serializer); - serde::Serializable::serialize(obj.bit_size, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.op, serializer); + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); } template <> template -Program::BrilligOpcode::Cast -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Cast obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source = - serde::Deserializable::deserialize(deserializer); - obj.bit_size = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::BinaryFieldOp obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.op = serde::Deserializable::deserialize(deserializer); + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, - const BrilligOpcode::JumpIfNot &rhs) { - if (!(lhs.condition == rhs.condition)) { - return false; - } - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::BinaryIntOp &lhs, const BrilligOpcode::BinaryIntOp &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.op == rhs.op)) { return false; } + if (!(lhs.bit_size == rhs.bit_size)) { return false; } + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + return true; + } -inline std::vector BrilligOpcode::JumpIfNot::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::BinaryIntOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::JumpIfNot -BrilligOpcode::JumpIfNot::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::BinaryIntOp BrilligOpcode::BinaryIntOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.condition, - serializer); - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.op, serializer); + serde::Serializable::serialize(obj.bit_size, serializer); + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); } template <> template -Program::BrilligOpcode::JumpIfNot -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::JumpIfNot obj; - obj.condition = - serde::Deserializable::deserialize(deserializer); - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::BinaryIntOp obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.op = serde::Deserializable::deserialize(deserializer); + obj.bit_size = serde::Deserializable::deserialize(deserializer); + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::JumpIf &lhs, - const BrilligOpcode::JumpIf &rhs) { - if (!(lhs.condition == rhs.condition)) { - return false; - } - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Cast &lhs, const BrilligOpcode::Cast &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.source == rhs.source)) { return false; } + if (!(lhs.bit_size == rhs.bit_size)) { return false; } + return true; + } -inline std::vector BrilligOpcode::JumpIf::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Cast::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::JumpIf -BrilligOpcode::JumpIf::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Cast BrilligOpcode::Cast::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.condition, - serializer); - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Cast &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source, serializer); + serde::Serializable::serialize(obj.bit_size, serializer); } template <> template -Program::BrilligOpcode::JumpIf -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::JumpIf obj; - obj.condition = - serde::Deserializable::deserialize(deserializer); - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Cast serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Cast obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source = serde::Deserializable::deserialize(deserializer); + obj.bit_size = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Jump &lhs, - const BrilligOpcode::Jump &rhs) { - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, const BrilligOpcode::JumpIfNot &rhs) { + if (!(lhs.condition == rhs.condition)) { return false; } + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Jump::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::JumpIfNot::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Jump -BrilligOpcode::Jump::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::JumpIfNot BrilligOpcode::JumpIfNot::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Jump &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.condition, serializer); + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::Jump -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Jump obj; - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::JumpIfNot serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::JumpIfNot obj; + obj.condition = serde::Deserializable::deserialize(deserializer); + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, - const BrilligOpcode::CalldataCopy &rhs) { - if (!(lhs.destination_address == rhs.destination_address)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - if (!(lhs.offset == rhs.offset)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::JumpIf &lhs, const BrilligOpcode::JumpIf &rhs) { + if (!(lhs.condition == rhs.condition)) { return false; } + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::CalldataCopy::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::JumpIf::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::CalldataCopy -BrilligOpcode::CalldataCopy::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::JumpIf BrilligOpcode::JumpIf::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) { - serde::Serializable::serialize( - obj.destination_address, serializer); - serde::Serializable::serialize(obj.size, serializer); - serde::Serializable::serialize(obj.offset, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.condition, serializer); + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::CalldataCopy -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::CalldataCopy obj; - obj.destination_address = - serde::Deserializable::deserialize( - deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - obj.offset = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::JumpIf serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::JumpIf obj; + obj.condition = serde::Deserializable::deserialize(deserializer); + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Call &lhs, - const BrilligOpcode::Call &rhs) { - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Jump &lhs, const BrilligOpcode::Jump &rhs) { + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Call::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Jump::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Call -BrilligOpcode::Call::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Jump BrilligOpcode::Jump::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Call &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Jump &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::Call -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Call obj; - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Jump serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Jump obj; + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Const &lhs, - const BrilligOpcode::Const &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.bit_size == rhs.bit_size)) { - return false; - } - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, const BrilligOpcode::CalldataCopy &rhs) { + if (!(lhs.destination_address == rhs.destination_address)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + if (!(lhs.offset == rhs.offset)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Const::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::CalldataCopy::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Const -BrilligOpcode::Const::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::CalldataCopy BrilligOpcode::CalldataCopy::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Const &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.bit_size, - serializer); - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination_address, serializer); + serde::Serializable::serialize(obj.size, serializer); + serde::Serializable::serialize(obj.offset, serializer); } template <> template -Program::BrilligOpcode::Const -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Const obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.bit_size = - serde::Deserializable::deserialize(deserializer); - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::CalldataCopy serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::CalldataCopy obj; + obj.destination_address = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + obj.offset = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Return &lhs, - const BrilligOpcode::Return &rhs) { - return true; -} + inline bool operator==(const BrilligOpcode::Call &lhs, const BrilligOpcode::Call &rhs) { + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Return::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Call::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Return -BrilligOpcode::Return::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Call BrilligOpcode::Call::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Return &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BrilligOpcode::Call &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.location, serializer); +} template <> template -Program::BrilligOpcode::Return -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Return obj; - return obj; +Program::BrilligOpcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Call obj; + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::ForeignCall &lhs, - const BrilligOpcode::ForeignCall &rhs) { - if (!(lhs.function == rhs.function)) { - return false; - } - if (!(lhs.destinations == rhs.destinations)) { - return false; - } - if (!(lhs.destination_value_types == rhs.destination_value_types)) { - return false; - } - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.input_value_types == rhs.input_value_types)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Const &lhs, const BrilligOpcode::Const &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.bit_size == rhs.bit_size)) { return false; } + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::ForeignCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Const::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::ForeignCall -BrilligOpcode::ForeignCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Const BrilligOpcode::Const::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.function, - serializer); - serde::Serializable::serialize(obj.destinations, - serializer); - serde::Serializable::serialize( - obj.destination_value_types, serializer); - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.input_value_types, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Const &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.bit_size, serializer); + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode::ForeignCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::ForeignCall obj; - obj.function = - serde::Deserializable::deserialize(deserializer); - obj.destinations = - serde::Deserializable::deserialize( - deserializer); - obj.destination_value_types = - serde::Deserializable::deserialize( - deserializer); - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.input_value_types = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::Const serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Const obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.bit_size = serde::Deserializable::deserialize(deserializer); + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Mov &lhs, - const BrilligOpcode::Mov &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.source == rhs.source)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Return &lhs, const BrilligOpcode::Return &rhs) { + return true; + } -inline std::vector BrilligOpcode::Mov::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Return::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Mov -BrilligOpcode::Mov::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Return BrilligOpcode::Return::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Mov &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.source, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Return &obj, Serializer &serializer) { } template <> template -Program::BrilligOpcode::Mov -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Mov obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Return serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Return obj; + return obj; } 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 bool operator==(const BrilligOpcode::ForeignCall &lhs, const BrilligOpcode::ForeignCall &rhs) { + if (!(lhs.function == rhs.function)) { return false; } + if (!(lhs.destinations == rhs.destinations)) { return false; } + if (!(lhs.destination_value_types == rhs.destination_value_types)) { return false; } + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.input_value_types == rhs.input_value_types)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::ConditionalMov::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::ForeignCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::ConditionalMov -BrilligOpcode::ConditionalMov::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::ForeignCall BrilligOpcode::ForeignCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.source_a, - serializer); - serde::Serializable::serialize(obj.source_b, - serializer); - serde::Serializable::serialize(obj.condition, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.function, serializer); + serde::Serializable::serialize(obj.destinations, serializer); + serde::Serializable::serialize(obj.destination_value_types, serializer); + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.input_value_types, serializer); } template <> template -Program::BrilligOpcode::ConditionalMov -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::ConditionalMov obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source_a = - serde::Deserializable::deserialize(deserializer); - obj.source_b = - serde::Deserializable::deserialize(deserializer); - obj.condition = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::ForeignCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::ForeignCall obj; + obj.function = serde::Deserializable::deserialize(deserializer); + obj.destinations = serde::Deserializable::deserialize(deserializer); + obj.destination_value_types = serde::Deserializable::deserialize(deserializer); + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.input_value_types = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Load &lhs, - const BrilligOpcode::Load &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.source_pointer == rhs.source_pointer)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Mov &lhs, const BrilligOpcode::Mov &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.source == rhs.source)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Load::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Mov::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Load -BrilligOpcode::Load::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Mov BrilligOpcode::Mov::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Load &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize( - obj.source_pointer, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Mov &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source, serializer); } template <> template -Program::BrilligOpcode::Load -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Load obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source_pointer = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::Mov serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Mov obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Store &lhs, - const BrilligOpcode::Store &rhs) { - if (!(lhs.destination_pointer == rhs.destination_pointer)) { - return false; - } - if (!(lhs.source == rhs.source)) { - return false; - } - return true; -} + 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 BrilligOpcode::Store::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::ConditionalMov::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Store -BrilligOpcode::Store::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::ConditionalMov BrilligOpcode::ConditionalMov::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Store &obj, Serializer &serializer) { - serde::Serializable::serialize( - obj.destination_pointer, serializer); - serde::Serializable::serialize(obj.source, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source_a, serializer); + serde::Serializable::serialize(obj.source_b, serializer); + serde::Serializable::serialize(obj.condition, serializer); } template <> template -Program::BrilligOpcode::Store -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Store obj; - obj.destination_pointer = - serde::Deserializable::deserialize( - deserializer); - obj.source = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::ConditionalMov serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::ConditionalMov obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source_a = serde::Deserializable::deserialize(deserializer); + obj.source_b = serde::Deserializable::deserialize(deserializer); + obj.condition = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::BlackBox &lhs, - const BrilligOpcode::BlackBox &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Load &lhs, const BrilligOpcode::Load &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.source_pointer == rhs.source_pointer)) { return false; } + return true; + } -inline std::vector BrilligOpcode::BlackBox::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Load::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::BlackBox -BrilligOpcode::BlackBox::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Load BrilligOpcode::Load::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Load &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source_pointer, serializer); } template <> template -Program::BrilligOpcode::BlackBox -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::BlackBox obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Load serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Load obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source_pointer = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Trap &lhs, - const BrilligOpcode::Trap &rhs) { - if (!(lhs.revert_data == rhs.revert_data)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Store &lhs, const BrilligOpcode::Store &rhs) { + if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; } + if (!(lhs.source == rhs.source)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Trap::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Store::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Trap -BrilligOpcode::Trap::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Store BrilligOpcode::Store::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Trap &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.revert_data, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Store &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination_pointer, serializer); + serde::Serializable::serialize(obj.source, serializer); } template <> template -Program::BrilligOpcode::Trap -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Trap obj; - obj.revert_data = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::Store serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Store obj; + obj.destination_pointer = serde::Deserializable::deserialize(deserializer); + obj.source = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Stop &lhs, - const BrilligOpcode::Stop &rhs) { - if (!(lhs.return_data_offset == rhs.return_data_offset)) { - return false; - } - if (!(lhs.return_data_size == rhs.return_data_size)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::BlackBox &lhs, const BrilligOpcode::BlackBox &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Stop::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::BlackBox::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Stop -BrilligOpcode::Stop::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::BlackBox BrilligOpcode::BlackBox::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Stop &obj, Serializer &serializer) { - serde::Serializable::serialize( - obj.return_data_offset, serializer); - serde::Serializable::serialize( - obj.return_data_size, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode::Stop -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Stop obj; - obj.return_data_offset = - serde::Deserializable::deserialize( - deserializer); - obj.return_data_size = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::BlackBox serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::BlackBox obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) { + if (!(lhs.revert_data == rhs.revert_data)) { return false; } + return true; + } -inline std::vector BrilligOutputs::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Trap::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOutputs -BrilligOutputs::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Trap BrilligOpcode::Trap::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOutputs &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.revert_data, serializer); } template <> template -Program::BrilligOutputs -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligOutputs obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligOpcode::Trap serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Trap obj; + obj.revert_data = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOutputs::Simple &lhs, - const BrilligOutputs::Simple &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Stop &lhs, const BrilligOpcode::Stop &rhs) { + if (!(lhs.return_data_offset == rhs.return_data_offset)) { return false; } + if (!(lhs.return_data_size == rhs.return_data_size)) { return false; } + return true; + } -inline std::vector BrilligOutputs::Simple::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Stop::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOutputs::Simple -BrilligOutputs::Simple::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Stop BrilligOpcode::Stop::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOutputs::Simple &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Stop &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.return_data_offset, serializer); + serde::Serializable::serialize(obj.return_data_size, serializer); } template <> template -Program::BrilligOutputs::Simple -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOutputs::Simple obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Stop serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Stop obj; + obj.return_data_offset = serde::Deserializable::deserialize(deserializer); + obj.return_data_size = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOutputs::Array &lhs, - const BrilligOutputs::Array &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOutputs::Array::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOutputs::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOutputs::Array -BrilligOutputs::Array::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOutputs BrilligOutputs::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOutputs::Array &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOutputs &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligOutputs::Array -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOutputs::Array obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOutputs serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligOutputs obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Circuit &lhs, const Circuit &rhs) { - if (!(lhs.current_witness_index == rhs.current_witness_index)) { - return false; - } - if (!(lhs.opcodes == rhs.opcodes)) { - return false; - } - if (!(lhs.expression_width == rhs.expression_width)) { - return false; - } - if (!(lhs.private_parameters == rhs.private_parameters)) { - return false; - } - if (!(lhs.public_parameters == rhs.public_parameters)) { - return false; - } - if (!(lhs.return_values == rhs.return_values)) { - return false; - } - if (!(lhs.assert_messages == rhs.assert_messages)) { - return false; - } - if (!(lhs.recursive == rhs.recursive)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOutputs::Simple &lhs, const BrilligOutputs::Simple &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Circuit::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOutputs::Simple::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Circuit Circuit::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOutputs::Simple BrilligOutputs::Simple::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Circuit &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize( - obj.current_witness_index, serializer); - serde::Serializable::serialize(obj.opcodes, - serializer); - serde::Serializable::serialize( - obj.expression_width, serializer); - serde::Serializable::serialize( - obj.private_parameters, serializer); - serde::Serializable::serialize( - obj.public_parameters, serializer); - serde::Serializable::serialize(obj.return_values, - serializer); - serde::Serializable::serialize( - obj.assert_messages, serializer); - serde::Serializable::serialize(obj.recursive, - serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligOutputs::Simple &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Circuit serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Circuit obj; - obj.current_witness_index = - serde::Deserializable::deserialize( - deserializer); - obj.opcodes = - serde::Deserializable::deserialize(deserializer); - obj.expression_width = - serde::Deserializable::deserialize( - deserializer); - obj.private_parameters = - serde::Deserializable::deserialize( - deserializer); - obj.public_parameters = - serde::Deserializable::deserialize( - deserializer); - obj.return_values = - serde::Deserializable::deserialize( - deserializer); - obj.assert_messages = - serde::Deserializable::deserialize( - deserializer); - obj.recursive = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligOutputs::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOutputs::Simple obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Directive &lhs, const Directive &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOutputs::Array &lhs, const BrilligOutputs::Array &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Directive::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOutputs::Array::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Directive Directive::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOutputs::Array BrilligOutputs::Array::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Directive &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligOutputs::Array &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Directive serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Directive obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligOutputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOutputs::Array obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Directive::ToLeRadix &lhs, - const Directive::ToLeRadix &rhs) { - if (!(lhs.a == rhs.a)) { - return false; - } - if (!(lhs.b == rhs.b)) { - return false; - } - if (!(lhs.radix == rhs.radix)) { - return false; - } - return true; -} + inline bool operator==(const Circuit &lhs, const Circuit &rhs) { + if (!(lhs.current_witness_index == rhs.current_witness_index)) { return false; } + if (!(lhs.opcodes == rhs.opcodes)) { return false; } + if (!(lhs.expression_width == rhs.expression_width)) { return false; } + if (!(lhs.private_parameters == rhs.private_parameters)) { return false; } + if (!(lhs.public_parameters == rhs.public_parameters)) { return false; } + if (!(lhs.return_values == rhs.return_values)) { return false; } + if (!(lhs.assert_messages == rhs.assert_messages)) { return false; } + if (!(lhs.recursive == rhs.recursive)) { return false; } + return true; + } -inline std::vector Directive::ToLeRadix::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Circuit::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Directive::ToLeRadix -Directive::ToLeRadix::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Circuit Circuit::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Directive::ToLeRadix &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.a, serializer); - serde::Serializable::serialize(obj.b, serializer); - serde::Serializable::serialize(obj.radix, serializer); +void serde::Serializable::serialize(const Program::Circuit &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.current_witness_index, serializer); + serde::Serializable::serialize(obj.opcodes, serializer); + serde::Serializable::serialize(obj.expression_width, serializer); + serde::Serializable::serialize(obj.private_parameters, serializer); + serde::Serializable::serialize(obj.public_parameters, serializer); + serde::Serializable::serialize(obj.return_values, serializer); + serde::Serializable::serialize(obj.assert_messages, serializer); + serde::Serializable::serialize(obj.recursive, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Directive::ToLeRadix -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Directive::ToLeRadix obj; - obj.a = serde::Deserializable::deserialize(deserializer); - obj.b = serde::Deserializable::deserialize(deserializer); - obj.radix = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Circuit serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Circuit obj; + obj.current_witness_index = serde::Deserializable::deserialize(deserializer); + obj.opcodes = serde::Deserializable::deserialize(deserializer); + obj.expression_width = serde::Deserializable::deserialize(deserializer); + obj.private_parameters = serde::Deserializable::deserialize(deserializer); + obj.public_parameters = serde::Deserializable::deserialize(deserializer); + obj.return_values = serde::Deserializable::deserialize(deserializer); + obj.assert_messages = serde::Deserializable::deserialize(deserializer); + obj.recursive = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Expression &lhs, const Expression &rhs) { - if (!(lhs.mul_terms == rhs.mul_terms)) { - return false; - } - if (!(lhs.linear_combinations == rhs.linear_combinations)) { - return false; - } - if (!(lhs.q_c == rhs.q_c)) { - return false; - } - return true; -} + inline bool operator==(const Directive &lhs, const Directive &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Expression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Directive::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Expression Expression::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Directive Directive::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Expression &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.mul_terms, - serializer); - serde::Serializable::serialize( - obj.linear_combinations, serializer); - serde::Serializable::serialize(obj.q_c, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Directive &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Expression serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Expression obj; - obj.mul_terms = - serde::Deserializable::deserialize(deserializer); - obj.linear_combinations = - serde::Deserializable::deserialize( - deserializer); - obj.q_c = serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Directive serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Directive obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ExpressionOrMemory &lhs, - const ExpressionOrMemory &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Directive::ToLeRadix &lhs, const Directive::ToLeRadix &rhs) { + if (!(lhs.a == rhs.a)) { return false; } + if (!(lhs.b == rhs.b)) { return false; } + if (!(lhs.radix == rhs.radix)) { return false; } + return true; + } -inline std::vector ExpressionOrMemory::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Directive::ToLeRadix::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionOrMemory -ExpressionOrMemory::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Directive::ToLeRadix Directive::ToLeRadix::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionOrMemory &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Directive::ToLeRadix &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.a, serializer); + serde::Serializable::serialize(obj.b, serializer); + serde::Serializable::serialize(obj.radix, serializer); } template <> template -Program::ExpressionOrMemory -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::ExpressionOrMemory obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Directive::ToLeRadix serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Directive::ToLeRadix obj; + obj.a = serde::Deserializable::deserialize(deserializer); + obj.b = serde::Deserializable::deserialize(deserializer); + obj.radix = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ExpressionOrMemory::Expression &lhs, - const ExpressionOrMemory::Expression &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Expression &lhs, const Expression &rhs) { + if (!(lhs.mul_terms == rhs.mul_terms)) { return false; } + if (!(lhs.linear_combinations == rhs.linear_combinations)) { return false; } + if (!(lhs.q_c == rhs.q_c)) { return false; } + return true; + } -inline std::vector -ExpressionOrMemory::Expression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector Expression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionOrMemory::Expression -ExpressionOrMemory::Expression::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Expression Expression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionOrMemory::Expression &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Expression &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.mul_terms, serializer); + serde::Serializable::serialize(obj.linear_combinations, serializer); + serde::Serializable::serialize(obj.q_c, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ExpressionOrMemory::Expression -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionOrMemory::Expression obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Expression obj; + obj.mul_terms = serde::Deserializable::deserialize(deserializer); + obj.linear_combinations = serde::Deserializable::deserialize(deserializer); + obj.q_c = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ExpressionOrMemory::Memory &lhs, - const ExpressionOrMemory::Memory &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionOrMemory &lhs, const ExpressionOrMemory &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ExpressionOrMemory::Memory::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionOrMemory::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionOrMemory::Memory -ExpressionOrMemory::Memory::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionOrMemory ExpressionOrMemory::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionOrMemory::Memory &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ExpressionOrMemory &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ExpressionOrMemory::Memory -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionOrMemory::Memory obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ExpressionOrMemory serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::ExpressionOrMemory obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionOrMemory::Expression &lhs, const ExpressionOrMemory::Expression &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ExpressionWidth::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionOrMemory::Expression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionWidth -ExpressionWidth::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionOrMemory::Expression ExpressionOrMemory::Expression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionWidth &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::ExpressionOrMemory::Expression &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ExpressionWidth -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::ExpressionWidth obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::ExpressionOrMemory::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionOrMemory::Expression obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ExpressionWidth::Unbounded &lhs, - const ExpressionWidth::Unbounded &rhs) { - return true; -} + inline bool operator==(const ExpressionOrMemory::Memory &lhs, const ExpressionOrMemory::Memory &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ExpressionWidth::Unbounded::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionOrMemory::Memory::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionWidth::Unbounded -ExpressionWidth::Unbounded::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionOrMemory::Memory ExpressionOrMemory::Memory::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::ExpressionOrMemory::Memory &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); +} template <> template -Program::ExpressionWidth::Unbounded -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionWidth::Unbounded obj; - return obj; +Program::ExpressionOrMemory::Memory serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionOrMemory::Memory obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ExpressionWidth::Bounded &lhs, - const ExpressionWidth::Bounded &rhs) { - if (!(lhs.width == rhs.width)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ExpressionWidth::Bounded::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionWidth::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionWidth::Bounded -ExpressionWidth::Bounded::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionWidth ExpressionWidth::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.width, serializer); +void serde::Serializable::serialize(const Program::ExpressionWidth &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ExpressionWidth::Bounded -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionWidth::Bounded obj; - obj.width = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ExpressionWidth serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::ExpressionWidth obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) { - if (!(lhs.witness == rhs.witness)) { - return false; - } - if (!(lhs.num_bits == rhs.num_bits)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionWidth::Unbounded &lhs, const ExpressionWidth::Unbounded &rhs) { + return true; + } -inline std::vector FunctionInput::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionWidth::Unbounded::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline FunctionInput -FunctionInput::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionWidth::Unbounded ExpressionWidth::Unbounded::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::FunctionInput &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.witness, - serializer); - serde::Serializable::serialize(obj.num_bits, - serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) { } template <> template -Program::FunctionInput -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::FunctionInput obj; - obj.witness = - serde::Deserializable::deserialize(deserializer); - obj.num_bits = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::ExpressionWidth::Unbounded serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionWidth::Unbounded obj; + return obj; } namespace Program { -inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) { - if (!(lhs.pointer == rhs.pointer)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionWidth::Bounded &lhs, const ExpressionWidth::Bounded &rhs) { + if (!(lhs.width == rhs.width)) { return false; } + return true; + } -inline std::vector HeapArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionWidth::Bounded::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapArray HeapArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionWidth::Bounded ExpressionWidth::Bounded::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapArray &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.pointer, - serializer); - serde::Serializable::serialize(obj.size, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.width, serializer); } template <> template -Program::HeapArray serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::HeapArray obj; - obj.pointer = - serde::Deserializable::deserialize(deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::ExpressionWidth::Bounded serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionWidth::Bounded obj; + obj.width = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) { + if (!(lhs.witness == rhs.witness)) { return false; } + if (!(lhs.num_bits == rhs.num_bits)) { return false; } + return true; + } -inline std::vector HeapValueType::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector FunctionInput::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType -HeapValueType::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline FunctionInput FunctionInput::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::FunctionInput &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.witness, serializer); + serde::Serializable::serialize(obj.num_bits, serializer); + serializer.decrease_container_depth(); } template <> template -Program::HeapValueType -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::HeapValueType obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::FunctionInput serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::FunctionInput obj; + obj.witness = serde::Deserializable::deserialize(deserializer); + obj.num_bits = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const HeapValueType::Simple &lhs, - const HeapValueType::Simple &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) { + if (!(lhs.pointer == rhs.pointer)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + return true; + } -inline std::vector HeapValueType::Simple::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType::Simple -HeapValueType::Simple::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapArray HeapArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType::Simple &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::HeapArray &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.pointer, serializer); + serde::Serializable::serialize(obj.size, serializer); + serializer.decrease_container_depth(); } template <> template -Program::HeapValueType::Simple -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::HeapValueType::Simple obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::HeapArray obj; + obj.pointer = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const HeapValueType::Array &lhs, - const HeapValueType::Array &rhs) { - if (!(lhs.value_types == rhs.value_types)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector HeapValueType::Array::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType::Array -HeapValueType::Array::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType HeapValueType::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType::Array &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value_types, - serializer); - serde::Serializable::serialize(obj.size, serializer); +void serde::Serializable::serialize(const Program::HeapValueType &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::HeapValueType::Array -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::HeapValueType::Array obj; - obj.value_types = - serde::Deserializable::deserialize( - deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::HeapValueType serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::HeapValueType obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const HeapValueType::Vector &lhs, - const HeapValueType::Vector &rhs) { - if (!(lhs.value_types == rhs.value_types)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType::Simple &lhs, const HeapValueType::Simple &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector HeapValueType::Vector::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::Simple::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType::Vector -HeapValueType::Vector::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType::Simple HeapValueType::Simple::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType::Vector &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value_types, - serializer); +void serde::Serializable::serialize(const Program::HeapValueType::Simple &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::HeapValueType::Vector -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::HeapValueType::Vector obj; - obj.value_types = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::HeapValueType::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::HeapValueType::Simple obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) { - if (!(lhs.pointer == rhs.pointer)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType::Array &lhs, const HeapValueType::Array &rhs) { + if (!(lhs.value_types == rhs.value_types)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + return true; + } -inline std::vector HeapVector::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::Array::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapVector HeapVector::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType::Array HeapValueType::Array::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapVector &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.pointer, - serializer); - serde::Serializable::serialize(obj.size, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::HeapValueType::Array &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value_types, serializer); + serde::Serializable::serialize(obj.size, serializer); } template <> template -Program::HeapVector serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::HeapVector obj; - obj.pointer = - serde::Deserializable::deserialize(deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::HeapValueType::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::HeapValueType::Array obj; + obj.value_types = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const MemOp &lhs, const MemOp &rhs) { - if (!(lhs.operation == rhs.operation)) { - return false; - } - if (!(lhs.index == rhs.index)) { - return false; - } - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType::Vector &lhs, const HeapValueType::Vector &rhs) { + if (!(lhs.value_types == rhs.value_types)) { return false; } + return true; + } -inline std::vector MemOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::Vector::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline MemOp MemOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType::Vector HeapValueType::Vector::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize(const Program::MemOp &obj, - Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.operation, - serializer); - serde::Serializable::serialize(obj.index, serializer); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::HeapValueType::Vector &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value_types, serializer); } template <> template -Program::MemOp -serde::Deserializable::deserialize(Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::MemOp obj; - obj.operation = - serde::Deserializable::deserialize(deserializer); - obj.index = - serde::Deserializable::deserialize(deserializer); - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::HeapValueType::Vector serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::HeapValueType::Vector obj; + obj.value_types = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) { + if (!(lhs.pointer == rhs.pointer)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + return true; + } -inline std::vector MemoryAddress::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapVector::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline MemoryAddress -MemoryAddress::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapVector HeapVector::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::MemoryAddress &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::HeapVector &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.pointer, serializer); + serde::Serializable::serialize(obj.size, serializer); + serializer.decrease_container_depth(); } template <> template -Program::MemoryAddress -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::MemoryAddress obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::HeapVector obj; + obj.pointer = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode &lhs, const Opcode &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const MemOp &lhs, const MemOp &rhs) { + if (!(lhs.operation == rhs.operation)) { return false; } + if (!(lhs.index == rhs.index)) { return false; } + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector MemOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode Opcode::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline MemOp MemOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize(const Program::Opcode &obj, - Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::MemOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.operation, serializer); + serde::Serializable::serialize(obj.index, serializer); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Opcode serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Opcode obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::MemOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::MemOp obj; + obj.operation = serde::Deserializable::deserialize(deserializer); + obj.index = serde::Deserializable::deserialize(deserializer); + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode::AssertZero &lhs, - const Opcode::AssertZero &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::AssertZero::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector MemoryAddress::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::AssertZero -Opcode::AssertZero::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline MemoryAddress MemoryAddress::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::AssertZero &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::MemoryAddress &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Opcode::AssertZero -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::AssertZero obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::MemoryAddress obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, - const Opcode::BlackBoxFuncCall &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode &lhs, const Opcode &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::BlackBoxFuncCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::BlackBoxFuncCall -Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode Opcode::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Opcode &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Opcode::BlackBoxFuncCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::BlackBoxFuncCall obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Opcode obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode::Directive &lhs, - const Opcode::Directive &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::Directive::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::AssertZero::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::Directive -Opcode::Directive::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::AssertZero Opcode::AssertZero::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::Directive &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::Directive -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::Directive obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::AssertZero serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::AssertZero obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::MemoryOp &lhs, - const Opcode::MemoryOp &rhs) { - if (!(lhs.block_id == rhs.block_id)) { - return false; - } - if (!(lhs.op == rhs.op)) { - return false; - } - if (!(lhs.predicate == rhs.predicate)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::MemoryOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::BlackBoxFuncCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::MemoryOp -Opcode::MemoryOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::MemoryOp &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.block_id, - serializer); - serde::Serializable::serialize(obj.op, serializer); - serde::Serializable::serialize(obj.predicate, - serializer); +void serde::Serializable::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::MemoryOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::MemoryOp obj; - obj.block_id = - serde::Deserializable::deserialize(deserializer); - obj.op = serde::Deserializable::deserialize(deserializer); - obj.predicate = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::BlackBoxFuncCall obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::MemoryInit &lhs, - const Opcode::MemoryInit &rhs) { - if (!(lhs.block_id == rhs.block_id)) { - return false; - } - if (!(lhs.init == rhs.init)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::Directive &lhs, const Opcode::Directive &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::MemoryInit::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::Directive::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::MemoryInit -Opcode::MemoryInit::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::Directive Opcode::Directive::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::MemoryInit &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.block_id, - serializer); - serde::Serializable::serialize(obj.init, serializer); +void serde::Serializable::serialize(const Program::Opcode::Directive &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::MemoryInit -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::MemoryInit obj; - obj.block_id = - serde::Deserializable::deserialize(deserializer); - obj.init = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::Directive serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::Directive obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::BrilligCall &lhs, - const Opcode::BrilligCall &rhs) { - if (!(lhs.id == rhs.id)) { - return false; - } - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - if (!(lhs.predicate == rhs.predicate)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::MemoryOp &lhs, const Opcode::MemoryOp &rhs) { + if (!(lhs.block_id == rhs.block_id)) { return false; } + if (!(lhs.op == rhs.op)) { return false; } + if (!(lhs.predicate == rhs.predicate)) { return false; } + return true; + } -inline std::vector Opcode::BrilligCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::MemoryOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::BrilligCall -Opcode::BrilligCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::MemoryOp Opcode::MemoryOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::BrilligCall &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.id, serializer); - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); - serde::Serializable::serialize(obj.predicate, - serializer); +void serde::Serializable::serialize(const Program::Opcode::MemoryOp &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.block_id, serializer); + serde::Serializable::serialize(obj.op, serializer); + serde::Serializable::serialize(obj.predicate, serializer); } template <> template -Program::Opcode::BrilligCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::BrilligCall obj; - obj.id = serde::Deserializable::deserialize(deserializer); - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - obj.predicate = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::MemoryOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::MemoryOp obj; + obj.block_id = serde::Deserializable::deserialize(deserializer); + obj.op = serde::Deserializable::deserialize(deserializer); + obj.predicate = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) { - if (!(lhs.id == rhs.id)) { - return false; - } - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - if (!(lhs.predicate == rhs.predicate)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) { + if (!(lhs.block_id == rhs.block_id)) { return false; } + if (!(lhs.init == rhs.init)) { return false; } + return true; + } -inline std::vector Opcode::Call::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::MemoryInit::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::Call -Opcode::Call::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::MemoryInit Opcode::MemoryInit::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::Call &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.id, serializer); - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); - serde::Serializable::serialize(obj.predicate, - serializer); +void serde::Serializable::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.block_id, serializer); + serde::Serializable::serialize(obj.init, serializer); } template <> template -Program::Opcode::Call serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::Call obj; - obj.id = serde::Deserializable::deserialize(deserializer); - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - obj.predicate = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::MemoryInit serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::MemoryInit obj; + obj.block_id = serde::Deserializable::deserialize(deserializer); + obj.init = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::BrilligCall &lhs, const Opcode::BrilligCall &rhs) { + if (!(lhs.id == rhs.id)) { return false; } + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + if (!(lhs.predicate == rhs.predicate)) { return false; } + return true; + } -inline std::vector OpcodeLocation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::BrilligCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline OpcodeLocation -OpcodeLocation::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::BrilligCall Opcode::BrilligCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::OpcodeLocation &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Opcode::BrilligCall &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.id, serializer); + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); + serde::Serializable::serialize(obj.predicate, serializer); } template <> template -Program::OpcodeLocation -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::OpcodeLocation obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Opcode::BrilligCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::BrilligCall obj; + obj.id = serde::Deserializable::deserialize(deserializer); + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + obj.predicate = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const OpcodeLocation::Acir &lhs, - const OpcodeLocation::Acir &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) { + if (!(lhs.id == rhs.id)) { return false; } + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + if (!(lhs.predicate == rhs.predicate)) { return false; } + return true; + } -inline std::vector OpcodeLocation::Acir::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::Call::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline OpcodeLocation::Acir -OpcodeLocation::Acir::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::Call Opcode::Call::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::OpcodeLocation::Acir &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Opcode::Call &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.id, serializer); + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); + serde::Serializable::serialize(obj.predicate, serializer); } template <> template -Program::OpcodeLocation::Acir -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::OpcodeLocation::Acir obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::Call obj; + obj.id = serde::Deserializable::deserialize(deserializer); + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + obj.predicate = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const OpcodeLocation::Brillig &lhs, - const OpcodeLocation::Brillig &rhs) { - if (!(lhs.acir_index == rhs.acir_index)) { - return false; - } - if (!(lhs.brillig_index == rhs.brillig_index)) { - return false; - } - return true; -} + inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector OpcodeLocation::Brillig::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector OpcodeLocation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline OpcodeLocation::Brillig -OpcodeLocation::Brillig::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline OpcodeLocation OpcodeLocation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.acir_index, - serializer); - serde::Serializable::serialize(obj.brillig_index, - serializer); +void serde::Serializable::serialize(const Program::OpcodeLocation &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::OpcodeLocation::Brillig -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::OpcodeLocation::Brillig obj; - obj.acir_index = serde::Deserializable::deserialize( - deserializer); - obj.brillig_index = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::OpcodeLocation serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::OpcodeLocation obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Program &lhs, const Program &rhs) { - if (!(lhs.functions == rhs.functions)) { - return false; - } - if (!(lhs.unconstrained_functions == rhs.unconstrained_functions)) { - return false; - } - return true; -} + inline bool operator==(const OpcodeLocation::Acir &lhs, const OpcodeLocation::Acir &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Program::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector OpcodeLocation::Acir::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Program Program::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline OpcodeLocation::Acir OpcodeLocation::Acir::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Program &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.functions, - serializer); - serde::Serializable::serialize( - obj.unconstrained_functions, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::OpcodeLocation::Acir &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Program serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Program obj; - obj.functions = - serde::Deserializable::deserialize(deserializer); - obj.unconstrained_functions = - serde::Deserializable::deserialize( - deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::OpcodeLocation::Acir serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::OpcodeLocation::Acir obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const OpcodeLocation::Brillig &lhs, const OpcodeLocation::Brillig &rhs) { + if (!(lhs.acir_index == rhs.acir_index)) { return false; } + if (!(lhs.brillig_index == rhs.brillig_index)) { return false; } + return true; + } -inline std::vector PublicInputs::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector OpcodeLocation::Brillig::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline PublicInputs -PublicInputs::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline OpcodeLocation::Brillig OpcodeLocation::Brillig::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::PublicInputs &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.acir_index, serializer); + serde::Serializable::serialize(obj.brillig_index, serializer); } template <> template -Program::PublicInputs serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::PublicInputs obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::OpcodeLocation::Brillig serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::OpcodeLocation::Brillig obj; + obj.acir_index = serde::Deserializable::deserialize(deserializer); + obj.brillig_index = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Program &lhs, const Program &rhs) { + if (!(lhs.functions == rhs.functions)) { return false; } + if (!(lhs.unconstrained_functions == rhs.unconstrained_functions)) { return false; } + return true; + } -inline std::vector ValueOrArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Program::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray -ValueOrArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Program Program::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Program &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.functions, serializer); + serde::Serializable::serialize(obj.unconstrained_functions, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ValueOrArray serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::ValueOrArray obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Program serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Program obj; + obj.functions = serde::Deserializable::deserialize(deserializer); + obj.unconstrained_functions = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray::MemoryAddress &lhs, - const ValueOrArray::MemoryAddress &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ValueOrArray::MemoryAddress::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector PublicInputs::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray::MemoryAddress -ValueOrArray::MemoryAddress::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline PublicInputs PublicInputs::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::PublicInputs &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ValueOrArray::MemoryAddress -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ValueOrArray::MemoryAddress obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::PublicInputs serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::PublicInputs obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray::HeapArray &lhs, - const ValueOrArray::HeapArray &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ValueOrArray::HeapArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ValueOrArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray::HeapArray -ValueOrArray::HeapArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ValueOrArray ValueOrArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ValueOrArray &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ValueOrArray::HeapArray -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ValueOrArray::HeapArray obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ValueOrArray serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::ValueOrArray obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray::HeapVector &lhs, - const ValueOrArray::HeapVector &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray::MemoryAddress &lhs, const ValueOrArray::MemoryAddress &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } + + inline std::vector ValueOrArray::MemoryAddress::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline std::vector ValueOrArray::HeapVector::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); + inline ValueOrArray::MemoryAddress ValueOrArray::MemoryAddress::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 +void serde::Serializable::serialize(const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } -inline ValueOrArray::HeapVector -ValueOrArray::HeapVector::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +template <> +template +Program::ValueOrArray::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ValueOrArray::MemoryAddress obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const ValueOrArray::HeapArray &lhs, const ValueOrArray::HeapArray &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } + + inline std::vector ValueOrArray::HeapArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline ValueOrArray::HeapArray ValueOrArray::HeapArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ValueOrArray::HeapVector -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ValueOrArray::HeapVector obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ValueOrArray::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ValueOrArray::HeapArray obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Witness &lhs, const Witness &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray::HeapVector &lhs, const ValueOrArray::HeapVector &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } + + inline std::vector ValueOrArray::HeapVector::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline ValueOrArray::HeapVector ValueOrArray::HeapVector::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::deserialize(deserializer); + if (deserializer.get_buffer_offset() < input.size()) { + throw serde::deserialization_error("Some input bytes were not read"); + } + return value; + } -inline std::vector Witness::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); +} // end of namespace Program + +template <> +template +void serde::Serializable::serialize(const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } -inline Witness Witness::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +template <> +template +Program::ValueOrArray::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ValueOrArray::HeapVector obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const Witness &lhs, const Witness &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } + + inline std::vector Witness::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline Witness Witness::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Witness &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Witness &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Witness serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Witness obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Witness obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } From 57001c36b5cfaa0864c08eeb472d4423e9ff9dc3 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 30 Apr 2024 16:24:15 +0000 Subject: [PATCH 24/27] fixed ts test --- .../acvm-repo/acvm_js/test/shared/variable_base_scalar_mul.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/noir/noir-repo/acvm-repo/acvm_js/test/shared/variable_base_scalar_mul.ts b/noir/noir-repo/acvm-repo/acvm_js/test/shared/variable_base_scalar_mul.ts index 400f7bf4e614..f191b41896ea 100644 --- a/noir/noir-repo/acvm-repo/acvm_js/test/shared/variable_base_scalar_mul.ts +++ b/noir/noir-repo/acvm-repo/acvm_js/test/shared/variable_base_scalar_mul.ts @@ -1,8 +1,8 @@ // See `variable_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, 93, 139, 65, 10, 0, 32, 8, 4, 213, 172, 46, 61, 186, 167, 103, 52, 65, 185, 176, + 31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 93, 139, 65, 10, 0, 32, 8, 4, 213, 172, 78, 253, 185, 167, 103, 52, 65, 185, 176, 140, 44, 142, 202, 73, 143, 42, 247, 230, 128, 51, 106, 176, 64, 135, 53, 218, 112, 252, 113, 141, 223, 187, 9, 155, - 36, 231, 203, 2, 176, 218, 19, 62, 137, 0, 0, 0, + 36, 231, 203, 2, 189, 15, 68, 136, 137, 0, 0, 0, ]); export const initialWitnessMap = new Map([ [1, '0x0000000000000000000000000000000000000000000000000000000000000001'], From 60b94210c4803851c9a8f260464a1af0b23191b2 Mon Sep 17 00:00:00 2001 From: Tom French <15848336+TomAFrench@users.noreply.github.com> Date: Tue, 7 May 2024 11:58:29 +0100 Subject: [PATCH 25/27] Update noir/noir-repo/noir_stdlib/src/aes128.nr --- noir/noir-repo/noir_stdlib/src/aes128.nr | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index 82f5cdbae605..d717f76aadf0 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -1,6 +1,6 @@ use crate::println; -// docs:start:aes128 #[foreign(aes128_encrypt)] +// docs:start:aes128 pub fn aes128_encrypt(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8] {} // docs:end:aes128 From 7dc53191a7103907e1a6d88e936565a5fdeac32c Mon Sep 17 00:00:00 2001 From: Tom French <15848336+TomAFrench@users.noreply.github.com> Date: Tue, 7 May 2024 11:58:36 +0100 Subject: [PATCH 26/27] Update noir/noir-repo/noir_stdlib/src/aes128.nr --- noir/noir-repo/noir_stdlib/src/aes128.nr | 1 - 1 file changed, 1 deletion(-) diff --git a/noir/noir-repo/noir_stdlib/src/aes128.nr b/noir/noir-repo/noir_stdlib/src/aes128.nr index d717f76aadf0..ac5c2b48ad83 100644 --- a/noir/noir-repo/noir_stdlib/src/aes128.nr +++ b/noir/noir-repo/noir_stdlib/src/aes128.nr @@ -1,4 +1,3 @@ -use crate::println; #[foreign(aes128_encrypt)] // docs:start:aes128 From 5d96c99aef1f1209f7b10754e2b61de15fd49907 Mon Sep 17 00:00:00 2001 From: thunkar Date: Tue, 7 May 2024 19:01:28 +0000 Subject: [PATCH 27/27] fixed test --- .../noir-repo/acvm-repo/acir/codegen/acir.cpp | 11727 +++++++--------- 1 file changed, 4948 insertions(+), 6779 deletions(-) diff --git a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp index 85b306f67880..b7e75c4320dc 100644 --- a/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp +++ b/noir/noir-repo/acvm-repo/acir/codegen/acir.cpp @@ -1,8811 +1,6980 @@ #pragma once -#include "bincode.hpp" #include "serde.hpp" +#include "bincode.hpp" namespace Program { -struct Witness { - uint32_t value; - - friend bool operator==(const Witness &, const Witness &); - std::vector bincodeSerialize() const; - static Witness bincodeDeserialize(std::vector); -}; - -struct FunctionInput { - Program::Witness witness; - uint32_t num_bits; - - friend bool operator==(const FunctionInput &, const FunctionInput &); - std::vector bincodeSerialize() const; - static FunctionInput bincodeDeserialize(std::vector); -}; - -struct BlackBoxFuncCall { - - struct AES128Encrypt { - std::vector inputs; - std::array iv; - std::array key; - std::vector outputs; - - friend bool operator==(const AES128Encrypt &, const AES128Encrypt &); - std::vector bincodeSerialize() const; - static AES128Encrypt bincodeDeserialize(std::vector); - }; - - struct AND { - Program::FunctionInput lhs; - Program::FunctionInput rhs; - Program::Witness output; - - friend bool operator==(const AND &, const AND &); - std::vector bincodeSerialize() const; - static AND bincodeDeserialize(std::vector); - }; - - struct XOR { - Program::FunctionInput lhs; - Program::FunctionInput rhs; - Program::Witness output; - - friend bool operator==(const XOR &, const XOR &); - std::vector bincodeSerialize() const; - static XOR bincodeDeserialize(std::vector); - }; - - struct RANGE { - Program::FunctionInput input; - - friend bool operator==(const RANGE &, const RANGE &); - std::vector bincodeSerialize() const; - static RANGE bincodeDeserialize(std::vector); - }; - - struct SHA256 { - std::vector inputs; - std::array outputs; - - friend bool operator==(const SHA256 &, const SHA256 &); - std::vector bincodeSerialize() const; - static SHA256 bincodeDeserialize(std::vector); - }; - - struct Blake2s { - std::vector inputs; - std::array outputs; - - friend bool operator==(const Blake2s &, const Blake2s &); - std::vector bincodeSerialize() const; - static Blake2s bincodeDeserialize(std::vector); - }; - - struct Blake3 { - std::vector inputs; - std::array outputs; - - friend bool operator==(const Blake3 &, const Blake3 &); - std::vector bincodeSerialize() const; - static Blake3 bincodeDeserialize(std::vector); - }; - - struct SchnorrVerify { - Program::FunctionInput public_key_x; - Program::FunctionInput public_key_y; - std::array signature; - std::vector message; - Program::Witness output; - - friend bool operator==(const SchnorrVerify &, const SchnorrVerify &); - std::vector bincodeSerialize() const; - static SchnorrVerify bincodeDeserialize(std::vector); - }; - - struct PedersenCommitment { - std::vector inputs; - uint32_t domain_separator; - std::array outputs; - - friend bool operator==(const PedersenCommitment &, - const PedersenCommitment &); - std::vector bincodeSerialize() const; - static PedersenCommitment bincodeDeserialize(std::vector); - }; - - struct PedersenHash { - std::vector inputs; - uint32_t domain_separator; - Program::Witness output; - - friend bool operator==(const PedersenHash &, const PedersenHash &); - std::vector bincodeSerialize() const; - static PedersenHash bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256k1 { - std::array public_key_x; - std::array public_key_y; - std::array signature; - std::array hashed_message; - Program::Witness output; - - friend bool operator==(const EcdsaSecp256k1 &, const EcdsaSecp256k1 &); - std::vector bincodeSerialize() const; - static EcdsaSecp256k1 bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256r1 { - std::array public_key_x; - std::array public_key_y; - std::array signature; - std::array hashed_message; - Program::Witness output; - - friend bool operator==(const EcdsaSecp256r1 &, const EcdsaSecp256r1 &); - std::vector bincodeSerialize() const; - static EcdsaSecp256r1 bincodeDeserialize(std::vector); - }; - - struct MultiScalarMul { - std::vector points; - std::vector scalars; - std::array outputs; - - friend bool operator==(const MultiScalarMul &, const MultiScalarMul &); - std::vector bincodeSerialize() const; - static MultiScalarMul bincodeDeserialize(std::vector); - }; - - struct EmbeddedCurveAdd { - Program::FunctionInput input1_x; - Program::FunctionInput input1_y; - Program::FunctionInput input2_x; - Program::FunctionInput input2_y; - std::array outputs; - - friend bool operator==(const EmbeddedCurveAdd &, const EmbeddedCurveAdd &); - std::vector bincodeSerialize() const; - static EmbeddedCurveAdd bincodeDeserialize(std::vector); - }; - - struct Keccak256 { - std::vector inputs; - Program::FunctionInput var_message_size; - std::array outputs; - - friend bool operator==(const Keccak256 &, const Keccak256 &); - std::vector bincodeSerialize() const; - static Keccak256 bincodeDeserialize(std::vector); - }; - - struct Keccakf1600 { - std::array inputs; - std::array outputs; - - friend bool operator==(const Keccakf1600 &, const Keccakf1600 &); - std::vector bincodeSerialize() const; - static Keccakf1600 bincodeDeserialize(std::vector); - }; - - struct RecursiveAggregation { - std::vector verification_key; - std::vector proof; - std::vector public_inputs; - Program::FunctionInput key_hash; - - friend bool operator==(const RecursiveAggregation &, - const RecursiveAggregation &); - std::vector bincodeSerialize() const; - static RecursiveAggregation bincodeDeserialize(std::vector); - }; - - struct BigIntAdd { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntAdd &, const BigIntAdd &); - std::vector bincodeSerialize() const; - static BigIntAdd bincodeDeserialize(std::vector); - }; - - struct BigIntSub { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntSub &, const BigIntSub &); - std::vector bincodeSerialize() const; - static BigIntSub bincodeDeserialize(std::vector); - }; - - struct BigIntMul { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntMul &, const BigIntMul &); - std::vector bincodeSerialize() const; - static BigIntMul bincodeDeserialize(std::vector); - }; - - struct BigIntDiv { - uint32_t lhs; - uint32_t rhs; - uint32_t output; - - friend bool operator==(const BigIntDiv &, const BigIntDiv &); - std::vector bincodeSerialize() const; - static BigIntDiv bincodeDeserialize(std::vector); - }; - - struct BigIntFromLeBytes { - std::vector inputs; - std::vector modulus; - uint32_t output; - - friend bool operator==(const BigIntFromLeBytes &, - const BigIntFromLeBytes &); - std::vector bincodeSerialize() const; - static BigIntFromLeBytes bincodeDeserialize(std::vector); - }; - - struct BigIntToLeBytes { - uint32_t input; - std::vector outputs; - - friend bool operator==(const BigIntToLeBytes &, const BigIntToLeBytes &); - std::vector bincodeSerialize() const; - static BigIntToLeBytes bincodeDeserialize(std::vector); - }; - - struct Poseidon2Permutation { - std::vector inputs; - std::vector outputs; - uint32_t len; - - friend bool operator==(const Poseidon2Permutation &, - const Poseidon2Permutation &); - std::vector bincodeSerialize() const; - static Poseidon2Permutation bincodeDeserialize(std::vector); - }; - - struct Sha256Compression { - std::array inputs; - std::array hash_values; - std::array outputs; - - friend bool operator==(const Sha256Compression &, - const Sha256Compression &); - std::vector bincodeSerialize() const; - static Sha256Compression bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BlackBoxFuncCall &, const BlackBoxFuncCall &); - std::vector bincodeSerialize() const; - static BlackBoxFuncCall bincodeDeserialize(std::vector); -}; - -struct BlockId { - uint32_t value; - - friend bool operator==(const BlockId &, const BlockId &); - std::vector bincodeSerialize() const; - static BlockId bincodeDeserialize(std::vector); -}; - -struct Expression { - std::vector> - mul_terms; - std::vector> linear_combinations; - std::string q_c; - - friend bool operator==(const Expression &, const Expression &); - std::vector bincodeSerialize() const; - static Expression bincodeDeserialize(std::vector); -}; - -struct BrilligInputs { - - struct Single { - Program::Expression value; - - friend bool operator==(const Single &, const Single &); - std::vector bincodeSerialize() const; - static Single bincodeDeserialize(std::vector); - }; - - struct Array { - std::vector value; - - friend bool operator==(const Array &, const Array &); - std::vector bincodeSerialize() const; - static Array bincodeDeserialize(std::vector); - }; - - struct MemoryArray { - Program::BlockId value; - - friend bool operator==(const MemoryArray &, const MemoryArray &); - std::vector bincodeSerialize() const; - static MemoryArray bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const BrilligInputs &, const BrilligInputs &); - std::vector bincodeSerialize() const; - static BrilligInputs bincodeDeserialize(std::vector); -}; - -struct BrilligOutputs { - - struct Simple { - Program::Witness value; - - friend bool operator==(const Simple &, const Simple &); - std::vector bincodeSerialize() const; - static Simple bincodeDeserialize(std::vector); - }; - - struct Array { - std::vector value; - - friend bool operator==(const Array &, const Array &); - std::vector bincodeSerialize() const; - static Array bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const BrilligOutputs &, const BrilligOutputs &); - std::vector bincodeSerialize() const; - static BrilligOutputs bincodeDeserialize(std::vector); -}; - -struct Directive { - - struct ToLeRadix { - Program::Expression a; - std::vector b; - uint32_t radix; - - friend bool operator==(const ToLeRadix &, const ToLeRadix &); - std::vector bincodeSerialize() const; - static ToLeRadix bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const Directive &, const Directive &); - std::vector bincodeSerialize() const; - static Directive bincodeDeserialize(std::vector); -}; - -struct MemOp { - Program::Expression operation; - Program::Expression index; - Program::Expression value; - - friend bool operator==(const MemOp &, const MemOp &); - std::vector bincodeSerialize() const; - static MemOp bincodeDeserialize(std::vector); -}; - -struct Opcode { - - struct AssertZero { - Program::Expression value; - - friend bool operator==(const AssertZero &, const AssertZero &); - std::vector bincodeSerialize() const; - static AssertZero bincodeDeserialize(std::vector); - }; - - struct BlackBoxFuncCall { - Program::BlackBoxFuncCall value; - - friend bool operator==(const BlackBoxFuncCall &, const BlackBoxFuncCall &); - std::vector bincodeSerialize() const; - static BlackBoxFuncCall bincodeDeserialize(std::vector); - }; - - struct Directive { - Program::Directive value; - - friend bool operator==(const Directive &, const Directive &); - std::vector bincodeSerialize() const; - static Directive bincodeDeserialize(std::vector); - }; - - struct MemoryOp { - Program::BlockId block_id; - Program::MemOp op; - std::optional predicate; - - friend bool operator==(const MemoryOp &, const MemoryOp &); - std::vector bincodeSerialize() const; - static MemoryOp bincodeDeserialize(std::vector); - }; - - struct MemoryInit { - Program::BlockId block_id; - std::vector init; - - friend bool operator==(const MemoryInit &, const MemoryInit &); - std::vector bincodeSerialize() const; - static MemoryInit bincodeDeserialize(std::vector); - }; - - struct BrilligCall { - uint32_t id; - std::vector inputs; - std::vector outputs; - std::optional predicate; - - friend bool operator==(const BrilligCall &, const BrilligCall &); - std::vector bincodeSerialize() const; - static BrilligCall bincodeDeserialize(std::vector); - }; - - struct Call { - uint32_t id; - std::vector inputs; - std::vector outputs; - std::optional predicate; - - friend bool operator==(const Call &, const Call &); - std::vector bincodeSerialize() const; - static Call bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const Opcode &, const Opcode &); - std::vector bincodeSerialize() const; - static Opcode bincodeDeserialize(std::vector); -}; - -struct BinaryFieldOp { - - struct Add { - friend bool operator==(const Add &, const Add &); - std::vector bincodeSerialize() const; - static Add bincodeDeserialize(std::vector); - }; - - struct Sub { - friend bool operator==(const Sub &, const Sub &); - std::vector bincodeSerialize() const; - static Sub bincodeDeserialize(std::vector); - }; - - struct Mul { - friend bool operator==(const Mul &, const Mul &); - std::vector bincodeSerialize() const; - static Mul bincodeDeserialize(std::vector); - }; - - struct Div { - friend bool operator==(const Div &, const Div &); - std::vector bincodeSerialize() const; - static Div bincodeDeserialize(std::vector); - }; - - struct IntegerDiv { - friend bool operator==(const IntegerDiv &, const IntegerDiv &); - std::vector bincodeSerialize() const; - static IntegerDiv bincodeDeserialize(std::vector); - }; - - struct Equals { - friend bool operator==(const Equals &, const Equals &); - std::vector bincodeSerialize() const; - static Equals bincodeDeserialize(std::vector); - }; - - struct LessThan { - friend bool operator==(const LessThan &, const LessThan &); - std::vector bincodeSerialize() const; - static LessThan bincodeDeserialize(std::vector); - }; - - struct LessThanEquals { - friend bool operator==(const LessThanEquals &, const LessThanEquals &); - std::vector bincodeSerialize() const; - static LessThanEquals bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BinaryFieldOp &, const BinaryFieldOp &); - std::vector bincodeSerialize() const; - static BinaryFieldOp bincodeDeserialize(std::vector); -}; - -struct BinaryIntOp { - - struct Add { - friend bool operator==(const Add &, const Add &); - std::vector bincodeSerialize() const; - static Add bincodeDeserialize(std::vector); - }; - - struct Sub { - friend bool operator==(const Sub &, const Sub &); - std::vector bincodeSerialize() const; - static Sub bincodeDeserialize(std::vector); - }; - - struct Mul { - friend bool operator==(const Mul &, const Mul &); - std::vector bincodeSerialize() const; - static Mul bincodeDeserialize(std::vector); - }; - - struct Div { - friend bool operator==(const Div &, const Div &); - std::vector bincodeSerialize() const; - static Div bincodeDeserialize(std::vector); - }; - - struct Equals { - friend bool operator==(const Equals &, const Equals &); - std::vector bincodeSerialize() const; - static Equals bincodeDeserialize(std::vector); - }; - - struct LessThan { - friend bool operator==(const LessThan &, const LessThan &); - std::vector bincodeSerialize() const; - static LessThan bincodeDeserialize(std::vector); - }; - - struct LessThanEquals { - friend bool operator==(const LessThanEquals &, const LessThanEquals &); - std::vector bincodeSerialize() const; - static LessThanEquals bincodeDeserialize(std::vector); - }; - - struct And { - friend bool operator==(const And &, const And &); - std::vector bincodeSerialize() const; - static And bincodeDeserialize(std::vector); - }; - - struct Or { - friend bool operator==(const Or &, const Or &); - std::vector bincodeSerialize() const; - static Or bincodeDeserialize(std::vector); - }; - - struct Xor { - friend bool operator==(const Xor &, const Xor &); - std::vector bincodeSerialize() const; - static Xor bincodeDeserialize(std::vector); - }; - - struct Shl { - friend bool operator==(const Shl &, const Shl &); - std::vector bincodeSerialize() const; - static Shl bincodeDeserialize(std::vector); - }; - - struct Shr { - friend bool operator==(const Shr &, const Shr &); - std::vector bincodeSerialize() const; - static Shr bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BinaryIntOp &, const BinaryIntOp &); - std::vector bincodeSerialize() const; - static BinaryIntOp bincodeDeserialize(std::vector); -}; - -struct MemoryAddress { - uint64_t value; - - friend bool operator==(const MemoryAddress &, const MemoryAddress &); - std::vector bincodeSerialize() const; - static MemoryAddress bincodeDeserialize(std::vector); -}; - -struct HeapArray { - Program::MemoryAddress pointer; - uint64_t size; - - friend bool operator==(const HeapArray &, const HeapArray &); - std::vector bincodeSerialize() const; - static HeapArray bincodeDeserialize(std::vector); -}; - -struct HeapVector { - Program::MemoryAddress pointer; - Program::MemoryAddress size; - - friend bool operator==(const HeapVector &, const HeapVector &); - std::vector bincodeSerialize() const; - static HeapVector bincodeDeserialize(std::vector); -}; - -struct BlackBoxOp { - - struct AES128Encrypt { - Program::HeapVector inputs; - Program::HeapArray iv; - Program::HeapArray key; - Program::HeapVector outputs; - - friend bool operator==(const AES128Encrypt &, const AES128Encrypt &); - std::vector bincodeSerialize() const; - static AES128Encrypt bincodeDeserialize(std::vector); - }; - - struct Sha256 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Sha256 &, const Sha256 &); - std::vector bincodeSerialize() const; - static Sha256 bincodeDeserialize(std::vector); - }; - - struct Blake2s { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Blake2s &, const Blake2s &); - std::vector bincodeSerialize() const; - static Blake2s bincodeDeserialize(std::vector); - }; - - struct Blake3 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Blake3 &, const Blake3 &); - std::vector bincodeSerialize() const; - static Blake3 bincodeDeserialize(std::vector); - }; - - struct Keccak256 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Keccak256 &, const Keccak256 &); - std::vector bincodeSerialize() const; - static Keccak256 bincodeDeserialize(std::vector); - }; - - struct Keccakf1600 { - Program::HeapVector message; - Program::HeapArray output; - - friend bool operator==(const Keccakf1600 &, const Keccakf1600 &); - std::vector bincodeSerialize() const; - static Keccakf1600 bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256k1 { - 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 bincodeSerialize() const; - static EcdsaSecp256k1 bincodeDeserialize(std::vector); - }; - - struct EcdsaSecp256r1 { - 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 bincodeSerialize() const; - static EcdsaSecp256r1 bincodeDeserialize(std::vector); - }; - - struct SchnorrVerify { - 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 bincodeSerialize() const; - static SchnorrVerify bincodeDeserialize(std::vector); - }; - - struct PedersenCommitment { - Program::HeapVector inputs; - Program::MemoryAddress domain_separator; - Program::HeapArray output; - - friend bool operator==(const PedersenCommitment &, - const PedersenCommitment &); - std::vector bincodeSerialize() const; - static PedersenCommitment bincodeDeserialize(std::vector); - }; - - struct PedersenHash { - Program::HeapVector inputs; - Program::MemoryAddress domain_separator; - Program::MemoryAddress output; - - friend bool operator==(const PedersenHash &, const PedersenHash &); - std::vector bincodeSerialize() const; - static PedersenHash bincodeDeserialize(std::vector); - }; - - struct MultiScalarMul { - Program::HeapVector points; - Program::HeapVector scalars; - Program::HeapArray outputs; - - friend bool operator==(const MultiScalarMul &, const MultiScalarMul &); - std::vector bincodeSerialize() const; - static MultiScalarMul bincodeDeserialize(std::vector); - }; - - struct EmbeddedCurveAdd { - 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 bincodeSerialize() const; - static EmbeddedCurveAdd bincodeDeserialize(std::vector); - }; - - struct BigIntAdd { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntAdd &, const BigIntAdd &); - std::vector bincodeSerialize() const; - static BigIntAdd bincodeDeserialize(std::vector); - }; - - struct BigIntSub { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntSub &, const BigIntSub &); - std::vector bincodeSerialize() const; - static BigIntSub bincodeDeserialize(std::vector); - }; - - struct BigIntMul { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntMul &, const BigIntMul &); - std::vector bincodeSerialize() const; - static BigIntMul bincodeDeserialize(std::vector); - }; - - struct BigIntDiv { - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - Program::MemoryAddress output; - - friend bool operator==(const BigIntDiv &, const BigIntDiv &); - std::vector bincodeSerialize() const; - static BigIntDiv bincodeDeserialize(std::vector); - }; - - struct BigIntFromLeBytes { - Program::HeapVector inputs; - Program::HeapVector modulus; - Program::MemoryAddress output; - - friend bool operator==(const BigIntFromLeBytes &, - const BigIntFromLeBytes &); - std::vector bincodeSerialize() const; - static BigIntFromLeBytes bincodeDeserialize(std::vector); - }; - - struct BigIntToLeBytes { - Program::MemoryAddress input; - Program::HeapVector output; - - friend bool operator==(const BigIntToLeBytes &, const BigIntToLeBytes &); - std::vector bincodeSerialize() const; - static BigIntToLeBytes bincodeDeserialize(std::vector); - }; - - struct Poseidon2Permutation { - Program::HeapVector message; - Program::HeapArray output; - Program::MemoryAddress len; - - friend bool operator==(const Poseidon2Permutation &, - const Poseidon2Permutation &); - std::vector bincodeSerialize() const; - static Poseidon2Permutation bincodeDeserialize(std::vector); - }; - - struct Sha256Compression { - Program::HeapVector input; - Program::HeapVector hash_values; - Program::HeapArray output; - - friend bool operator==(const Sha256Compression &, - const Sha256Compression &); - std::vector bincodeSerialize() const; - static Sha256Compression bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BlackBoxOp &, const BlackBoxOp &); - std::vector bincodeSerialize() const; - static BlackBoxOp bincodeDeserialize(std::vector); -}; - -struct HeapValueType; - -struct HeapValueType { - - struct Simple { - uint32_t value; - - friend bool operator==(const Simple &, const Simple &); - std::vector bincodeSerialize() const; - static Simple bincodeDeserialize(std::vector); - }; - - struct Array { - std::vector value_types; - uint64_t size; - - friend bool operator==(const Array &, const Array &); - std::vector bincodeSerialize() const; - static Array bincodeDeserialize(std::vector); - }; - - struct Vector { - std::vector value_types; - - friend bool operator==(const Vector &, const Vector &); - std::vector bincodeSerialize() const; - static Vector bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const HeapValueType &, const HeapValueType &); - std::vector bincodeSerialize() const; - static HeapValueType bincodeDeserialize(std::vector); -}; - -struct ValueOrArray { - - struct MemoryAddress { - Program::MemoryAddress value; - - friend bool operator==(const MemoryAddress &, const MemoryAddress &); - std::vector bincodeSerialize() const; - static MemoryAddress bincodeDeserialize(std::vector); - }; - - struct HeapArray { - Program::HeapArray value; - - friend bool operator==(const HeapArray &, const HeapArray &); - std::vector bincodeSerialize() const; - static HeapArray bincodeDeserialize(std::vector); - }; - - struct HeapVector { - Program::HeapVector value; - - friend bool operator==(const HeapVector &, const HeapVector &); - std::vector bincodeSerialize() const; - static HeapVector bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const ValueOrArray &, const ValueOrArray &); - std::vector bincodeSerialize() const; - static ValueOrArray bincodeDeserialize(std::vector); -}; - -struct BrilligOpcode { - - struct BinaryFieldOp { - Program::MemoryAddress destination; - Program::BinaryFieldOp op; - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - - friend bool operator==(const BinaryFieldOp &, const BinaryFieldOp &); - std::vector bincodeSerialize() const; - static BinaryFieldOp bincodeDeserialize(std::vector); - }; - - struct BinaryIntOp { - Program::MemoryAddress destination; - Program::BinaryIntOp op; - uint32_t bit_size; - Program::MemoryAddress lhs; - Program::MemoryAddress rhs; - - friend bool operator==(const BinaryIntOp &, const BinaryIntOp &); - std::vector bincodeSerialize() const; - static BinaryIntOp bincodeDeserialize(std::vector); - }; - - struct Cast { - Program::MemoryAddress destination; - Program::MemoryAddress source; - uint32_t bit_size; - - friend bool operator==(const Cast &, const Cast &); - std::vector bincodeSerialize() const; - static Cast bincodeDeserialize(std::vector); - }; - - struct JumpIfNot { - Program::MemoryAddress condition; - uint64_t location; - - friend bool operator==(const JumpIfNot &, const JumpIfNot &); - std::vector bincodeSerialize() const; - static JumpIfNot bincodeDeserialize(std::vector); - }; - - struct JumpIf { - Program::MemoryAddress condition; - uint64_t location; - - friend bool operator==(const JumpIf &, const JumpIf &); - std::vector bincodeSerialize() const; - static JumpIf bincodeDeserialize(std::vector); - }; - - struct Jump { - uint64_t location; - - friend bool operator==(const Jump &, const Jump &); - std::vector bincodeSerialize() const; - static Jump bincodeDeserialize(std::vector); - }; - - struct CalldataCopy { - Program::MemoryAddress destination_address; - uint64_t size; - uint64_t offset; - - friend bool operator==(const CalldataCopy &, const CalldataCopy &); - std::vector bincodeSerialize() const; - static CalldataCopy bincodeDeserialize(std::vector); - }; - - struct Call { - uint64_t location; - - friend bool operator==(const Call &, const Call &); - std::vector bincodeSerialize() const; - static Call bincodeDeserialize(std::vector); - }; - - struct Const { - Program::MemoryAddress destination; - uint32_t bit_size; - std::string value; - - friend bool operator==(const Const &, const Const &); - std::vector bincodeSerialize() const; - static Const bincodeDeserialize(std::vector); - }; - - struct Return { - friend bool operator==(const Return &, const Return &); - std::vector bincodeSerialize() const; - static Return bincodeDeserialize(std::vector); - }; - - struct ForeignCall { - std::string function; - std::vector destinations; - std::vector destination_value_types; - std::vector inputs; - std::vector input_value_types; - - friend bool operator==(const ForeignCall &, const ForeignCall &); - std::vector bincodeSerialize() const; - static ForeignCall bincodeDeserialize(std::vector); - }; - - struct Mov { - Program::MemoryAddress destination; - Program::MemoryAddress source; - - friend bool operator==(const Mov &, const Mov &); - std::vector bincodeSerialize() const; - static Mov bincodeDeserialize(std::vector); - }; - - 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 bincodeSerialize() const; - static ConditionalMov bincodeDeserialize(std::vector); - }; - - struct Load { - Program::MemoryAddress destination; - Program::MemoryAddress source_pointer; - - friend bool operator==(const Load &, const Load &); - std::vector bincodeSerialize() const; - static Load bincodeDeserialize(std::vector); - }; - - struct Store { - Program::MemoryAddress destination_pointer; - Program::MemoryAddress source; - - friend bool operator==(const Store &, const Store &); - std::vector bincodeSerialize() const; - static Store bincodeDeserialize(std::vector); - }; - - struct BlackBox { - Program::BlackBoxOp value; - - friend bool operator==(const BlackBox &, const BlackBox &); - std::vector bincodeSerialize() const; - static BlackBox bincodeDeserialize(std::vector); - }; - - struct Trap { - Program::HeapArray revert_data; - - friend bool operator==(const Trap &, const Trap &); - std::vector bincodeSerialize() const; - static Trap bincodeDeserialize(std::vector); - }; - - struct Stop { - uint64_t return_data_offset; - uint64_t return_data_size; - - friend bool operator==(const Stop &, const Stop &); - std::vector bincodeSerialize() const; - static Stop bincodeDeserialize(std::vector); - }; - - std::variant - value; - - friend bool operator==(const BrilligOpcode &, const BrilligOpcode &); - std::vector bincodeSerialize() const; - static BrilligOpcode bincodeDeserialize(std::vector); -}; - -struct ExpressionOrMemory { - - struct Expression { - Program::Expression value; - - friend bool operator==(const Expression &, const Expression &); - std::vector bincodeSerialize() const; - static Expression bincodeDeserialize(std::vector); - }; - - struct Memory { - Program::BlockId value; - - friend bool operator==(const Memory &, const Memory &); - std::vector bincodeSerialize() const; - static Memory bincodeDeserialize(std::vector); - }; - - std::variant value; - - friend bool operator==(const ExpressionOrMemory &, - const ExpressionOrMemory &); - std::vector bincodeSerialize() const; - static ExpressionOrMemory bincodeDeserialize(std::vector); -}; - -struct AssertionPayload { - - struct StaticString { - std::string value; - - friend bool operator==(const StaticString &, const StaticString &); - std::vector bincodeSerialize() const; - static StaticString bincodeDeserialize(std::vector); - }; - - struct Dynamic { - std::tuple> value; - - friend bool operator==(const Dynamic &, const Dynamic &); - std::vector bincodeSerialize() const; - static Dynamic bincodeDeserialize(std::vector); - }; + struct Witness { + uint32_t value; + + friend bool operator==(const Witness&, const Witness&); + std::vector bincodeSerialize() const; + static Witness bincodeDeserialize(std::vector); + }; + + struct FunctionInput { + Program::Witness witness; + uint32_t num_bits; + + friend bool operator==(const FunctionInput&, const FunctionInput&); + std::vector bincodeSerialize() const; + static FunctionInput bincodeDeserialize(std::vector); + }; + + struct BlackBoxFuncCall { + + struct AES128Encrypt { + std::vector inputs; + std::array iv; + std::array key; + std::vector outputs; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + + struct AND { + Program::FunctionInput lhs; + Program::FunctionInput rhs; + Program::Witness output; + + friend bool operator==(const AND&, const AND&); + std::vector bincodeSerialize() const; + static AND bincodeDeserialize(std::vector); + }; + + struct XOR { + Program::FunctionInput lhs; + Program::FunctionInput rhs; + Program::Witness output; + + friend bool operator==(const XOR&, const XOR&); + std::vector bincodeSerialize() const; + static XOR bincodeDeserialize(std::vector); + }; + + struct RANGE { + Program::FunctionInput input; + + friend bool operator==(const RANGE&, const RANGE&); + std::vector bincodeSerialize() const; + static RANGE bincodeDeserialize(std::vector); + }; + + struct SHA256 { + std::vector inputs; + std::array outputs; + + friend bool operator==(const SHA256&, const SHA256&); + std::vector bincodeSerialize() const; + static SHA256 bincodeDeserialize(std::vector); + }; + + struct Blake2s { + std::vector inputs; + std::array outputs; + + friend bool operator==(const Blake2s&, const Blake2s&); + std::vector bincodeSerialize() const; + static Blake2s bincodeDeserialize(std::vector); + }; + + struct Blake3 { + std::vector inputs; + std::array outputs; + + friend bool operator==(const Blake3&, const Blake3&); + std::vector bincodeSerialize() const; + static Blake3 bincodeDeserialize(std::vector); + }; + + struct SchnorrVerify { + Program::FunctionInput public_key_x; + Program::FunctionInput public_key_y; + std::array signature; + std::vector message; + Program::Witness output; + + friend bool operator==(const SchnorrVerify&, const SchnorrVerify&); + std::vector bincodeSerialize() const; + static SchnorrVerify bincodeDeserialize(std::vector); + }; + + struct PedersenCommitment { + std::vector inputs; + uint32_t domain_separator; + std::array outputs; + + friend bool operator==(const PedersenCommitment&, const PedersenCommitment&); + std::vector bincodeSerialize() const; + static PedersenCommitment bincodeDeserialize(std::vector); + }; + + struct PedersenHash { + std::vector inputs; + uint32_t domain_separator; + Program::Witness output; + + friend bool operator==(const PedersenHash&, const PedersenHash&); + std::vector bincodeSerialize() const; + static PedersenHash bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256k1 { + std::array public_key_x; + std::array public_key_y; + std::array signature; + std::array hashed_message; + Program::Witness output; + + friend bool operator==(const EcdsaSecp256k1&, const EcdsaSecp256k1&); + std::vector bincodeSerialize() const; + static EcdsaSecp256k1 bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256r1 { + std::array public_key_x; + std::array public_key_y; + std::array signature; + std::array hashed_message; + Program::Witness output; + + friend bool operator==(const EcdsaSecp256r1&, const EcdsaSecp256r1&); + std::vector bincodeSerialize() const; + static EcdsaSecp256r1 bincodeDeserialize(std::vector); + }; + + struct MultiScalarMul { + std::vector points; + std::vector scalars; + std::array outputs; + + friend bool operator==(const MultiScalarMul&, const MultiScalarMul&); + std::vector bincodeSerialize() const; + static MultiScalarMul bincodeDeserialize(std::vector); + }; + + struct EmbeddedCurveAdd { + Program::FunctionInput input1_x; + Program::FunctionInput input1_y; + Program::FunctionInput input2_x; + Program::FunctionInput input2_y; + std::array outputs; + + friend bool operator==(const EmbeddedCurveAdd&, const EmbeddedCurveAdd&); + std::vector bincodeSerialize() const; + static EmbeddedCurveAdd bincodeDeserialize(std::vector); + }; + + struct Keccak256 { + std::vector inputs; + Program::FunctionInput var_message_size; + std::array outputs; + + friend bool operator==(const Keccak256&, const Keccak256&); + std::vector bincodeSerialize() const; + static Keccak256 bincodeDeserialize(std::vector); + }; + + struct Keccakf1600 { + std::array inputs; + std::array outputs; + + friend bool operator==(const Keccakf1600&, const Keccakf1600&); + std::vector bincodeSerialize() const; + static Keccakf1600 bincodeDeserialize(std::vector); + }; + + struct RecursiveAggregation { + std::vector verification_key; + std::vector proof; + std::vector public_inputs; + Program::FunctionInput key_hash; + + friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&); + std::vector bincodeSerialize() const; + static RecursiveAggregation bincodeDeserialize(std::vector); + }; + + struct BigIntAdd { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntAdd&, const BigIntAdd&); + std::vector bincodeSerialize() const; + static BigIntAdd bincodeDeserialize(std::vector); + }; + + struct BigIntSub { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntSub&, const BigIntSub&); + std::vector bincodeSerialize() const; + static BigIntSub bincodeDeserialize(std::vector); + }; + + struct BigIntMul { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntMul&, const BigIntMul&); + std::vector bincodeSerialize() const; + static BigIntMul bincodeDeserialize(std::vector); + }; + + struct BigIntDiv { + uint32_t lhs; + uint32_t rhs; + uint32_t output; + + friend bool operator==(const BigIntDiv&, const BigIntDiv&); + std::vector bincodeSerialize() const; + static BigIntDiv bincodeDeserialize(std::vector); + }; + + struct BigIntFromLeBytes { + std::vector inputs; + std::vector modulus; + uint32_t output; + + friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&); + std::vector bincodeSerialize() const; + static BigIntFromLeBytes bincodeDeserialize(std::vector); + }; + + struct BigIntToLeBytes { + uint32_t input; + std::vector outputs; + + friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&); + std::vector bincodeSerialize() const; + static BigIntToLeBytes bincodeDeserialize(std::vector); + }; + + struct Poseidon2Permutation { + std::vector inputs; + std::vector outputs; + uint32_t len; + + friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&); + std::vector bincodeSerialize() const; + static Poseidon2Permutation bincodeDeserialize(std::vector); + }; + + struct Sha256Compression { + std::array inputs; + std::array hash_values; + std::array outputs; + + friend bool operator==(const Sha256Compression&, const Sha256Compression&); + std::vector bincodeSerialize() const; + static Sha256Compression bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); + std::vector bincodeSerialize() const; + static BlackBoxFuncCall bincodeDeserialize(std::vector); + }; + + struct BlockId { + uint32_t value; + + friend bool operator==(const BlockId&, const BlockId&); + std::vector bincodeSerialize() const; + static BlockId bincodeDeserialize(std::vector); + }; + + struct Expression { + std::vector> mul_terms; + std::vector> linear_combinations; + std::string q_c; + + friend bool operator==(const Expression&, const Expression&); + std::vector bincodeSerialize() const; + static Expression bincodeDeserialize(std::vector); + }; + + struct BrilligInputs { + + struct Single { + Program::Expression value; + + friend bool operator==(const Single&, const Single&); + std::vector bincodeSerialize() const; + static Single bincodeDeserialize(std::vector); + }; + + struct Array { + std::vector value; + + friend bool operator==(const Array&, const Array&); + std::vector bincodeSerialize() const; + static Array bincodeDeserialize(std::vector); + }; + + struct MemoryArray { + Program::BlockId value; + + friend bool operator==(const MemoryArray&, const MemoryArray&); + std::vector bincodeSerialize() const; + static MemoryArray bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BrilligInputs&, const BrilligInputs&); + std::vector bincodeSerialize() const; + static BrilligInputs bincodeDeserialize(std::vector); + }; + + struct BrilligOutputs { + + struct Simple { + Program::Witness value; + + friend bool operator==(const Simple&, const Simple&); + std::vector bincodeSerialize() const; + static Simple bincodeDeserialize(std::vector); + }; + + struct Array { + std::vector value; + + friend bool operator==(const Array&, const Array&); + std::vector bincodeSerialize() const; + static Array bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BrilligOutputs&, const BrilligOutputs&); + std::vector bincodeSerialize() const; + static BrilligOutputs bincodeDeserialize(std::vector); + }; + + struct Directive { + + struct ToLeRadix { + Program::Expression a; + std::vector b; + uint32_t radix; + + friend bool operator==(const ToLeRadix&, const ToLeRadix&); + std::vector bincodeSerialize() const; + static ToLeRadix bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const Directive&, const Directive&); + std::vector bincodeSerialize() const; + static Directive bincodeDeserialize(std::vector); + }; + + struct MemOp { + Program::Expression operation; + Program::Expression index; + Program::Expression value; + + friend bool operator==(const MemOp&, const MemOp&); + std::vector bincodeSerialize() const; + static MemOp bincodeDeserialize(std::vector); + }; + + struct Opcode { + + struct AssertZero { + Program::Expression value; + + friend bool operator==(const AssertZero&, const AssertZero&); + std::vector bincodeSerialize() const; + static AssertZero bincodeDeserialize(std::vector); + }; + + struct BlackBoxFuncCall { + Program::BlackBoxFuncCall value; + + friend bool operator==(const BlackBoxFuncCall&, const BlackBoxFuncCall&); + std::vector bincodeSerialize() const; + static BlackBoxFuncCall bincodeDeserialize(std::vector); + }; + + struct Directive { + Program::Directive value; + + friend bool operator==(const Directive&, const Directive&); + std::vector bincodeSerialize() const; + static Directive bincodeDeserialize(std::vector); + }; + + struct MemoryOp { + Program::BlockId block_id; + Program::MemOp op; + std::optional predicate; + + friend bool operator==(const MemoryOp&, const MemoryOp&); + std::vector bincodeSerialize() const; + static MemoryOp bincodeDeserialize(std::vector); + }; + + struct MemoryInit { + Program::BlockId block_id; + std::vector init; + + friend bool operator==(const MemoryInit&, const MemoryInit&); + std::vector bincodeSerialize() const; + static MemoryInit bincodeDeserialize(std::vector); + }; + + struct BrilligCall { + uint32_t id; + std::vector inputs; + std::vector outputs; + std::optional predicate; + + friend bool operator==(const BrilligCall&, const BrilligCall&); + std::vector bincodeSerialize() const; + static BrilligCall bincodeDeserialize(std::vector); + }; + + struct Call { + uint32_t id; + std::vector inputs; + std::vector outputs; + std::optional predicate; + + friend bool operator==(const Call&, const Call&); + std::vector bincodeSerialize() const; + static Call bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const Opcode&, const Opcode&); + std::vector bincodeSerialize() const; + static Opcode bincodeDeserialize(std::vector); + }; + + struct BinaryFieldOp { + + struct Add { + friend bool operator==(const Add&, const Add&); + std::vector bincodeSerialize() const; + static Add bincodeDeserialize(std::vector); + }; + + struct Sub { + friend bool operator==(const Sub&, const Sub&); + std::vector bincodeSerialize() const; + static Sub bincodeDeserialize(std::vector); + }; + + struct Mul { + friend bool operator==(const Mul&, const Mul&); + std::vector bincodeSerialize() const; + static Mul bincodeDeserialize(std::vector); + }; + + struct Div { + friend bool operator==(const Div&, const Div&); + std::vector bincodeSerialize() const; + static Div bincodeDeserialize(std::vector); + }; + + struct IntegerDiv { + friend bool operator==(const IntegerDiv&, const IntegerDiv&); + std::vector bincodeSerialize() const; + static IntegerDiv bincodeDeserialize(std::vector); + }; + + struct Equals { + friend bool operator==(const Equals&, const Equals&); + std::vector bincodeSerialize() const; + static Equals bincodeDeserialize(std::vector); + }; + + struct LessThan { + friend bool operator==(const LessThan&, const LessThan&); + std::vector bincodeSerialize() const; + static LessThan bincodeDeserialize(std::vector); + }; + + struct LessThanEquals { + friend bool operator==(const LessThanEquals&, const LessThanEquals&); + std::vector bincodeSerialize() const; + static LessThanEquals bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&); + std::vector bincodeSerialize() const; + static BinaryFieldOp bincodeDeserialize(std::vector); + }; + + struct BinaryIntOp { + + struct Add { + friend bool operator==(const Add&, const Add&); + std::vector bincodeSerialize() const; + static Add bincodeDeserialize(std::vector); + }; + + struct Sub { + friend bool operator==(const Sub&, const Sub&); + std::vector bincodeSerialize() const; + static Sub bincodeDeserialize(std::vector); + }; + + struct Mul { + friend bool operator==(const Mul&, const Mul&); + std::vector bincodeSerialize() const; + static Mul bincodeDeserialize(std::vector); + }; + + struct Div { + friend bool operator==(const Div&, const Div&); + std::vector bincodeSerialize() const; + static Div bincodeDeserialize(std::vector); + }; + + struct Equals { + friend bool operator==(const Equals&, const Equals&); + std::vector bincodeSerialize() const; + static Equals bincodeDeserialize(std::vector); + }; + + struct LessThan { + friend bool operator==(const LessThan&, const LessThan&); + std::vector bincodeSerialize() const; + static LessThan bincodeDeserialize(std::vector); + }; + + struct LessThanEquals { + friend bool operator==(const LessThanEquals&, const LessThanEquals&); + std::vector bincodeSerialize() const; + static LessThanEquals bincodeDeserialize(std::vector); + }; + + struct And { + friend bool operator==(const And&, const And&); + std::vector bincodeSerialize() const; + static And bincodeDeserialize(std::vector); + }; + + struct Or { + friend bool operator==(const Or&, const Or&); + std::vector bincodeSerialize() const; + static Or bincodeDeserialize(std::vector); + }; + + struct Xor { + friend bool operator==(const Xor&, const Xor&); + std::vector bincodeSerialize() const; + static Xor bincodeDeserialize(std::vector); + }; + + struct Shl { + friend bool operator==(const Shl&, const Shl&); + std::vector bincodeSerialize() const; + static Shl bincodeDeserialize(std::vector); + }; + + struct Shr { + friend bool operator==(const Shr&, const Shr&); + std::vector bincodeSerialize() const; + static Shr bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BinaryIntOp&, const BinaryIntOp&); + std::vector bincodeSerialize() const; + static BinaryIntOp bincodeDeserialize(std::vector); + }; + + struct MemoryAddress { + uint64_t value; + + friend bool operator==(const MemoryAddress&, const MemoryAddress&); + std::vector bincodeSerialize() const; + static MemoryAddress bincodeDeserialize(std::vector); + }; + + struct HeapArray { + Program::MemoryAddress pointer; + uint64_t size; + + friend bool operator==(const HeapArray&, const HeapArray&); + std::vector bincodeSerialize() const; + static HeapArray bincodeDeserialize(std::vector); + }; + + struct HeapVector { + Program::MemoryAddress pointer; + Program::MemoryAddress size; + + friend bool operator==(const HeapVector&, const HeapVector&); + std::vector bincodeSerialize() const; + static HeapVector bincodeDeserialize(std::vector); + }; + + struct BlackBoxOp { + + struct AES128Encrypt { + Program::HeapVector inputs; + Program::HeapArray iv; + Program::HeapArray key; + Program::HeapVector outputs; + + friend bool operator==(const AES128Encrypt&, const AES128Encrypt&); + std::vector bincodeSerialize() const; + static AES128Encrypt bincodeDeserialize(std::vector); + }; + + struct Sha256 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Sha256&, const Sha256&); + std::vector bincodeSerialize() const; + static Sha256 bincodeDeserialize(std::vector); + }; + + struct Blake2s { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Blake2s&, const Blake2s&); + std::vector bincodeSerialize() const; + static Blake2s bincodeDeserialize(std::vector); + }; + + struct Blake3 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Blake3&, const Blake3&); + std::vector bincodeSerialize() const; + static Blake3 bincodeDeserialize(std::vector); + }; + + struct Keccak256 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Keccak256&, const Keccak256&); + std::vector bincodeSerialize() const; + static Keccak256 bincodeDeserialize(std::vector); + }; + + struct Keccakf1600 { + Program::HeapVector message; + Program::HeapArray output; + + friend bool operator==(const Keccakf1600&, const Keccakf1600&); + std::vector bincodeSerialize() const; + static Keccakf1600 bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256k1 { + 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 bincodeSerialize() const; + static EcdsaSecp256k1 bincodeDeserialize(std::vector); + }; + + struct EcdsaSecp256r1 { + 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 bincodeSerialize() const; + static EcdsaSecp256r1 bincodeDeserialize(std::vector); + }; + + struct SchnorrVerify { + 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 bincodeSerialize() const; + static SchnorrVerify bincodeDeserialize(std::vector); + }; + + struct PedersenCommitment { + Program::HeapVector inputs; + Program::MemoryAddress domain_separator; + Program::HeapArray output; + + friend bool operator==(const PedersenCommitment&, const PedersenCommitment&); + std::vector bincodeSerialize() const; + static PedersenCommitment bincodeDeserialize(std::vector); + }; + + struct PedersenHash { + Program::HeapVector inputs; + Program::MemoryAddress domain_separator; + Program::MemoryAddress output; + + friend bool operator==(const PedersenHash&, const PedersenHash&); + std::vector bincodeSerialize() const; + static PedersenHash bincodeDeserialize(std::vector); + }; + + struct MultiScalarMul { + Program::HeapVector points; + Program::HeapVector scalars; + Program::HeapArray outputs; + + friend bool operator==(const MultiScalarMul&, const MultiScalarMul&); + std::vector bincodeSerialize() const; + static MultiScalarMul bincodeDeserialize(std::vector); + }; + + struct EmbeddedCurveAdd { + 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 bincodeSerialize() const; + static EmbeddedCurveAdd bincodeDeserialize(std::vector); + }; + + struct BigIntAdd { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntAdd&, const BigIntAdd&); + std::vector bincodeSerialize() const; + static BigIntAdd bincodeDeserialize(std::vector); + }; + + struct BigIntSub { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntSub&, const BigIntSub&); + std::vector bincodeSerialize() const; + static BigIntSub bincodeDeserialize(std::vector); + }; + + struct BigIntMul { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntMul&, const BigIntMul&); + std::vector bincodeSerialize() const; + static BigIntMul bincodeDeserialize(std::vector); + }; + + struct BigIntDiv { + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + Program::MemoryAddress output; + + friend bool operator==(const BigIntDiv&, const BigIntDiv&); + std::vector bincodeSerialize() const; + static BigIntDiv bincodeDeserialize(std::vector); + }; + + struct BigIntFromLeBytes { + Program::HeapVector inputs; + Program::HeapVector modulus; + Program::MemoryAddress output; + + friend bool operator==(const BigIntFromLeBytes&, const BigIntFromLeBytes&); + std::vector bincodeSerialize() const; + static BigIntFromLeBytes bincodeDeserialize(std::vector); + }; + + struct BigIntToLeBytes { + Program::MemoryAddress input; + Program::HeapVector output; + + friend bool operator==(const BigIntToLeBytes&, const BigIntToLeBytes&); + std::vector bincodeSerialize() const; + static BigIntToLeBytes bincodeDeserialize(std::vector); + }; + + struct Poseidon2Permutation { + Program::HeapVector message; + Program::HeapArray output; + Program::MemoryAddress len; + + friend bool operator==(const Poseidon2Permutation&, const Poseidon2Permutation&); + std::vector bincodeSerialize() const; + static Poseidon2Permutation bincodeDeserialize(std::vector); + }; + + struct Sha256Compression { + Program::HeapVector input; + Program::HeapVector hash_values; + Program::HeapArray output; + + friend bool operator==(const Sha256Compression&, const Sha256Compression&); + std::vector bincodeSerialize() const; + static Sha256Compression bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BlackBoxOp&, const BlackBoxOp&); + std::vector bincodeSerialize() const; + static BlackBoxOp bincodeDeserialize(std::vector); + }; + + struct HeapValueType; + + struct HeapValueType { + + struct Simple { + uint32_t value; + + friend bool operator==(const Simple&, const Simple&); + std::vector bincodeSerialize() const; + static Simple bincodeDeserialize(std::vector); + }; + + struct Array { + std::vector value_types; + uint64_t size; + + friend bool operator==(const Array&, const Array&); + std::vector bincodeSerialize() const; + static Array bincodeDeserialize(std::vector); + }; + + struct Vector { + std::vector value_types; + + friend bool operator==(const Vector&, const Vector&); + std::vector bincodeSerialize() const; + static Vector bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const HeapValueType&, const HeapValueType&); + std::vector bincodeSerialize() const; + static HeapValueType bincodeDeserialize(std::vector); + }; + + struct ValueOrArray { + + struct MemoryAddress { + Program::MemoryAddress value; + + friend bool operator==(const MemoryAddress&, const MemoryAddress&); + std::vector bincodeSerialize() const; + static MemoryAddress bincodeDeserialize(std::vector); + }; + + struct HeapArray { + Program::HeapArray value; + + friend bool operator==(const HeapArray&, const HeapArray&); + std::vector bincodeSerialize() const; + static HeapArray bincodeDeserialize(std::vector); + }; + + struct HeapVector { + Program::HeapVector value; + + friend bool operator==(const HeapVector&, const HeapVector&); + std::vector bincodeSerialize() const; + static HeapVector bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const ValueOrArray&, const ValueOrArray&); + std::vector bincodeSerialize() const; + static ValueOrArray bincodeDeserialize(std::vector); + }; + + struct BrilligOpcode { + + struct BinaryFieldOp { + Program::MemoryAddress destination; + Program::BinaryFieldOp op; + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + + friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&); + std::vector bincodeSerialize() const; + static BinaryFieldOp bincodeDeserialize(std::vector); + }; + + struct BinaryIntOp { + Program::MemoryAddress destination; + Program::BinaryIntOp op; + uint32_t bit_size; + Program::MemoryAddress lhs; + Program::MemoryAddress rhs; + + friend bool operator==(const BinaryIntOp&, const BinaryIntOp&); + std::vector bincodeSerialize() const; + static BinaryIntOp bincodeDeserialize(std::vector); + }; + + struct Cast { + Program::MemoryAddress destination; + Program::MemoryAddress source; + uint32_t bit_size; + + friend bool operator==(const Cast&, const Cast&); + std::vector bincodeSerialize() const; + static Cast bincodeDeserialize(std::vector); + }; + + struct JumpIfNot { + Program::MemoryAddress condition; + uint64_t location; + + friend bool operator==(const JumpIfNot&, const JumpIfNot&); + std::vector bincodeSerialize() const; + static JumpIfNot bincodeDeserialize(std::vector); + }; + + struct JumpIf { + Program::MemoryAddress condition; + uint64_t location; + + friend bool operator==(const JumpIf&, const JumpIf&); + std::vector bincodeSerialize() const; + static JumpIf bincodeDeserialize(std::vector); + }; + + struct Jump { + uint64_t location; + + friend bool operator==(const Jump&, const Jump&); + std::vector bincodeSerialize() const; + static Jump bincodeDeserialize(std::vector); + }; + + struct CalldataCopy { + Program::MemoryAddress destination_address; + uint64_t size; + uint64_t offset; + + friend bool operator==(const CalldataCopy&, const CalldataCopy&); + std::vector bincodeSerialize() const; + static CalldataCopy bincodeDeserialize(std::vector); + }; + + struct Call { + uint64_t location; + + friend bool operator==(const Call&, const Call&); + std::vector bincodeSerialize() const; + static Call bincodeDeserialize(std::vector); + }; + + struct Const { + Program::MemoryAddress destination; + uint32_t bit_size; + std::string value; + + friend bool operator==(const Const&, const Const&); + std::vector bincodeSerialize() const; + static Const bincodeDeserialize(std::vector); + }; + + struct Return { + friend bool operator==(const Return&, const Return&); + std::vector bincodeSerialize() const; + static Return bincodeDeserialize(std::vector); + }; + + struct ForeignCall { + std::string function; + std::vector destinations; + std::vector destination_value_types; + std::vector inputs; + std::vector input_value_types; + + friend bool operator==(const ForeignCall&, const ForeignCall&); + std::vector bincodeSerialize() const; + static ForeignCall bincodeDeserialize(std::vector); + }; + + struct Mov { + Program::MemoryAddress destination; + Program::MemoryAddress source; + + friend bool operator==(const Mov&, const Mov&); + std::vector bincodeSerialize() const; + static Mov bincodeDeserialize(std::vector); + }; + + 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 bincodeSerialize() const; + static ConditionalMov bincodeDeserialize(std::vector); + }; + + struct Load { + Program::MemoryAddress destination; + Program::MemoryAddress source_pointer; + + friend bool operator==(const Load&, const Load&); + std::vector bincodeSerialize() const; + static Load bincodeDeserialize(std::vector); + }; + + struct Store { + Program::MemoryAddress destination_pointer; + Program::MemoryAddress source; + + friend bool operator==(const Store&, const Store&); + std::vector bincodeSerialize() const; + static Store bincodeDeserialize(std::vector); + }; + + struct BlackBox { + Program::BlackBoxOp value; + + friend bool operator==(const BlackBox&, const BlackBox&); + std::vector bincodeSerialize() const; + static BlackBox bincodeDeserialize(std::vector); + }; + + struct Trap { + Program::HeapArray revert_data; + + friend bool operator==(const Trap&, const Trap&); + std::vector bincodeSerialize() const; + static Trap bincodeDeserialize(std::vector); + }; + + struct Stop { + uint64_t return_data_offset; + uint64_t return_data_size; + + friend bool operator==(const Stop&, const Stop&); + std::vector bincodeSerialize() const; + static Stop bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const BrilligOpcode&, const BrilligOpcode&); + std::vector bincodeSerialize() const; + static BrilligOpcode bincodeDeserialize(std::vector); + }; + + struct ExpressionOrMemory { - std::variant value; + struct Expression { + Program::Expression value; + + friend bool operator==(const Expression&, const Expression&); + std::vector bincodeSerialize() const; + static Expression bincodeDeserialize(std::vector); + }; + + struct Memory { + Program::BlockId value; + + friend bool operator==(const Memory&, const Memory&); + std::vector bincodeSerialize() const; + static Memory bincodeDeserialize(std::vector); + }; + + std::variant value; + + friend bool operator==(const ExpressionOrMemory&, const ExpressionOrMemory&); + std::vector bincodeSerialize() const; + static ExpressionOrMemory bincodeDeserialize(std::vector); + }; - friend bool operator==(const AssertionPayload &, const AssertionPayload &); - std::vector bincodeSerialize() const; - static AssertionPayload bincodeDeserialize(std::vector); -}; + struct AssertionPayload { + + struct StaticString { + std::string value; -struct ExpressionWidth { + friend bool operator==(const StaticString&, const StaticString&); + std::vector bincodeSerialize() const; + static StaticString bincodeDeserialize(std::vector); + }; + + struct Dynamic { + std::tuple> value; + + friend bool operator==(const Dynamic&, const Dynamic&); + std::vector bincodeSerialize() const; + static Dynamic bincodeDeserialize(std::vector); + }; - struct Unbounded { - friend bool operator==(const Unbounded &, const Unbounded &); - std::vector bincodeSerialize() const; - static Unbounded bincodeDeserialize(std::vector); - }; + std::variant value; - struct Bounded { - uint64_t width; + friend bool operator==(const AssertionPayload&, const AssertionPayload&); + std::vector bincodeSerialize() const; + static AssertionPayload bincodeDeserialize(std::vector); + }; - friend bool operator==(const Bounded &, const Bounded &); - std::vector bincodeSerialize() const; - static Bounded bincodeDeserialize(std::vector); - }; + struct ExpressionWidth { - std::variant value; + struct Unbounded { + friend bool operator==(const Unbounded&, const Unbounded&); + std::vector bincodeSerialize() const; + static Unbounded bincodeDeserialize(std::vector); + }; - friend bool operator==(const ExpressionWidth &, const ExpressionWidth &); - std::vector bincodeSerialize() const; - static ExpressionWidth bincodeDeserialize(std::vector); -}; + struct Bounded { + uint64_t width; -struct OpcodeLocation { + friend bool operator==(const Bounded&, const Bounded&); + std::vector bincodeSerialize() const; + static Bounded bincodeDeserialize(std::vector); + }; - struct Acir { - uint64_t value; + std::variant value; - friend bool operator==(const Acir &, const Acir &); - std::vector bincodeSerialize() const; - static Acir bincodeDeserialize(std::vector); - }; + friend bool operator==(const ExpressionWidth&, const ExpressionWidth&); + std::vector bincodeSerialize() const; + static ExpressionWidth bincodeDeserialize(std::vector); + }; - struct Brillig { - uint64_t acir_index; - uint64_t brillig_index; + struct OpcodeLocation { - friend bool operator==(const Brillig &, const Brillig &); - std::vector bincodeSerialize() const; - static Brillig bincodeDeserialize(std::vector); - }; + struct Acir { + uint64_t value; - std::variant value; + friend bool operator==(const Acir&, const Acir&); + std::vector bincodeSerialize() const; + static Acir bincodeDeserialize(std::vector); + }; - friend bool operator==(const OpcodeLocation &, const OpcodeLocation &); - std::vector bincodeSerialize() const; - static OpcodeLocation bincodeDeserialize(std::vector); -}; + struct Brillig { + uint64_t acir_index; + uint64_t brillig_index; -struct PublicInputs { - std::vector value; + friend bool operator==(const Brillig&, const Brillig&); + std::vector bincodeSerialize() const; + static Brillig bincodeDeserialize(std::vector); + }; - friend bool operator==(const PublicInputs &, const PublicInputs &); - std::vector bincodeSerialize() const; - static PublicInputs bincodeDeserialize(std::vector); -}; + std::variant value; -struct Circuit { - uint32_t current_witness_index; - std::vector opcodes; - Program::ExpressionWidth expression_width; - std::vector private_parameters; - Program::PublicInputs public_parameters; - Program::PublicInputs return_values; - std::vector> - assert_messages; - bool recursive; + friend bool operator==(const OpcodeLocation&, const OpcodeLocation&); + std::vector bincodeSerialize() const; + static OpcodeLocation bincodeDeserialize(std::vector); + }; - friend bool operator==(const Circuit &, const Circuit &); - std::vector bincodeSerialize() const; - static Circuit bincodeDeserialize(std::vector); -}; + struct PublicInputs { + std::vector value; -struct BrilligBytecode { - std::vector bytecode; + friend bool operator==(const PublicInputs&, const PublicInputs&); + std::vector bincodeSerialize() const; + static PublicInputs bincodeDeserialize(std::vector); + }; - friend bool operator==(const BrilligBytecode &, const BrilligBytecode &); - std::vector bincodeSerialize() const; - static BrilligBytecode bincodeDeserialize(std::vector); -}; + struct Circuit { + uint32_t current_witness_index; + std::vector opcodes; + Program::ExpressionWidth expression_width; + std::vector private_parameters; + Program::PublicInputs public_parameters; + Program::PublicInputs return_values; + std::vector> assert_messages; + bool recursive; -struct Program { - std::vector functions; - std::vector unconstrained_functions; + friend bool operator==(const Circuit&, const Circuit&); + std::vector bincodeSerialize() const; + static Circuit bincodeDeserialize(std::vector); + }; - friend bool operator==(const Program &, const Program &); - std::vector bincodeSerialize() const; - static Program bincodeDeserialize(std::vector); -}; + struct BrilligBytecode { + std::vector bytecode; + + friend bool operator==(const BrilligBytecode&, const BrilligBytecode&); + std::vector bincodeSerialize() const; + static BrilligBytecode bincodeDeserialize(std::vector); + }; + + struct Program { + std::vector functions; + std::vector unconstrained_functions; + + friend bool operator==(const Program&, const Program&); + std::vector bincodeSerialize() const; + static Program bincodeDeserialize(std::vector); + }; } // end of namespace Program + namespace Program { -inline bool operator==(const AssertionPayload &lhs, - const AssertionPayload &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const AssertionPayload &lhs, const AssertionPayload &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector AssertionPayload::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector AssertionPayload::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline AssertionPayload -AssertionPayload::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline AssertionPayload AssertionPayload::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::AssertionPayload &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::AssertionPayload &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::AssertionPayload -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::AssertionPayload obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::AssertionPayload serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::AssertionPayload obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const AssertionPayload::StaticString &lhs, - const AssertionPayload::StaticString &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const AssertionPayload::StaticString &lhs, const AssertionPayload::StaticString &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -AssertionPayload::StaticString::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector AssertionPayload::StaticString::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline AssertionPayload::StaticString -AssertionPayload::StaticString::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline AssertionPayload::StaticString AssertionPayload::StaticString::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::AssertionPayload::StaticString &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::AssertionPayload::StaticString &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::AssertionPayload::StaticString -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::AssertionPayload::StaticString obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::AssertionPayload::StaticString serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::AssertionPayload::StaticString obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const AssertionPayload::Dynamic &lhs, - const AssertionPayload::Dynamic &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const AssertionPayload::Dynamic &lhs, const AssertionPayload::Dynamic &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -AssertionPayload::Dynamic::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector AssertionPayload::Dynamic::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline AssertionPayload::Dynamic -AssertionPayload::Dynamic::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline AssertionPayload::Dynamic AssertionPayload::Dynamic::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::AssertionPayload::Dynamic &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::AssertionPayload::Dynamic -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::AssertionPayload::Dynamic obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::AssertionPayload::Dynamic serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::AssertionPayload::Dynamic obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BinaryFieldOp &lhs, const BinaryFieldOp &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BinaryFieldOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp -BinaryFieldOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp BinaryFieldOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BinaryFieldOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BinaryFieldOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BinaryFieldOp obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BinaryFieldOp obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Add &lhs, - const BinaryFieldOp::Add &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Add &lhs, const BinaryFieldOp::Add &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Add::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Add::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Add -BinaryFieldOp::Add::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Add BinaryFieldOp::Add::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Add &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Add &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Add -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Add obj; - return obj; +Program::BinaryFieldOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Add obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Sub &lhs, - const BinaryFieldOp::Sub &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Sub &lhs, const BinaryFieldOp::Sub &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Sub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Sub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Sub -BinaryFieldOp::Sub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Sub BinaryFieldOp::Sub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Sub &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Sub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Sub obj; - return obj; +Program::BinaryFieldOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Sub obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Mul &lhs, - const BinaryFieldOp::Mul &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Mul &lhs, const BinaryFieldOp::Mul &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Mul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Mul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Mul -BinaryFieldOp::Mul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Mul BinaryFieldOp::Mul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Mul &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Mul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Mul obj; - return obj; +Program::BinaryFieldOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Mul obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Div &lhs, - const BinaryFieldOp::Div &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Div &lhs, const BinaryFieldOp::Div &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Div::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Div::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Div -BinaryFieldOp::Div::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Div BinaryFieldOp::Div::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Div &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Div &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Div -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Div obj; - return obj; +Program::BinaryFieldOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Div obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, - const BinaryFieldOp::IntegerDiv &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) { + return true; + } -inline std::vector -BinaryFieldOp::IntegerDiv::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::IntegerDiv::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::IntegerDiv -BinaryFieldOp::IntegerDiv::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::IntegerDiv BinaryFieldOp::IntegerDiv::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::IntegerDiv -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::IntegerDiv obj; - return obj; +Program::BinaryFieldOp::IntegerDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::IntegerDiv obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::Equals &lhs, - const BinaryFieldOp::Equals &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) { + return true; + } -inline std::vector BinaryFieldOp::Equals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::Equals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::Equals -BinaryFieldOp::Equals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::Equals BinaryFieldOp::Equals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::Equals &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::Equals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::Equals obj; - return obj; +Program::BinaryFieldOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::Equals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::LessThan &lhs, - const BinaryFieldOp::LessThan &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) { + return true; + } -inline std::vector BinaryFieldOp::LessThan::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::LessThan::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::LessThan -BinaryFieldOp::LessThan::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::LessThan BinaryFieldOp::LessThan::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryFieldOp::LessThan &obj, Serializer &serializer) { +} template <> template -Program::BinaryFieldOp::LessThan -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::LessThan obj; - return obj; +Program::BinaryFieldOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::LessThan obj; + return obj; } namespace Program { -inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, - const BinaryFieldOp::LessThanEquals &rhs) { - return true; -} + inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) { + return true; + } -inline std::vector -BinaryFieldOp::LessThanEquals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryFieldOp::LessThanEquals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryFieldOp::LessThanEquals -BinaryFieldOp::LessThanEquals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryFieldOp::LessThanEquals BinaryFieldOp::LessThanEquals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) { +void serde::Serializable::serialize(const Program::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) { } template <> template -Program::BinaryFieldOp::LessThanEquals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryFieldOp::LessThanEquals obj; - return obj; +Program::BinaryFieldOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryFieldOp::LessThanEquals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BinaryIntOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp BinaryIntOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp BinaryIntOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BinaryIntOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BinaryIntOp serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BinaryIntOp obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BinaryIntOp obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Add &lhs, - const BinaryIntOp::Add &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Add &lhs, const BinaryIntOp::Add &rhs) { + return true; + } -inline std::vector BinaryIntOp::Add::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Add::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Add -BinaryIntOp::Add::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Add BinaryIntOp::Add::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Add &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Add &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Add -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Add obj; - return obj; +Program::BinaryIntOp::Add serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Add obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Sub &lhs, - const BinaryIntOp::Sub &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Sub &lhs, const BinaryIntOp::Sub &rhs) { + return true; + } -inline std::vector BinaryIntOp::Sub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Sub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Sub -BinaryIntOp::Sub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Sub BinaryIntOp::Sub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Sub &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Sub &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Sub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Sub obj; - return obj; +Program::BinaryIntOp::Sub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Sub obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Mul &lhs, - const BinaryIntOp::Mul &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Mul &lhs, const BinaryIntOp::Mul &rhs) { + return true; + } -inline std::vector BinaryIntOp::Mul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Mul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Mul -BinaryIntOp::Mul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Mul BinaryIntOp::Mul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Mul &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Mul &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Mul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Mul obj; - return obj; +Program::BinaryIntOp::Mul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Mul obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Div &lhs, - const BinaryIntOp::Div &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Div &lhs, const BinaryIntOp::Div &rhs) { + return true; + } -inline std::vector BinaryIntOp::Div::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Div::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Div -BinaryIntOp::Div::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Div BinaryIntOp::Div::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Div &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Div &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Div -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Div obj; - return obj; +Program::BinaryIntOp::Div serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Div obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Equals &lhs, - const BinaryIntOp::Equals &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Equals &lhs, const BinaryIntOp::Equals &rhs) { + return true; + } -inline std::vector BinaryIntOp::Equals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Equals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Equals -BinaryIntOp::Equals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Equals BinaryIntOp::Equals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Equals &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Equals &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Equals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Equals obj; - return obj; +Program::BinaryIntOp::Equals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Equals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::LessThan &lhs, - const BinaryIntOp::LessThan &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::LessThan &lhs, const BinaryIntOp::LessThan &rhs) { + return true; + } -inline std::vector BinaryIntOp::LessThan::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::LessThan::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::LessThan -BinaryIntOp::LessThan::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::LessThan BinaryIntOp::LessThan::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::LessThan &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::LessThan -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::LessThan obj; - return obj; +Program::BinaryIntOp::LessThan serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::LessThan obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, - const BinaryIntOp::LessThanEquals &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::LessThanEquals &lhs, const BinaryIntOp::LessThanEquals &rhs) { + return true; + } -inline std::vector -BinaryIntOp::LessThanEquals::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::LessThanEquals::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::LessThanEquals -BinaryIntOp::LessThanEquals::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::LessThanEquals BinaryIntOp::LessThanEquals::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::LessThanEquals &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::LessThanEquals -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::LessThanEquals obj; - return obj; +Program::BinaryIntOp::LessThanEquals serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::LessThanEquals obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::And &lhs, - const BinaryIntOp::And &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::And &lhs, const BinaryIntOp::And &rhs) { + return true; + } -inline std::vector BinaryIntOp::And::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::And::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::And -BinaryIntOp::And::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::And BinaryIntOp::And::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::And &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::And &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::And -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::And obj; - return obj; +Program::BinaryIntOp::And serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::And obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Or &lhs, const BinaryIntOp::Or &rhs) { + return true; + } -inline std::vector BinaryIntOp::Or::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Or::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Or -BinaryIntOp::Or::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Or BinaryIntOp::Or::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Or &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Or &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Or -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Or obj; - return obj; +Program::BinaryIntOp::Or serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Or obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Xor &lhs, - const BinaryIntOp::Xor &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Xor &lhs, const BinaryIntOp::Xor &rhs) { + return true; + } -inline std::vector BinaryIntOp::Xor::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Xor::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Xor -BinaryIntOp::Xor::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Xor BinaryIntOp::Xor::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Xor &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Xor &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Xor -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Xor obj; - return obj; +Program::BinaryIntOp::Xor serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Xor obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Shl &lhs, - const BinaryIntOp::Shl &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Shl &lhs, const BinaryIntOp::Shl &rhs) { + return true; + } -inline std::vector BinaryIntOp::Shl::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Shl::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Shl -BinaryIntOp::Shl::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Shl BinaryIntOp::Shl::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Shl &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Shl &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Shl -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Shl obj; - return obj; +Program::BinaryIntOp::Shl serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Shl obj; + return obj; } namespace Program { -inline bool operator==(const BinaryIntOp::Shr &lhs, - const BinaryIntOp::Shr &rhs) { - return true; -} + inline bool operator==(const BinaryIntOp::Shr &lhs, const BinaryIntOp::Shr &rhs) { + return true; + } -inline std::vector BinaryIntOp::Shr::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BinaryIntOp::Shr::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BinaryIntOp::Shr -BinaryIntOp::Shr::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BinaryIntOp::Shr BinaryIntOp::Shr::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BinaryIntOp::Shr &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BinaryIntOp::Shr &obj, Serializer &serializer) { +} template <> template -Program::BinaryIntOp::Shr -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BinaryIntOp::Shr obj; - return obj; +Program::BinaryIntOp::Shr serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BinaryIntOp::Shr obj; + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall &lhs, - const BlackBoxFuncCall &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall &lhs, const BlackBoxFuncCall &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall -BlackBoxFuncCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall BlackBoxFuncCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BlackBoxFuncCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BlackBoxFuncCall obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BlackBoxFuncCall obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, - const BlackBoxFuncCall::AES128Encrypt &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.iv == rhs.iv)) { - return false; - } - if (!(lhs.key == rhs.key)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::AES128Encrypt &lhs, const BlackBoxFuncCall::AES128Encrypt &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.iv == rhs.iv)) { return false; } + if (!(lhs.key == rhs.key)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::AES128Encrypt::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::AES128Encrypt -BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::AES128Encrypt BlackBoxFuncCall::AES128Encrypt::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::AES128Encrypt &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.iv, serializer); - serde::Serializable::serialize(obj.key, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AES128Encrypt &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::AES128Encrypt -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::AES128Encrypt obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.iv = serde::Deserializable::deserialize(deserializer); - obj.key = serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::AND &lhs, - const BlackBoxFuncCall::AND &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::AND &lhs, const BlackBoxFuncCall::AND &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::AND::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::AND::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::AND -BlackBoxFuncCall::AND::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::AND BlackBoxFuncCall::AND::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::AND &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::AND -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::AND obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::AND serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::AND obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::XOR &lhs, - const BlackBoxFuncCall::XOR &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::XOR &lhs, const BlackBoxFuncCall::XOR &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::XOR::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::XOR::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::XOR -BlackBoxFuncCall::XOR::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::XOR BlackBoxFuncCall::XOR::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::XOR &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::XOR -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::XOR obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::XOR serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::XOR obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, - const BlackBoxFuncCall::RANGE &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::RANGE &lhs, const BlackBoxFuncCall::RANGE &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::RANGE::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::RANGE::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::RANGE -BlackBoxFuncCall::RANGE::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::RANGE BlackBoxFuncCall::RANGE::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::RANGE &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); } template <> template -Program::BlackBoxFuncCall::RANGE -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::RANGE obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::RANGE serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::RANGE obj; + obj.input = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::SHA256 &lhs, - const BlackBoxFuncCall::SHA256 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::SHA256 &lhs, const BlackBoxFuncCall::SHA256 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::SHA256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::SHA256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::SHA256 -BlackBoxFuncCall::SHA256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::SHA256 BlackBoxFuncCall::SHA256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::SHA256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::SHA256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::SHA256 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::SHA256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::SHA256 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, - const BlackBoxFuncCall::Blake2s &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Blake2s &lhs, const BlackBoxFuncCall::Blake2s &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Blake2s::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Blake2s::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Blake2s -BlackBoxFuncCall::Blake2s::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Blake2s BlackBoxFuncCall::Blake2s::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Blake2s &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Blake2s -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Blake2s obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Blake2s obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, - const BlackBoxFuncCall::Blake3 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Blake3 &lhs, const BlackBoxFuncCall::Blake3 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxFuncCall::Blake3::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Blake3::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Blake3 -BlackBoxFuncCall::Blake3::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Blake3 BlackBoxFuncCall::Blake3::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Blake3 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Blake3 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Blake3 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Blake3 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, - const BlackBoxFuncCall::SchnorrVerify &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::SchnorrVerify &lhs, const BlackBoxFuncCall::SchnorrVerify &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::SchnorrVerify::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::SchnorrVerify::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::SchnorrVerify -BlackBoxFuncCall::SchnorrVerify::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::SchnorrVerify BlackBoxFuncCall::SchnorrVerify::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::SchnorrVerify &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::SchnorrVerify &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::SchnorrVerify -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::SchnorrVerify obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, - const BlackBoxFuncCall::PedersenCommitment &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; +Program::BlackBoxFuncCall::SchnorrVerify serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::SchnorrVerify obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } -inline std::vector -BlackBoxFuncCall::PedersenCommitment::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} +namespace Program { -inline BlackBoxFuncCall::PedersenCommitment -BlackBoxFuncCall::PedersenCommitment::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline bool operator==(const BlackBoxFuncCall::PedersenCommitment &lhs, const BlackBoxFuncCall::PedersenCommitment &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::PedersenCommitment::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::PedersenCommitment BlackBoxFuncCall::PedersenCommitment::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::PedersenCommitment &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::PedersenCommitment -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::PedersenCommitment obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, - const BlackBoxFuncCall::PedersenHash &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; +Program::BlackBoxFuncCall::PedersenCommitment serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::PedersenCommitment obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } -inline std::vector -BlackBoxFuncCall::PedersenHash::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} +namespace Program { -inline BlackBoxFuncCall::PedersenHash -BlackBoxFuncCall::PedersenHash::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline bool operator==(const BlackBoxFuncCall::PedersenHash &lhs, const BlackBoxFuncCall::PedersenHash &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::PedersenHash::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::PedersenHash BlackBoxFuncCall::PedersenHash::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::PedersenHash &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::PedersenHash &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::PedersenHash -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::PedersenHash obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::PedersenHash serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::PedersenHash obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, - const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.hashed_message == rhs.hashed_message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxFuncCall::EcdsaSecp256k1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::EcdsaSecp256k1 -BlackBoxFuncCall::EcdsaSecp256k1::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::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 + inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256k1 &lhs, const BlackBoxFuncCall::EcdsaSecp256k1 &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.hashed_message == rhs.hashed_message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::EcdsaSecp256k1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::EcdsaSecp256k1 BlackBoxFuncCall::EcdsaSecp256k1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize( - obj.hashed_message, serializer); - serde::Serializable::serialize(obj.output, serializer); -} - -template <> -template -Program::BlackBoxFuncCall::EcdsaSecp256k1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::EcdsaSecp256k1 obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.hashed_message = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256r1 &lhs, - const BlackBoxFuncCall::EcdsaSecp256r1 &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.hashed_message == rhs.hashed_message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxFuncCall::EcdsaSecp256r1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::EcdsaSecp256r1 -BlackBoxFuncCall::EcdsaSecp256r1::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize( - obj.hashed_message, serializer); - serde::Serializable::serialize(obj.output, serializer); -} - -template <> -template -Program::BlackBoxFuncCall::EcdsaSecp256r1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::EcdsaSecp256r1 obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.hashed_message = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::MultiScalarMul &lhs, - const BlackBoxFuncCall::MultiScalarMul &rhs) { - if (!(lhs.points == rhs.points)) { - return false; - } - if (!(lhs.scalars == rhs.scalars)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256k1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.hashed_message, serializer); + serde::Serializable::serialize(obj.output, serializer); } -inline std::vector -BlackBoxFuncCall::MultiScalarMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxFuncCall::MultiScalarMul -BlackBoxFuncCall::MultiScalarMul::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +template <> +template +Program::BlackBoxFuncCall::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::EcdsaSecp256k1 obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.hashed_message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const BlackBoxFuncCall::EcdsaSecp256r1 &lhs, const BlackBoxFuncCall::EcdsaSecp256r1 &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.hashed_message == rhs.hashed_message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::EcdsaSecp256r1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::EcdsaSecp256r1 BlackBoxFuncCall::EcdsaSecp256r1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::MultiScalarMul &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.points, serializer); - serde::Serializable::serialize(obj.scalars, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); + +template <> +template +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EcdsaSecp256r1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.hashed_message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::MultiScalarMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::MultiScalarMul obj; - obj.points = - serde::Deserializable::deserialize(deserializer); - obj.scalars = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, - const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) { - if (!(lhs.input1_x == rhs.input1_x)) { - return false; - } - if (!(lhs.input1_y == rhs.input1_y)) { - return false; - } - if (!(lhs.input2_x == rhs.input2_x)) { - return false; - } - if (!(lhs.input2_y == rhs.input2_y)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; +Program::BlackBoxFuncCall::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::EcdsaSecp256r1 obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.hashed_message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } -inline std::vector -BlackBoxFuncCall::EmbeddedCurveAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} +namespace Program { -inline BlackBoxFuncCall::EmbeddedCurveAdd -BlackBoxFuncCall::EmbeddedCurveAdd::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline bool operator==(const BlackBoxFuncCall::MultiScalarMul &lhs, const BlackBoxFuncCall::MultiScalarMul &rhs) { + if (!(lhs.points == rhs.points)) { return false; } + if (!(lhs.scalars == rhs.scalars)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } + + inline std::vector BlackBoxFuncCall::MultiScalarMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxFuncCall::MultiScalarMul BlackBoxFuncCall::MultiScalarMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.input1_x, - serializer); - serde::Serializable::serialize(obj.input1_y, - serializer); - serde::Serializable::serialize(obj.input2_x, - serializer); - serde::Serializable::serialize(obj.input2_y, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::MultiScalarMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.points, serializer); + serde::Serializable::serialize(obj.scalars, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::EmbeddedCurveAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::EmbeddedCurveAdd obj; - obj.input1_x = - serde::Deserializable::deserialize(deserializer); - obj.input1_y = - serde::Deserializable::deserialize(deserializer); - obj.input2_x = - serde::Deserializable::deserialize(deserializer); - obj.input2_y = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::MultiScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::MultiScalarMul obj; + obj.points = serde::Deserializable::deserialize(deserializer); + obj.scalars = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, - const BlackBoxFuncCall::Keccak256 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.var_message_size == rhs.var_message_size)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::EmbeddedCurveAdd &lhs, const BlackBoxFuncCall::EmbeddedCurveAdd &rhs) { + if (!(lhs.input1_x == rhs.input1_x)) { return false; } + if (!(lhs.input1_y == rhs.input1_y)) { return false; } + if (!(lhs.input2_x == rhs.input2_x)) { return false; } + if (!(lhs.input2_y == rhs.input2_y)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Keccak256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::EmbeddedCurveAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Keccak256 -BlackBoxFuncCall::Keccak256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::EmbeddedCurveAdd BlackBoxFuncCall::EmbeddedCurveAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.var_message_size, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::EmbeddedCurveAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input1_x, serializer); + serde::Serializable::serialize(obj.input1_y, serializer); + serde::Serializable::serialize(obj.input2_x, serializer); + serde::Serializable::serialize(obj.input2_y, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Keccak256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Keccak256 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.var_message_size = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::EmbeddedCurveAdd obj; + obj.input1_x = serde::Deserializable::deserialize(deserializer); + obj.input1_y = serde::Deserializable::deserialize(deserializer); + obj.input2_x = serde::Deserializable::deserialize(deserializer); + obj.input2_y = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, - const BlackBoxFuncCall::Keccakf1600 &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Keccak256 &lhs, const BlackBoxFuncCall::Keccak256 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.var_message_size == rhs.var_message_size)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Keccakf1600::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Keccak256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Keccakf1600 -BlackBoxFuncCall::Keccakf1600::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Keccak256 BlackBoxFuncCall::Keccak256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Keccak256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.var_message_size, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Keccakf1600 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::Keccakf1600 obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Keccak256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Keccak256 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.var_message_size = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, - const BlackBoxFuncCall::RecursiveAggregation &rhs) { - if (!(lhs.verification_key == rhs.verification_key)) { - return false; - } - if (!(lhs.proof == rhs.proof)) { - return false; - } - if (!(lhs.public_inputs == rhs.public_inputs)) { - return false; - } - if (!(lhs.key_hash == rhs.key_hash)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Keccakf1600 &lhs, const BlackBoxFuncCall::Keccakf1600 &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::RecursiveAggregation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Keccakf1600::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::RecursiveAggregation -BlackBoxFuncCall::RecursiveAggregation::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable< - BlackBoxFuncCall::RecursiveAggregation>::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Keccakf1600 BlackBoxFuncCall::Keccakf1600::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, - Serializer &serializer) { - serde::Serializable::serialize( - obj.verification_key, serializer); - serde::Serializable::serialize(obj.proof, serializer); - serde::Serializable::serialize(obj.public_inputs, - serializer); - serde::Serializable::serialize(obj.key_hash, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Keccakf1600 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::RecursiveAggregation -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::RecursiveAggregation obj; - obj.verification_key = - serde::Deserializable::deserialize( - deserializer); - obj.proof = - serde::Deserializable::deserialize(deserializer); - obj.public_inputs = - serde::Deserializable::deserialize( - deserializer); - obj.key_hash = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Keccakf1600 obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, - const BlackBoxFuncCall::BigIntAdd &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::RecursiveAggregation &lhs, const BlackBoxFuncCall::RecursiveAggregation &rhs) { + if (!(lhs.verification_key == rhs.verification_key)) { return false; } + if (!(lhs.proof == rhs.proof)) { return false; } + if (!(lhs.public_inputs == rhs.public_inputs)) { return false; } + if (!(lhs.key_hash == rhs.key_hash)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::RecursiveAggregation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntAdd -BlackBoxFuncCall::BigIntAdd::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::RecursiveAggregation BlackBoxFuncCall::RecursiveAggregation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::RecursiveAggregation &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.verification_key, serializer); + serde::Serializable::serialize(obj.proof, serializer); + serde::Serializable::serialize(obj.public_inputs, serializer); + serde::Serializable::serialize(obj.key_hash, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntAdd obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::RecursiveAggregation obj; + obj.verification_key = serde::Deserializable::deserialize(deserializer); + obj.proof = serde::Deserializable::deserialize(deserializer); + obj.public_inputs = serde::Deserializable::deserialize(deserializer); + obj.key_hash = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, - const BlackBoxFuncCall::BigIntSub &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntAdd &lhs, const BlackBoxFuncCall::BigIntAdd &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntSub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntSub -BlackBoxFuncCall::BigIntSub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntAdd BlackBoxFuncCall::BigIntAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntSub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntSub obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntAdd obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, - const BlackBoxFuncCall::BigIntMul &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntSub &lhs, const BlackBoxFuncCall::BigIntSub &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntSub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntMul -BlackBoxFuncCall::BigIntMul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntSub BlackBoxFuncCall::BigIntSub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntSub &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntMul obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntSub obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, - const BlackBoxFuncCall::BigIntDiv &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntMul &lhs, const BlackBoxFuncCall::BigIntMul &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntDiv::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntDiv -BlackBoxFuncCall::BigIntDiv::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntMul BlackBoxFuncCall::BigIntMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntDiv -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntDiv obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntMul obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, - const BlackBoxFuncCall::BigIntFromLeBytes &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.modulus == rhs.modulus)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntDiv &lhs, const BlackBoxFuncCall::BigIntDiv &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntFromLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntDiv::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntFromLeBytes -BlackBoxFuncCall::BigIntFromLeBytes::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntDiv BlackBoxFuncCall::BigIntDiv::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.modulus, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntDiv &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntFromLeBytes -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntFromLeBytes obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.modulus = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntDiv obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, - const BlackBoxFuncCall::BigIntToLeBytes &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntFromLeBytes &lhs, const BlackBoxFuncCall::BigIntFromLeBytes &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.modulus == rhs.modulus)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::BigIntToLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntFromLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::BigIntToLeBytes -BlackBoxFuncCall::BigIntToLeBytes::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntFromLeBytes BlackBoxFuncCall::BigIntFromLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntFromLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.modulus, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxFuncCall::BigIntToLeBytes -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxFuncCall::BigIntToLeBytes obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntFromLeBytes obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.modulus = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, - const BlackBoxFuncCall::Poseidon2Permutation &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - if (!(lhs.len == rhs.len)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::BigIntToLeBytes &lhs, const BlackBoxFuncCall::BigIntToLeBytes &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Poseidon2Permutation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::BigIntToLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Poseidon2Permutation -BlackBoxFuncCall::Poseidon2Permutation::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable< - BlackBoxFuncCall::Poseidon2Permutation>::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::BigIntToLeBytes BlackBoxFuncCall::BigIntToLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); - serde::Serializable::serialize(obj.len, serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::BigIntToLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxFuncCall::Poseidon2Permutation -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Poseidon2Permutation obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - obj.len = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::BigIntToLeBytes obj; + obj.input = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, - const BlackBoxFuncCall::Sha256Compression &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.hash_values == rhs.hash_values)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Poseidon2Permutation &lhs, const BlackBoxFuncCall::Poseidon2Permutation &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + if (!(lhs.len == rhs.len)) { return false; } + return true; + } -inline std::vector -BlackBoxFuncCall::Sha256Compression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize( - *this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Poseidon2Permutation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxFuncCall::Sha256Compression -BlackBoxFuncCall::Sha256Compression::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Poseidon2Permutation BlackBoxFuncCall::Poseidon2Permutation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable:: - serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.hash_values, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Poseidon2Permutation &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); + serde::Serializable::serialize(obj.len, serializer); } template <> template -Program::BlackBoxFuncCall::Sha256Compression -serde::Deserializable:: - deserialize(Deserializer &deserializer) { - Program::BlackBoxFuncCall::Sha256Compression obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.hash_values = - serde::Deserializable::deserialize( - deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxFuncCall::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Poseidon2Permutation obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + obj.len = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxFuncCall::Sha256Compression &lhs, const BlackBoxFuncCall::Sha256Compression &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.hash_values == rhs.hash_values)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxFuncCall::Sha256Compression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp BlackBoxOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxFuncCall::Sha256Compression BlackBoxFuncCall::Sha256Compression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxFuncCall::Sha256Compression &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.hash_values, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxOp serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BlackBoxOp obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxFuncCall::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxFuncCall::Sha256Compression obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.hash_values = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, - const BlackBoxOp::AES128Encrypt &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.iv == rhs.iv)) { - return false; - } - if (!(lhs.key == rhs.key)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp &lhs, const BlackBoxOp &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::AES128Encrypt::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::AES128Encrypt -BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp BlackBoxOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.iv, serializer); - serde::Serializable::serialize(obj.key, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BlackBoxOp::AES128Encrypt -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::AES128Encrypt obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.iv = serde::Deserializable::deserialize(deserializer); - obj.key = serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BlackBoxOp obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Sha256 &lhs, - const BlackBoxOp::Sha256 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::AES128Encrypt &lhs, const BlackBoxOp::AES128Encrypt &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.iv == rhs.iv)) { return false; } + if (!(lhs.key == rhs.key)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Sha256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::AES128Encrypt::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Sha256 -BlackBoxOp::Sha256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::AES128Encrypt BlackBoxOp::AES128Encrypt::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Sha256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::AES128Encrypt &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.iv, serializer); + serde::Serializable::serialize(obj.key, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxOp::Sha256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Sha256 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::AES128Encrypt serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::AES128Encrypt obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.iv = serde::Deserializable::deserialize(deserializer); + obj.key = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Blake2s &lhs, - const BlackBoxOp::Blake2s &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Sha256 &lhs, const BlackBoxOp::Sha256 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Blake2s::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Sha256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Blake2s -BlackBoxOp::Blake2s::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Sha256 BlackBoxOp::Sha256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Sha256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Blake2s -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Blake2s obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Sha256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Sha256 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Blake3 &lhs, - const BlackBoxOp::Blake3 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Blake2s &lhs, const BlackBoxOp::Blake2s &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Blake3::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Blake2s::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Blake3 -BlackBoxOp::Blake3::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Blake2s BlackBoxOp::Blake2s::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Blake2s &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Blake3 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Blake3 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Blake2s serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Blake2s obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Keccak256 &lhs, - const BlackBoxOp::Keccak256 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Blake3 &lhs, const BlackBoxOp::Blake3 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Keccak256::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Blake3::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Keccak256 -BlackBoxOp::Keccak256::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Blake3 BlackBoxOp::Blake3::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Blake3 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Keccak256 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Keccak256 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Blake3 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Blake3 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, - const BlackBoxOp::Keccakf1600 &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Keccak256 &lhs, const BlackBoxOp::Keccak256 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::Keccakf1600::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Keccak256::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Keccakf1600 -BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Keccak256 BlackBoxOp::Keccak256::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Keccak256 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Keccakf1600 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Keccakf1600 obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Keccak256 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Keccak256 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, - const BlackBoxOp::EcdsaSecp256k1 &rhs) { - if (!(lhs.hashed_msg == rhs.hashed_msg)) { - return false; - } - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Keccakf1600 &lhs, const BlackBoxOp::Keccakf1600 &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Keccakf1600::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::EcdsaSecp256k1 -BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Keccakf1600 BlackBoxOp::Keccakf1600::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.hashed_msg, - serializer); - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Keccakf1600 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::EcdsaSecp256k1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::EcdsaSecp256k1 obj; - obj.hashed_msg = serde::Deserializable::deserialize( - deserializer); - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, - const BlackBoxOp::EcdsaSecp256r1 &rhs) { - if (!(lhs.hashed_msg == rhs.hashed_msg)) { - return false; - } - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} - -inline BlackBoxOp::EcdsaSecp256r1 -BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +Program::BlackBoxOp::Keccakf1600 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Keccakf1600 obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const BlackBoxOp::EcdsaSecp256k1 &lhs, const BlackBoxOp::EcdsaSecp256k1 &rhs) { + if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; } + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } + + inline std::vector BlackBoxOp::EcdsaSecp256k1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::EcdsaSecp256k1 BlackBoxOp::EcdsaSecp256k1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.hashed_msg, - serializer); - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.result, serializer); -} - +template +void serde::Serializable::serialize(const Program::BlackBoxOp::EcdsaSecp256k1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.hashed_msg, serializer); + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.result, serializer); +} + template <> template -Program::BlackBoxOp::EcdsaSecp256r1 -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::EcdsaSecp256r1 obj; - obj.hashed_msg = serde::Deserializable::deserialize( - deserializer); - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; -} - -namespace Program { - -inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, - const BlackBoxOp::SchnorrVerify &rhs) { - if (!(lhs.public_key_x == rhs.public_key_x)) { - return false; - } - if (!(lhs.public_key_y == rhs.public_key_y)) { - return false; - } - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.signature == rhs.signature)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} - -inline std::vector -BlackBoxOp::SchnorrVerify::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); +Program::BlackBoxOp::EcdsaSecp256k1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::EcdsaSecp256k1 obj; + obj.hashed_msg = serde::Deserializable::deserialize(deserializer); + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } -inline BlackBoxOp::SchnorrVerify -BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} +namespace Program { + + inline bool operator==(const BlackBoxOp::EcdsaSecp256r1 &lhs, const BlackBoxOp::EcdsaSecp256r1 &rhs) { + if (!(lhs.hashed_msg == rhs.hashed_msg)) { return false; } + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } + + inline std::vector BlackBoxOp::EcdsaSecp256r1::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline BlackBoxOp::EcdsaSecp256r1 BlackBoxOp::EcdsaSecp256r1::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.public_key_x, - serializer); - serde::Serializable::serialize(obj.public_key_y, - serializer); - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.signature, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::EcdsaSecp256r1 &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.hashed_msg, serializer); + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::SchnorrVerify -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::SchnorrVerify obj; - obj.public_key_x = - serde::Deserializable::deserialize( - deserializer); - obj.public_key_y = - serde::Deserializable::deserialize( - deserializer); - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.signature = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::EcdsaSecp256r1 serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::EcdsaSecp256r1 obj; + obj.hashed_msg = serde::Deserializable::deserialize(deserializer); + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, - const BlackBoxOp::PedersenCommitment &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::SchnorrVerify &lhs, const BlackBoxOp::SchnorrVerify &rhs) { + if (!(lhs.public_key_x == rhs.public_key_x)) { return false; } + if (!(lhs.public_key_y == rhs.public_key_y)) { return false; } + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.signature == rhs.signature)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::PedersenCommitment::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::SchnorrVerify::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::PedersenCommitment -BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::SchnorrVerify BlackBoxOp::SchnorrVerify::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::PedersenCommitment &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::SchnorrVerify &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.public_key_x, serializer); + serde::Serializable::serialize(obj.public_key_y, serializer); + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.signature, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::PedersenCommitment -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::PedersenCommitment obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::SchnorrVerify serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::SchnorrVerify obj; + obj.public_key_x = serde::Deserializable::deserialize(deserializer); + obj.public_key_y = serde::Deserializable::deserialize(deserializer); + obj.message = serde::Deserializable::deserialize(deserializer); + obj.signature = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::PedersenHash &lhs, - const BlackBoxOp::PedersenHash &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.domain_separator == rhs.domain_separator)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::PedersenCommitment &lhs, const BlackBoxOp::PedersenCommitment &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::PedersenHash::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::PedersenCommitment::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::PedersenHash -BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::PedersenCommitment BlackBoxOp::PedersenCommitment::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.domain_separator, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::PedersenCommitment &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::PedersenHash -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::PedersenHash obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.domain_separator = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::PedersenCommitment serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::PedersenCommitment obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::MultiScalarMul &lhs, - const BlackBoxOp::MultiScalarMul &rhs) { - if (!(lhs.points == rhs.points)) { - return false; - } - if (!(lhs.scalars == rhs.scalars)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::PedersenHash &lhs, const BlackBoxOp::PedersenHash &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.domain_separator == rhs.domain_separator)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::MultiScalarMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::PedersenHash::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::MultiScalarMul -BlackBoxOp::MultiScalarMul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::PedersenHash BlackBoxOp::PedersenHash::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::MultiScalarMul &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.points, serializer); - serde::Serializable::serialize(obj.scalars, - serializer); - serde::Serializable::serialize(obj.outputs, - serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::PedersenHash &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.domain_separator, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::MultiScalarMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::MultiScalarMul obj; - obj.points = - serde::Deserializable::deserialize(deserializer); - obj.scalars = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::PedersenHash serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::PedersenHash obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.domain_separator = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, - const BlackBoxOp::EmbeddedCurveAdd &rhs) { - if (!(lhs.input1_x == rhs.input1_x)) { - return false; - } - if (!(lhs.input1_y == rhs.input1_y)) { - return false; - } - if (!(lhs.input2_x == rhs.input2_x)) { - return false; - } - if (!(lhs.input2_y == rhs.input2_y)) { - return false; - } - if (!(lhs.result == rhs.result)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::MultiScalarMul &lhs, const BlackBoxOp::MultiScalarMul &rhs) { + if (!(lhs.points == rhs.points)) { return false; } + if (!(lhs.scalars == rhs.scalars)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::EmbeddedCurveAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::MultiScalarMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::EmbeddedCurveAdd -BlackBoxOp::EmbeddedCurveAdd::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::MultiScalarMul BlackBoxOp::MultiScalarMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input1_x, - serializer); - serde::Serializable::serialize(obj.input1_y, - serializer); - serde::Serializable::serialize(obj.input2_x, - serializer); - serde::Serializable::serialize(obj.input2_y, - serializer); - serde::Serializable::serialize(obj.result, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::MultiScalarMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.points, serializer); + serde::Serializable::serialize(obj.scalars, serializer); + serde::Serializable::serialize(obj.outputs, serializer); } template <> template -Program::BlackBoxOp::EmbeddedCurveAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::EmbeddedCurveAdd obj; - obj.input1_x = - serde::Deserializable::deserialize(deserializer); - obj.input1_y = - serde::Deserializable::deserialize(deserializer); - obj.input2_x = - serde::Deserializable::deserialize(deserializer); - obj.input2_y = - serde::Deserializable::deserialize(deserializer); - obj.result = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::MultiScalarMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::MultiScalarMul obj; + obj.points = serde::Deserializable::deserialize(deserializer); + obj.scalars = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, - const BlackBoxOp::BigIntAdd &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::EmbeddedCurveAdd &lhs, const BlackBoxOp::EmbeddedCurveAdd &rhs) { + if (!(lhs.input1_x == rhs.input1_x)) { return false; } + if (!(lhs.input1_y == rhs.input1_y)) { return false; } + if (!(lhs.input2_x == rhs.input2_x)) { return false; } + if (!(lhs.input2_y == rhs.input2_y)) { return false; } + if (!(lhs.result == rhs.result)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntAdd::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::EmbeddedCurveAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntAdd -BlackBoxOp::BigIntAdd::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::EmbeddedCurveAdd BlackBoxOp::EmbeddedCurveAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::EmbeddedCurveAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input1_x, serializer); + serde::Serializable::serialize(obj.input1_y, serializer); + serde::Serializable::serialize(obj.input2_x, serializer); + serde::Serializable::serialize(obj.input2_y, serializer); + serde::Serializable::serialize(obj.result, serializer); } template <> template -Program::BlackBoxOp::BigIntAdd -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntAdd obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::EmbeddedCurveAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::EmbeddedCurveAdd obj; + obj.input1_x = serde::Deserializable::deserialize(deserializer); + obj.input1_y = serde::Deserializable::deserialize(deserializer); + obj.input2_x = serde::Deserializable::deserialize(deserializer); + obj.input2_y = serde::Deserializable::deserialize(deserializer); + obj.result = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntSub &lhs, - const BlackBoxOp::BigIntSub &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntAdd &lhs, const BlackBoxOp::BigIntAdd &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntSub::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntAdd::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntSub -BlackBoxOp::BigIntSub::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntAdd BlackBoxOp::BigIntAdd::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntAdd &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntSub -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntSub obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntAdd serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntAdd obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntMul &lhs, - const BlackBoxOp::BigIntMul &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntSub &lhs, const BlackBoxOp::BigIntSub &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntMul::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntSub::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntMul -BlackBoxOp::BigIntMul::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntSub BlackBoxOp::BigIntSub::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntSub &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntMul -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntMul obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntSub serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntSub obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, - const BlackBoxOp::BigIntDiv &rhs) { - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntMul &lhs, const BlackBoxOp::BigIntMul &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlackBoxOp::BigIntDiv::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntMul::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntDiv -BlackBoxOp::BigIntDiv::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntMul BlackBoxOp::BigIntMul::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntMul &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntDiv -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntDiv obj; - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntMul serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntMul obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, - const BlackBoxOp::BigIntFromLeBytes &rhs) { - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.modulus == rhs.modulus)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntDiv &lhs, const BlackBoxOp::BigIntDiv &rhs) { + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::BigIntFromLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntDiv::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntFromLeBytes -BlackBoxOp::BigIntFromLeBytes::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntDiv BlackBoxOp::BigIntDiv::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.modulus, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntDiv &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntFromLeBytes -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntFromLeBytes obj; - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.modulus = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntDiv serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntDiv obj; + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, - const BlackBoxOp::BigIntToLeBytes &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntFromLeBytes &lhs, const BlackBoxOp::BigIntFromLeBytes &rhs) { + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.modulus == rhs.modulus)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::BigIntToLeBytes::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntFromLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::BigIntToLeBytes -BlackBoxOp::BigIntToLeBytes::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntFromLeBytes BlackBoxOp::BigIntFromLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntFromLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.modulus, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::BigIntToLeBytes -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::BigIntToLeBytes obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntFromLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntFromLeBytes obj; + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.modulus = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, - const BlackBoxOp::Poseidon2Permutation &rhs) { - if (!(lhs.message == rhs.message)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - if (!(lhs.len == rhs.len)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::BigIntToLeBytes &lhs, const BlackBoxOp::BigIntToLeBytes &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::Poseidon2Permutation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::BigIntToLeBytes::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Poseidon2Permutation -BlackBoxOp::Poseidon2Permutation::bincodeDeserialize( - std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::BigIntToLeBytes BlackBoxOp::BigIntToLeBytes::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Poseidon2Permutation &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.message, - serializer); - serde::Serializable::serialize(obj.output, serializer); - serde::Serializable::serialize(obj.len, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::BigIntToLeBytes &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlackBoxOp::Poseidon2Permutation -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Poseidon2Permutation obj; - obj.message = - serde::Deserializable::deserialize(deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - obj.len = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::BigIntToLeBytes serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::BigIntToLeBytes obj; + obj.input = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, - const BlackBoxOp::Sha256Compression &rhs) { - if (!(lhs.input == rhs.input)) { - return false; - } - if (!(lhs.hash_values == rhs.hash_values)) { - return false; - } - if (!(lhs.output == rhs.output)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Poseidon2Permutation &lhs, const BlackBoxOp::Poseidon2Permutation &rhs) { + if (!(lhs.message == rhs.message)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + if (!(lhs.len == rhs.len)) { return false; } + return true; + } -inline std::vector -BlackBoxOp::Sha256Compression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Poseidon2Permutation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlackBoxOp::Sha256Compression -BlackBoxOp::Sha256Compression::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Poseidon2Permutation BlackBoxOp::Poseidon2Permutation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.input, serializer); - serde::Serializable::serialize(obj.hash_values, - serializer); - serde::Serializable::serialize(obj.output, serializer); +void serde::Serializable::serialize(const Program::BlackBoxOp::Poseidon2Permutation &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.message, serializer); + serde::Serializable::serialize(obj.output, serializer); + serde::Serializable::serialize(obj.len, serializer); } template <> template -Program::BlackBoxOp::Sha256Compression -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BlackBoxOp::Sha256Compression obj; - obj.input = - serde::Deserializable::deserialize(deserializer); - obj.hash_values = - serde::Deserializable::deserialize( - deserializer); - obj.output = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BlackBoxOp::Poseidon2Permutation serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Poseidon2Permutation obj; + obj.message = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + obj.len = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BlockId &lhs, const BlockId &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BlackBoxOp::Sha256Compression &lhs, const BlackBoxOp::Sha256Compression &rhs) { + if (!(lhs.input == rhs.input)) { return false; } + if (!(lhs.hash_values == rhs.hash_values)) { return false; } + if (!(lhs.output == rhs.output)) { return false; } + return true; + } -inline std::vector BlockId::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlackBoxOp::Sha256Compression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BlockId BlockId::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlackBoxOp::Sha256Compression BlackBoxOp::Sha256Compression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BlockId &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlackBoxOp::Sha256Compression &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.input, serializer); + serde::Serializable::serialize(obj.hash_values, serializer); + serde::Serializable::serialize(obj.output, serializer); } template <> template -Program::BlockId serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BlockId obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlackBoxOp::Sha256Compression serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BlackBoxOp::Sha256Compression obj; + obj.input = serde::Deserializable::deserialize(deserializer); + obj.hash_values = serde::Deserializable::deserialize(deserializer); + obj.output = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) { - if (!(lhs.bytecode == rhs.bytecode)) { - return false; - } - return true; -} + inline bool operator==(const BlockId &lhs, const BlockId &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligBytecode::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BlockId::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligBytecode -BrilligBytecode::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BlockId BlockId::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligBytecode &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.bytecode, - serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BlockId &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligBytecode -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligBytecode obj; - obj.bytecode = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BlockId serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BlockId obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligBytecode &lhs, const BrilligBytecode &rhs) { + if (!(lhs.bytecode == rhs.bytecode)) { return false; } + return true; + } -inline std::vector BrilligInputs::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligBytecode::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs -BrilligInputs::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligBytecode BrilligBytecode::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligBytecode &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.bytecode, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligInputs -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligInputs obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligBytecode serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligBytecode obj; + obj.bytecode = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs::Single &lhs, - const BrilligInputs::Single &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs &lhs, const BrilligInputs &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligInputs::Single::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs::Single -BrilligInputs::Single::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs BrilligInputs::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs::Single &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligInputs &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligInputs::Single -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligInputs::Single obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligInputs serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligInputs obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs::Array &lhs, - const BrilligInputs::Array &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs::Single &lhs, const BrilligInputs::Single &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligInputs::Array::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::Single::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs::Array -BrilligInputs::Array::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs::Single BrilligInputs::Single::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs::Array &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligInputs::Single &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligInputs::Array -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligInputs::Array obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligInputs::Single serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligInputs::Single obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligInputs::MemoryArray &lhs, - const BrilligInputs::MemoryArray &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs::Array &lhs, const BrilligInputs::Array &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BrilligInputs::MemoryArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::Array::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligInputs::MemoryArray -BrilligInputs::MemoryArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs::Array BrilligInputs::Array::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligInputs::Array &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligInputs::MemoryArray -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligInputs::MemoryArray obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligInputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligInputs::Array obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligInputs::MemoryArray &lhs, const BrilligInputs::MemoryArray &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOpcode::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligInputs::MemoryArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode -BrilligOpcode::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligInputs::MemoryArray BrilligInputs::MemoryArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligInputs::MemoryArray &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligOpcode obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligInputs::MemoryArray serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligInputs::MemoryArray obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, - const BrilligOpcode::BinaryFieldOp &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.op == rhs.op)) { - return false; - } - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode &lhs, const BrilligOpcode &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::BinaryFieldOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::BinaryFieldOp -BrilligOpcode::BinaryFieldOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode BrilligOpcode::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.op, serializer); - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligOpcode::BinaryFieldOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::BinaryFieldOp obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.op = serde::Deserializable::deserialize(deserializer); - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligOpcode obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::BinaryIntOp &lhs, - const BrilligOpcode::BinaryIntOp &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.op == rhs.op)) { - return false; - } - if (!(lhs.bit_size == rhs.bit_size)) { - return false; - } - if (!(lhs.lhs == rhs.lhs)) { - return false; - } - if (!(lhs.rhs == rhs.rhs)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::BinaryFieldOp &lhs, const BrilligOpcode::BinaryFieldOp &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.op == rhs.op)) { return false; } + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::BinaryIntOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::BinaryFieldOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::BinaryIntOp -BrilligOpcode::BinaryIntOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::BinaryFieldOp BrilligOpcode::BinaryFieldOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.op, serializer); - serde::Serializable::serialize(obj.bit_size, - serializer); - serde::Serializable::serialize(obj.lhs, serializer); - serde::Serializable::serialize(obj.rhs, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::BinaryFieldOp &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.op, serializer); + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); } template <> template -Program::BrilligOpcode::BinaryIntOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::BinaryIntOp obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.op = serde::Deserializable::deserialize(deserializer); - obj.bit_size = - serde::Deserializable::deserialize(deserializer); - obj.lhs = serde::Deserializable::deserialize(deserializer); - obj.rhs = serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::BinaryFieldOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::BinaryFieldOp obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.op = serde::Deserializable::deserialize(deserializer); + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Cast &lhs, - const BrilligOpcode::Cast &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.source == rhs.source)) { - return false; - } - if (!(lhs.bit_size == rhs.bit_size)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::BinaryIntOp &lhs, const BrilligOpcode::BinaryIntOp &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.op == rhs.op)) { return false; } + if (!(lhs.bit_size == rhs.bit_size)) { return false; } + if (!(lhs.lhs == rhs.lhs)) { return false; } + if (!(lhs.rhs == rhs.rhs)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Cast::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::BinaryIntOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Cast -BrilligOpcode::Cast::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::BinaryIntOp BrilligOpcode::BinaryIntOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Cast &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.source, serializer); - serde::Serializable::serialize(obj.bit_size, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::BinaryIntOp &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.op, serializer); + serde::Serializable::serialize(obj.bit_size, serializer); + serde::Serializable::serialize(obj.lhs, serializer); + serde::Serializable::serialize(obj.rhs, serializer); } template <> template -Program::BrilligOpcode::Cast -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Cast obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source = - serde::Deserializable::deserialize(deserializer); - obj.bit_size = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::BinaryIntOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::BinaryIntOp obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.op = serde::Deserializable::deserialize(deserializer); + obj.bit_size = serde::Deserializable::deserialize(deserializer); + obj.lhs = serde::Deserializable::deserialize(deserializer); + obj.rhs = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, - const BrilligOpcode::JumpIfNot &rhs) { - if (!(lhs.condition == rhs.condition)) { - return false; - } - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Cast &lhs, const BrilligOpcode::Cast &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.source == rhs.source)) { return false; } + if (!(lhs.bit_size == rhs.bit_size)) { return false; } + return true; + } -inline std::vector BrilligOpcode::JumpIfNot::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Cast::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::JumpIfNot -BrilligOpcode::JumpIfNot::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Cast BrilligOpcode::Cast::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.condition, - serializer); - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Cast &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source, serializer); + serde::Serializable::serialize(obj.bit_size, serializer); } template <> template -Program::BrilligOpcode::JumpIfNot -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::JumpIfNot obj; - obj.condition = - serde::Deserializable::deserialize(deserializer); - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Cast serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Cast obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source = serde::Deserializable::deserialize(deserializer); + obj.bit_size = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::JumpIf &lhs, - const BrilligOpcode::JumpIf &rhs) { - if (!(lhs.condition == rhs.condition)) { - return false; - } - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::JumpIfNot &lhs, const BrilligOpcode::JumpIfNot &rhs) { + if (!(lhs.condition == rhs.condition)) { return false; } + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector BrilligOpcode::JumpIf::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::JumpIfNot::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::JumpIf -BrilligOpcode::JumpIf::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::JumpIfNot BrilligOpcode::JumpIfNot::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.condition, - serializer); - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::JumpIfNot &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.condition, serializer); + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::JumpIf -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::JumpIf obj; - obj.condition = - serde::Deserializable::deserialize(deserializer); - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::JumpIfNot serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::JumpIfNot obj; + obj.condition = serde::Deserializable::deserialize(deserializer); + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Jump &lhs, - const BrilligOpcode::Jump &rhs) { - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::JumpIf &lhs, const BrilligOpcode::JumpIf &rhs) { + if (!(lhs.condition == rhs.condition)) { return false; } + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Jump::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::JumpIf::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Jump -BrilligOpcode::Jump::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::JumpIf BrilligOpcode::JumpIf::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Jump &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::JumpIf &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.condition, serializer); + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::Jump -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Jump obj; - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::JumpIf serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::JumpIf obj; + obj.condition = serde::Deserializable::deserialize(deserializer); + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, - const BrilligOpcode::CalldataCopy &rhs) { - if (!(lhs.destination_address == rhs.destination_address)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - if (!(lhs.offset == rhs.offset)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Jump &lhs, const BrilligOpcode::Jump &rhs) { + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::CalldataCopy::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Jump::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::CalldataCopy -BrilligOpcode::CalldataCopy::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Jump BrilligOpcode::Jump::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) { - serde::Serializable::serialize( - obj.destination_address, serializer); - serde::Serializable::serialize(obj.size, serializer); - serde::Serializable::serialize(obj.offset, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Jump &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::CalldataCopy -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::CalldataCopy obj; - obj.destination_address = - serde::Deserializable::deserialize( - deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - obj.offset = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Jump serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Jump obj; + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Call &lhs, - const BrilligOpcode::Call &rhs) { - if (!(lhs.location == rhs.location)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::CalldataCopy &lhs, const BrilligOpcode::CalldataCopy &rhs) { + if (!(lhs.destination_address == rhs.destination_address)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + if (!(lhs.offset == rhs.offset)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Call::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::CalldataCopy::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Call -BrilligOpcode::Call::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::CalldataCopy BrilligOpcode::CalldataCopy::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Call &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.location, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::CalldataCopy &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination_address, serializer); + serde::Serializable::serialize(obj.size, serializer); + serde::Serializable::serialize(obj.offset, serializer); } template <> template -Program::BrilligOpcode::Call -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Call obj; - obj.location = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::CalldataCopy serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::CalldataCopy obj; + obj.destination_address = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + obj.offset = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Const &lhs, - const BrilligOpcode::Const &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.bit_size == rhs.bit_size)) { - return false; - } - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Call &lhs, const BrilligOpcode::Call &rhs) { + if (!(lhs.location == rhs.location)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Const::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Call::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Const -BrilligOpcode::Const::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Call BrilligOpcode::Call::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Const &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.bit_size, - serializer); - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Call &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.location, serializer); } template <> template -Program::BrilligOpcode::Const -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Const obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.bit_size = - serde::Deserializable::deserialize(deserializer); - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Call obj; + obj.location = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Return &lhs, - const BrilligOpcode::Return &rhs) { - return true; -} + inline bool operator==(const BrilligOpcode::Const &lhs, const BrilligOpcode::Const &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.bit_size == rhs.bit_size)) { return false; } + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Return::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Const::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Return -BrilligOpcode::Return::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Const BrilligOpcode::Const::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Return &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::BrilligOpcode::Const &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.bit_size, serializer); + serde::Serializable::serialize(obj.value, serializer); +} template <> template -Program::BrilligOpcode::Return -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Return obj; - return obj; +Program::BrilligOpcode::Const serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Const obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.bit_size = serde::Deserializable::deserialize(deserializer); + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::ForeignCall &lhs, - const BrilligOpcode::ForeignCall &rhs) { - if (!(lhs.function == rhs.function)) { - return false; - } - if (!(lhs.destinations == rhs.destinations)) { - return false; - } - if (!(lhs.destination_value_types == rhs.destination_value_types)) { - return false; - } - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.input_value_types == rhs.input_value_types)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Return &lhs, const BrilligOpcode::Return &rhs) { + return true; + } -inline std::vector -BrilligOpcode::ForeignCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Return::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::ForeignCall -BrilligOpcode::ForeignCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Return BrilligOpcode::Return::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.function, - serializer); - serde::Serializable::serialize(obj.destinations, - serializer); - serde::Serializable::serialize( - obj.destination_value_types, serializer); - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize( - obj.input_value_types, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Return &obj, Serializer &serializer) { } template <> template -Program::BrilligOpcode::ForeignCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::ForeignCall obj; - obj.function = - serde::Deserializable::deserialize(deserializer); - obj.destinations = - serde::Deserializable::deserialize( - deserializer); - obj.destination_value_types = - serde::Deserializable::deserialize( - deserializer); - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.input_value_types = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::Return serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Return obj; + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Mov &lhs, - const BrilligOpcode::Mov &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.source == rhs.source)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::ForeignCall &lhs, const BrilligOpcode::ForeignCall &rhs) { + if (!(lhs.function == rhs.function)) { return false; } + if (!(lhs.destinations == rhs.destinations)) { return false; } + if (!(lhs.destination_value_types == rhs.destination_value_types)) { return false; } + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.input_value_types == rhs.input_value_types)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Mov::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::ForeignCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Mov -BrilligOpcode::Mov::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::ForeignCall BrilligOpcode::ForeignCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Mov &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.source, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::ForeignCall &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.function, serializer); + serde::Serializable::serialize(obj.destinations, serializer); + serde::Serializable::serialize(obj.destination_value_types, serializer); + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.input_value_types, serializer); } template <> template -Program::BrilligOpcode::Mov -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Mov obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::ForeignCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::ForeignCall obj; + obj.function = serde::Deserializable::deserialize(deserializer); + obj.destinations = serde::Deserializable::deserialize(deserializer); + obj.destination_value_types = serde::Deserializable::deserialize(deserializer); + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.input_value_types = serde::Deserializable::deserialize(deserializer); + return obj; } 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 bool operator==(const BrilligOpcode::Mov &lhs, const BrilligOpcode::Mov &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.source == rhs.source)) { return false; } + return true; + } -inline std::vector -BrilligOpcode::ConditionalMov::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Mov::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::ConditionalMov -BrilligOpcode::ConditionalMov::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Mov BrilligOpcode::Mov::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize(obj.source_a, - serializer); - serde::Serializable::serialize(obj.source_b, - serializer); - serde::Serializable::serialize(obj.condition, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Mov &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source, serializer); } template <> template -Program::BrilligOpcode::ConditionalMov -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::ConditionalMov obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source_a = - serde::Deserializable::deserialize(deserializer); - obj.source_b = - serde::Deserializable::deserialize(deserializer); - obj.condition = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Mov serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Mov obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Load &lhs, - const BrilligOpcode::Load &rhs) { - if (!(lhs.destination == rhs.destination)) { - return false; - } - if (!(lhs.source_pointer == rhs.source_pointer)) { - return false; - } - return true; -} + 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 BrilligOpcode::Load::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::ConditionalMov::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Load -BrilligOpcode::Load::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::ConditionalMov BrilligOpcode::ConditionalMov::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Load &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.destination, - serializer); - serde::Serializable::serialize( - obj.source_pointer, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::ConditionalMov &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source_a, serializer); + serde::Serializable::serialize(obj.source_b, serializer); + serde::Serializable::serialize(obj.condition, serializer); } template <> template -Program::BrilligOpcode::Load -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Load obj; - obj.destination = - serde::Deserializable::deserialize( - deserializer); - obj.source_pointer = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::ConditionalMov serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::ConditionalMov obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source_a = serde::Deserializable::deserialize(deserializer); + obj.source_b = serde::Deserializable::deserialize(deserializer); + obj.condition = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Store &lhs, - const BrilligOpcode::Store &rhs) { - if (!(lhs.destination_pointer == rhs.destination_pointer)) { - return false; - } - if (!(lhs.source == rhs.source)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Load &lhs, const BrilligOpcode::Load &rhs) { + if (!(lhs.destination == rhs.destination)) { return false; } + if (!(lhs.source_pointer == rhs.source_pointer)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Store::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Load::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Store -BrilligOpcode::Store::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Load BrilligOpcode::Load::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Store &obj, Serializer &serializer) { - serde::Serializable::serialize( - obj.destination_pointer, serializer); - serde::Serializable::serialize(obj.source, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Load &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination, serializer); + serde::Serializable::serialize(obj.source_pointer, serializer); } template <> template -Program::BrilligOpcode::Store -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Store obj; - obj.destination_pointer = - serde::Deserializable::deserialize( - deserializer); - obj.source = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Load serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Load obj; + obj.destination = serde::Deserializable::deserialize(deserializer); + obj.source_pointer = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::BlackBox &lhs, - const BrilligOpcode::BlackBox &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Store &lhs, const BrilligOpcode::Store &rhs) { + if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; } + if (!(lhs.source == rhs.source)) { return false; } + return true; + } -inline std::vector BrilligOpcode::BlackBox::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Store::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::BlackBox -BrilligOpcode::BlackBox::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Store BrilligOpcode::Store::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Store &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.destination_pointer, serializer); + serde::Serializable::serialize(obj.source, serializer); } template <> template -Program::BrilligOpcode::BlackBox -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::BlackBox obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOpcode::Store serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Store obj; + obj.destination_pointer = serde::Deserializable::deserialize(deserializer); + obj.source = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Trap &lhs, - const BrilligOpcode::Trap &rhs) { - if (!(lhs.revert_data == rhs.revert_data)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::BlackBox &lhs, const BrilligOpcode::BlackBox &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Trap::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::BlackBox::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Trap -BrilligOpcode::Trap::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::BlackBox BrilligOpcode::BlackBox::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Trap &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.revert_data, - serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::BlackBox &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOpcode::Trap -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Trap obj; - obj.revert_data = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::BlackBox serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::BlackBox obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOpcode::Stop &lhs, - const BrilligOpcode::Stop &rhs) { - if (!(lhs.return_data_offset == rhs.return_data_offset)) { - return false; - } - if (!(lhs.return_data_size == rhs.return_data_size)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Trap &lhs, const BrilligOpcode::Trap &rhs) { + if (!(lhs.revert_data == rhs.revert_data)) { return false; } + return true; + } -inline std::vector BrilligOpcode::Stop::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Trap::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOpcode::Stop -BrilligOpcode::Stop::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Trap BrilligOpcode::Trap::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOpcode::Stop &obj, Serializer &serializer) { - serde::Serializable::serialize( - obj.return_data_offset, serializer); - serde::Serializable::serialize( - obj.return_data_size, serializer); +void serde::Serializable::serialize(const Program::BrilligOpcode::Trap &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.revert_data, serializer); } template <> template -Program::BrilligOpcode::Stop -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOpcode::Stop obj; - obj.return_data_offset = - serde::Deserializable::deserialize( - deserializer); - obj.return_data_size = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::BrilligOpcode::Trap serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Trap obj; + obj.revert_data = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOpcode::Stop &lhs, const BrilligOpcode::Stop &rhs) { + if (!(lhs.return_data_offset == rhs.return_data_offset)) { return false; } + if (!(lhs.return_data_size == rhs.return_data_size)) { return false; } + return true; + } -inline std::vector BrilligOutputs::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOpcode::Stop::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOutputs -BrilligOutputs::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOpcode::Stop BrilligOpcode::Stop::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOutputs &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligOpcode::Stop &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.return_data_offset, serializer); + serde::Serializable::serialize(obj.return_data_size, serializer); } template <> template -Program::BrilligOutputs -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::BrilligOutputs obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligOpcode::Stop serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOpcode::Stop obj; + obj.return_data_offset = serde::Deserializable::deserialize(deserializer); + obj.return_data_size = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const BrilligOutputs::Simple &lhs, - const BrilligOutputs::Simple &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOutputs &lhs, const BrilligOutputs &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOutputs::Simple::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOutputs::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOutputs::Simple -BrilligOutputs::Simple::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOutputs BrilligOutputs::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOutputs::Simple &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOutputs &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::BrilligOutputs::Simple -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOutputs::Simple obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOutputs serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::BrilligOutputs obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const BrilligOutputs::Array &lhs, - const BrilligOutputs::Array &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOutputs::Simple &lhs, const BrilligOutputs::Simple &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector BrilligOutputs::Array::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOutputs::Simple::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline BrilligOutputs::Array -BrilligOutputs::Array::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOutputs::Simple BrilligOutputs::Simple::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::BrilligOutputs::Array &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::BrilligOutputs::Simple &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::BrilligOutputs::Array -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::BrilligOutputs::Array obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::BrilligOutputs::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOutputs::Simple obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Circuit &lhs, const Circuit &rhs) { - if (!(lhs.current_witness_index == rhs.current_witness_index)) { - return false; - } - if (!(lhs.opcodes == rhs.opcodes)) { - return false; - } - if (!(lhs.expression_width == rhs.expression_width)) { - return false; - } - if (!(lhs.private_parameters == rhs.private_parameters)) { - return false; - } - if (!(lhs.public_parameters == rhs.public_parameters)) { - return false; - } - if (!(lhs.return_values == rhs.return_values)) { - return false; - } - if (!(lhs.assert_messages == rhs.assert_messages)) { - return false; - } - if (!(lhs.recursive == rhs.recursive)) { - return false; - } - return true; -} + inline bool operator==(const BrilligOutputs::Array &lhs, const BrilligOutputs::Array &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Circuit::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector BrilligOutputs::Array::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Circuit Circuit::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline BrilligOutputs::Array BrilligOutputs::Array::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Circuit &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize( - obj.current_witness_index, serializer); - serde::Serializable::serialize(obj.opcodes, - serializer); - serde::Serializable::serialize( - obj.expression_width, serializer); - serde::Serializable::serialize( - obj.private_parameters, serializer); - serde::Serializable::serialize( - obj.public_parameters, serializer); - serde::Serializable::serialize(obj.return_values, - serializer); - serde::Serializable::serialize( - obj.assert_messages, serializer); - serde::Serializable::serialize(obj.recursive, - serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::BrilligOutputs::Array &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Circuit serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Circuit obj; - obj.current_witness_index = - serde::Deserializable::deserialize( - deserializer); - obj.opcodes = - serde::Deserializable::deserialize(deserializer); - obj.expression_width = - serde::Deserializable::deserialize( - deserializer); - obj.private_parameters = - serde::Deserializable::deserialize( - deserializer); - obj.public_parameters = - serde::Deserializable::deserialize( - deserializer); - obj.return_values = - serde::Deserializable::deserialize( - deserializer); - obj.assert_messages = - serde::Deserializable::deserialize( - deserializer); - obj.recursive = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::BrilligOutputs::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::BrilligOutputs::Array obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Directive &lhs, const Directive &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Circuit &lhs, const Circuit &rhs) { + if (!(lhs.current_witness_index == rhs.current_witness_index)) { return false; } + if (!(lhs.opcodes == rhs.opcodes)) { return false; } + if (!(lhs.expression_width == rhs.expression_width)) { return false; } + if (!(lhs.private_parameters == rhs.private_parameters)) { return false; } + if (!(lhs.public_parameters == rhs.public_parameters)) { return false; } + if (!(lhs.return_values == rhs.return_values)) { return false; } + if (!(lhs.assert_messages == rhs.assert_messages)) { return false; } + if (!(lhs.recursive == rhs.recursive)) { return false; } + return true; + } -inline std::vector Directive::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Circuit::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Directive Directive::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Circuit Circuit::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Directive &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Circuit &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.current_witness_index, serializer); + serde::Serializable::serialize(obj.opcodes, serializer); + serde::Serializable::serialize(obj.expression_width, serializer); + serde::Serializable::serialize(obj.private_parameters, serializer); + serde::Serializable::serialize(obj.public_parameters, serializer); + serde::Serializable::serialize(obj.return_values, serializer); + serde::Serializable::serialize(obj.assert_messages, serializer); + serde::Serializable::serialize(obj.recursive, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Directive serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Directive obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Circuit serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Circuit obj; + obj.current_witness_index = serde::Deserializable::deserialize(deserializer); + obj.opcodes = serde::Deserializable::deserialize(deserializer); + obj.expression_width = serde::Deserializable::deserialize(deserializer); + obj.private_parameters = serde::Deserializable::deserialize(deserializer); + obj.public_parameters = serde::Deserializable::deserialize(deserializer); + obj.return_values = serde::Deserializable::deserialize(deserializer); + obj.assert_messages = serde::Deserializable::deserialize(deserializer); + obj.recursive = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Directive::ToLeRadix &lhs, - const Directive::ToLeRadix &rhs) { - if (!(lhs.a == rhs.a)) { - return false; - } - if (!(lhs.b == rhs.b)) { - return false; - } - if (!(lhs.radix == rhs.radix)) { - return false; - } - return true; -} + inline bool operator==(const Directive &lhs, const Directive &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Directive::ToLeRadix::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Directive::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Directive::ToLeRadix -Directive::ToLeRadix::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Directive Directive::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Directive::ToLeRadix &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.a, serializer); - serde::Serializable::serialize(obj.b, serializer); - serde::Serializable::serialize(obj.radix, serializer); +void serde::Serializable::serialize(const Program::Directive &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Directive::ToLeRadix -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Directive::ToLeRadix obj; - obj.a = serde::Deserializable::deserialize(deserializer); - obj.b = serde::Deserializable::deserialize(deserializer); - obj.radix = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Directive serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Directive obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Expression &lhs, const Expression &rhs) { - if (!(lhs.mul_terms == rhs.mul_terms)) { - return false; - } - if (!(lhs.linear_combinations == rhs.linear_combinations)) { - return false; - } - if (!(lhs.q_c == rhs.q_c)) { - return false; - } - return true; -} + inline bool operator==(const Directive::ToLeRadix &lhs, const Directive::ToLeRadix &rhs) { + if (!(lhs.a == rhs.a)) { return false; } + if (!(lhs.b == rhs.b)) { return false; } + if (!(lhs.radix == rhs.radix)) { return false; } + return true; + } -inline std::vector Expression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Directive::ToLeRadix::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Expression Expression::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Directive::ToLeRadix Directive::ToLeRadix::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Expression &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.mul_terms, - serializer); - serde::Serializable::serialize( - obj.linear_combinations, serializer); - serde::Serializable::serialize(obj.q_c, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Directive::ToLeRadix &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.a, serializer); + serde::Serializable::serialize(obj.b, serializer); + serde::Serializable::serialize(obj.radix, serializer); } template <> template -Program::Expression serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Expression obj; - obj.mul_terms = - serde::Deserializable::deserialize(deserializer); - obj.linear_combinations = - serde::Deserializable::deserialize( - deserializer); - obj.q_c = serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Directive::ToLeRadix serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Directive::ToLeRadix obj; + obj.a = serde::Deserializable::deserialize(deserializer); + obj.b = serde::Deserializable::deserialize(deserializer); + obj.radix = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ExpressionOrMemory &lhs, - const ExpressionOrMemory &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Expression &lhs, const Expression &rhs) { + if (!(lhs.mul_terms == rhs.mul_terms)) { return false; } + if (!(lhs.linear_combinations == rhs.linear_combinations)) { return false; } + if (!(lhs.q_c == rhs.q_c)) { return false; } + return true; + } -inline std::vector ExpressionOrMemory::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Expression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionOrMemory -ExpressionOrMemory::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Expression Expression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionOrMemory &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Expression &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.mul_terms, serializer); + serde::Serializable::serialize(obj.linear_combinations, serializer); + serde::Serializable::serialize(obj.q_c, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ExpressionOrMemory -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::ExpressionOrMemory obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Expression obj; + obj.mul_terms = serde::Deserializable::deserialize(deserializer); + obj.linear_combinations = serde::Deserializable::deserialize(deserializer); + obj.q_c = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ExpressionOrMemory::Expression &lhs, - const ExpressionOrMemory::Expression &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionOrMemory &lhs, const ExpressionOrMemory &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ExpressionOrMemory::Expression::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionOrMemory::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionOrMemory::Expression -ExpressionOrMemory::Expression::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionOrMemory ExpressionOrMemory::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionOrMemory::Expression &obj, - Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ExpressionOrMemory &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ExpressionOrMemory::Expression -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionOrMemory::Expression obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ExpressionOrMemory serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::ExpressionOrMemory obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ExpressionOrMemory::Memory &lhs, - const ExpressionOrMemory::Memory &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionOrMemory::Expression &lhs, const ExpressionOrMemory::Expression &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ExpressionOrMemory::Memory::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionOrMemory::Expression::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionOrMemory::Memory -ExpressionOrMemory::Memory::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionOrMemory::Expression ExpressionOrMemory::Expression::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionOrMemory::Memory &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ExpressionOrMemory::Expression &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ExpressionOrMemory::Memory -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionOrMemory::Memory obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ExpressionOrMemory::Expression serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionOrMemory::Expression obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionOrMemory::Memory &lhs, const ExpressionOrMemory::Memory &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ExpressionWidth::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionOrMemory::Memory::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionWidth -ExpressionWidth::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionOrMemory::Memory ExpressionOrMemory::Memory::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionWidth &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::ExpressionOrMemory::Memory &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ExpressionWidth -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::ExpressionWidth obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::ExpressionOrMemory::Memory serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionOrMemory::Memory obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ExpressionWidth::Unbounded &lhs, - const ExpressionWidth::Unbounded &rhs) { - return true; -} + inline bool operator==(const ExpressionWidth &lhs, const ExpressionWidth &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ExpressionWidth::Unbounded::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionWidth::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionWidth::Unbounded -ExpressionWidth::Unbounded::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionWidth ExpressionWidth::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) {} +void serde::Serializable::serialize(const Program::ExpressionWidth &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); +} template <> template -Program::ExpressionWidth::Unbounded -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionWidth::Unbounded obj; - return obj; +Program::ExpressionWidth serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::ExpressionWidth obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ExpressionWidth::Bounded &lhs, - const ExpressionWidth::Bounded &rhs) { - if (!(lhs.width == rhs.width)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionWidth::Unbounded &lhs, const ExpressionWidth::Unbounded &rhs) { + return true; + } -inline std::vector ExpressionWidth::Bounded::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionWidth::Unbounded::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ExpressionWidth::Bounded -ExpressionWidth::Bounded::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionWidth::Unbounded ExpressionWidth::Unbounded::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.width, serializer); +void serde::Serializable::serialize(const Program::ExpressionWidth::Unbounded &obj, Serializer &serializer) { } template <> template -Program::ExpressionWidth::Bounded -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ExpressionWidth::Bounded obj; - obj.width = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ExpressionWidth::Unbounded serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionWidth::Unbounded obj; + return obj; } namespace Program { -inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) { - if (!(lhs.witness == rhs.witness)) { - return false; - } - if (!(lhs.num_bits == rhs.num_bits)) { - return false; - } - return true; -} + inline bool operator==(const ExpressionWidth::Bounded &lhs, const ExpressionWidth::Bounded &rhs) { + if (!(lhs.width == rhs.width)) { return false; } + return true; + } -inline std::vector FunctionInput::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ExpressionWidth::Bounded::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline FunctionInput -FunctionInput::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ExpressionWidth::Bounded ExpressionWidth::Bounded::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::FunctionInput &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.witness, - serializer); - serde::Serializable::serialize(obj.num_bits, - serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::ExpressionWidth::Bounded &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.width, serializer); } template <> template -Program::FunctionInput -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::FunctionInput obj; - obj.witness = - serde::Deserializable::deserialize(deserializer); - obj.num_bits = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::ExpressionWidth::Bounded serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ExpressionWidth::Bounded obj; + obj.width = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) { - if (!(lhs.pointer == rhs.pointer)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - return true; -} + inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) { + if (!(lhs.witness == rhs.witness)) { return false; } + if (!(lhs.num_bits == rhs.num_bits)) { return false; } + return true; + } -inline std::vector HeapArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector FunctionInput::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapArray HeapArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline FunctionInput FunctionInput::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapArray &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.pointer, - serializer); - serde::Serializable::serialize(obj.size, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::FunctionInput &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.witness, serializer); + serde::Serializable::serialize(obj.num_bits, serializer); + serializer.decrease_container_depth(); } template <> template -Program::HeapArray serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::HeapArray obj; - obj.pointer = - serde::Deserializable::deserialize(deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::FunctionInput serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::FunctionInput obj; + obj.witness = serde::Deserializable::deserialize(deserializer); + obj.num_bits = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const HeapArray &lhs, const HeapArray &rhs) { + if (!(lhs.pointer == rhs.pointer)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + return true; + } -inline std::vector HeapValueType::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType -HeapValueType::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapArray HeapArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::HeapArray &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.pointer, serializer); + serde::Serializable::serialize(obj.size, serializer); + serializer.decrease_container_depth(); } template <> template -Program::HeapValueType -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::HeapValueType obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::HeapArray obj; + obj.pointer = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const HeapValueType::Simple &lhs, - const HeapValueType::Simple &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType &lhs, const HeapValueType &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector HeapValueType::Simple::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType::Simple -HeapValueType::Simple::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType HeapValueType::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType::Simple &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::HeapValueType &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::HeapValueType::Simple -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::HeapValueType::Simple obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::HeapValueType serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::HeapValueType obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const HeapValueType::Array &lhs, - const HeapValueType::Array &rhs) { - if (!(lhs.value_types == rhs.value_types)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType::Simple &lhs, const HeapValueType::Simple &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector HeapValueType::Array::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::Simple::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType::Array -HeapValueType::Array::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType::Simple HeapValueType::Simple::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType::Array &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value_types, - serializer); - serde::Serializable::serialize(obj.size, serializer); +void serde::Serializable::serialize(const Program::HeapValueType::Simple &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::HeapValueType::Array -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::HeapValueType::Array obj; - obj.value_types = - serde::Deserializable::deserialize( - deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::HeapValueType::Simple serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::HeapValueType::Simple obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const HeapValueType::Vector &lhs, - const HeapValueType::Vector &rhs) { - if (!(lhs.value_types == rhs.value_types)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType::Array &lhs, const HeapValueType::Array &rhs) { + if (!(lhs.value_types == rhs.value_types)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + return true; + } -inline std::vector HeapValueType::Vector::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::Array::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapValueType::Vector -HeapValueType::Vector::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType::Array HeapValueType::Array::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapValueType::Vector &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value_types, - serializer); +void serde::Serializable::serialize(const Program::HeapValueType::Array &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value_types, serializer); + serde::Serializable::serialize(obj.size, serializer); } template <> template -Program::HeapValueType::Vector -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::HeapValueType::Vector obj; - obj.value_types = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::HeapValueType::Array serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::HeapValueType::Array obj; + obj.value_types = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) { - if (!(lhs.pointer == rhs.pointer)) { - return false; - } - if (!(lhs.size == rhs.size)) { - return false; - } - return true; -} + inline bool operator==(const HeapValueType::Vector &lhs, const HeapValueType::Vector &rhs) { + if (!(lhs.value_types == rhs.value_types)) { return false; } + return true; + } -inline std::vector HeapVector::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapValueType::Vector::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline HeapVector HeapVector::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapValueType::Vector HeapValueType::Vector::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::HeapVector &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.pointer, - serializer); - serde::Serializable::serialize(obj.size, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::HeapValueType::Vector &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value_types, serializer); } template <> template -Program::HeapVector serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::HeapVector obj; - obj.pointer = - serde::Deserializable::deserialize(deserializer); - obj.size = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::HeapValueType::Vector serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::HeapValueType::Vector obj; + obj.value_types = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const MemOp &lhs, const MemOp &rhs) { - if (!(lhs.operation == rhs.operation)) { - return false; - } - if (!(lhs.index == rhs.index)) { - return false; - } - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const HeapVector &lhs, const HeapVector &rhs) { + if (!(lhs.pointer == rhs.pointer)) { return false; } + if (!(lhs.size == rhs.size)) { return false; } + return true; + } -inline std::vector MemOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector HeapVector::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline MemOp MemOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline HeapVector HeapVector::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize(const Program::MemOp &obj, - Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.operation, - serializer); - serde::Serializable::serialize(obj.index, serializer); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::HeapVector &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.pointer, serializer); + serde::Serializable::serialize(obj.size, serializer); + serializer.decrease_container_depth(); } template <> template -Program::MemOp -serde::Deserializable::deserialize(Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::MemOp obj; - obj.operation = - serde::Deserializable::deserialize(deserializer); - obj.index = - serde::Deserializable::deserialize(deserializer); - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::HeapVector obj; + obj.pointer = serde::Deserializable::deserialize(deserializer); + obj.size = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const MemOp &lhs, const MemOp &rhs) { + if (!(lhs.operation == rhs.operation)) { return false; } + if (!(lhs.index == rhs.index)) { return false; } + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector MemoryAddress::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector MemOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline MemoryAddress -MemoryAddress::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline MemOp MemOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::MemoryAddress &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::MemOp &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.operation, serializer); + serde::Serializable::serialize(obj.index, serializer); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::MemoryAddress -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::MemoryAddress obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::MemOp serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::MemOp obj; + obj.operation = serde::Deserializable::deserialize(deserializer); + obj.index = serde::Deserializable::deserialize(deserializer); + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode &lhs, const Opcode &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const MemoryAddress &lhs, const MemoryAddress &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector MemoryAddress::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode Opcode::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline MemoryAddress MemoryAddress::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize(const Program::Opcode &obj, - Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::MemoryAddress &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Opcode serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Opcode obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::MemoryAddress obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode::AssertZero &lhs, - const Opcode::AssertZero &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode &lhs, const Opcode &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::AssertZero::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::AssertZero -Opcode::AssertZero::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode Opcode::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::AssertZero &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Opcode &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Opcode::AssertZero -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::AssertZero obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Opcode obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, - const Opcode::BlackBoxFuncCall &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::AssertZero &lhs, const Opcode::AssertZero &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::BlackBoxFuncCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::AssertZero::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::BlackBoxFuncCall -Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::AssertZero Opcode::AssertZero::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Opcode::AssertZero &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::BlackBoxFuncCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::BlackBoxFuncCall obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::AssertZero serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::AssertZero obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::Directive &lhs, - const Opcode::Directive &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::BlackBoxFuncCall &lhs, const Opcode::BlackBoxFuncCall &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::Directive::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::BlackBoxFuncCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::Directive -Opcode::Directive::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::BlackBoxFuncCall Opcode::BlackBoxFuncCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::Directive &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::Opcode::BlackBoxFuncCall &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::Directive -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::Directive obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::BlackBoxFuncCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::BlackBoxFuncCall obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::MemoryOp &lhs, - const Opcode::MemoryOp &rhs) { - if (!(lhs.block_id == rhs.block_id)) { - return false; - } - if (!(lhs.op == rhs.op)) { - return false; - } - if (!(lhs.predicate == rhs.predicate)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::Directive &lhs, const Opcode::Directive &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector Opcode::MemoryOp::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::Directive::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::MemoryOp -Opcode::MemoryOp::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::Directive Opcode::Directive::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::MemoryOp &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.block_id, - serializer); - serde::Serializable::serialize(obj.op, serializer); - serde::Serializable::serialize(obj.predicate, - serializer); +void serde::Serializable::serialize(const Program::Opcode::Directive &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::Opcode::MemoryOp -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::MemoryOp obj; - obj.block_id = - serde::Deserializable::deserialize(deserializer); - obj.op = serde::Deserializable::deserialize(deserializer); - obj.predicate = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::Directive serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::Directive obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::MemoryInit &lhs, - const Opcode::MemoryInit &rhs) { - if (!(lhs.block_id == rhs.block_id)) { - return false; - } - if (!(lhs.init == rhs.init)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::MemoryOp &lhs, const Opcode::MemoryOp &rhs) { + if (!(lhs.block_id == rhs.block_id)) { return false; } + if (!(lhs.op == rhs.op)) { return false; } + if (!(lhs.predicate == rhs.predicate)) { return false; } + return true; + } -inline std::vector Opcode::MemoryInit::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::MemoryOp::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::MemoryInit -Opcode::MemoryInit::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::MemoryOp Opcode::MemoryOp::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::MemoryInit &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.block_id, - serializer); - serde::Serializable::serialize(obj.init, serializer); +void serde::Serializable::serialize(const Program::Opcode::MemoryOp &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.block_id, serializer); + serde::Serializable::serialize(obj.op, serializer); + serde::Serializable::serialize(obj.predicate, serializer); } template <> template -Program::Opcode::MemoryInit -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::MemoryInit obj; - obj.block_id = - serde::Deserializable::deserialize(deserializer); - obj.init = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::MemoryOp serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::MemoryOp obj; + obj.block_id = serde::Deserializable::deserialize(deserializer); + obj.op = serde::Deserializable::deserialize(deserializer); + obj.predicate = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::BrilligCall &lhs, - const Opcode::BrilligCall &rhs) { - if (!(lhs.id == rhs.id)) { - return false; - } - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - if (!(lhs.predicate == rhs.predicate)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::MemoryInit &lhs, const Opcode::MemoryInit &rhs) { + if (!(lhs.block_id == rhs.block_id)) { return false; } + if (!(lhs.init == rhs.init)) { return false; } + return true; + } -inline std::vector Opcode::BrilligCall::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::MemoryInit::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::BrilligCall -Opcode::BrilligCall::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::MemoryInit Opcode::MemoryInit::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::BrilligCall &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.id, serializer); - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); - serde::Serializable::serialize(obj.predicate, - serializer); +void serde::Serializable::serialize(const Program::Opcode::MemoryInit &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.block_id, serializer); + serde::Serializable::serialize(obj.init, serializer); } template <> template -Program::Opcode::BrilligCall -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::BrilligCall obj; - obj.id = serde::Deserializable::deserialize(deserializer); - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - obj.predicate = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::MemoryInit serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::MemoryInit obj; + obj.block_id = serde::Deserializable::deserialize(deserializer); + obj.init = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) { - if (!(lhs.id == rhs.id)) { - return false; - } - if (!(lhs.inputs == rhs.inputs)) { - return false; - } - if (!(lhs.outputs == rhs.outputs)) { - return false; - } - if (!(lhs.predicate == rhs.predicate)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::BrilligCall &lhs, const Opcode::BrilligCall &rhs) { + if (!(lhs.id == rhs.id)) { return false; } + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + if (!(lhs.predicate == rhs.predicate)) { return false; } + return true; + } -inline std::vector Opcode::Call::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::BrilligCall::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Opcode::Call -Opcode::Call::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::BrilligCall Opcode::BrilligCall::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Opcode::Call &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.id, serializer); - serde::Serializable::serialize(obj.inputs, serializer); - serde::Serializable::serialize(obj.outputs, - serializer); - serde::Serializable::serialize(obj.predicate, - serializer); +void serde::Serializable::serialize(const Program::Opcode::BrilligCall &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.id, serializer); + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); + serde::Serializable::serialize(obj.predicate, serializer); } template <> template -Program::Opcode::Call serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::Opcode::Call obj; - obj.id = serde::Deserializable::deserialize(deserializer); - obj.inputs = - serde::Deserializable::deserialize(deserializer); - obj.outputs = - serde::Deserializable::deserialize(deserializer); - obj.predicate = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::Opcode::BrilligCall serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::BrilligCall obj; + obj.id = serde::Deserializable::deserialize(deserializer); + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + obj.predicate = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) { + if (!(lhs.id == rhs.id)) { return false; } + if (!(lhs.inputs == rhs.inputs)) { return false; } + if (!(lhs.outputs == rhs.outputs)) { return false; } + if (!(lhs.predicate == rhs.predicate)) { return false; } + return true; + } -inline std::vector OpcodeLocation::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Opcode::Call::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline OpcodeLocation -OpcodeLocation::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Opcode::Call Opcode::Call::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::OpcodeLocation &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Opcode::Call &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.id, serializer); + serde::Serializable::serialize(obj.inputs, serializer); + serde::Serializable::serialize(obj.outputs, serializer); + serde::Serializable::serialize(obj.predicate, serializer); } template <> template -Program::OpcodeLocation -serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::OpcodeLocation obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Opcode::Call serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::Opcode::Call obj; + obj.id = serde::Deserializable::deserialize(deserializer); + obj.inputs = serde::Deserializable::deserialize(deserializer); + obj.outputs = serde::Deserializable::deserialize(deserializer); + obj.predicate = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const OpcodeLocation::Acir &lhs, - const OpcodeLocation::Acir &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector OpcodeLocation::Acir::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector OpcodeLocation::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline OpcodeLocation::Acir -OpcodeLocation::Acir::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline OpcodeLocation OpcodeLocation::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::OpcodeLocation::Acir &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::OpcodeLocation &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::OpcodeLocation::Acir -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::OpcodeLocation::Acir obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::OpcodeLocation serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::OpcodeLocation obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const OpcodeLocation::Brillig &lhs, - const OpcodeLocation::Brillig &rhs) { - if (!(lhs.acir_index == rhs.acir_index)) { - return false; - } - if (!(lhs.brillig_index == rhs.brillig_index)) { - return false; - } - return true; -} + inline bool operator==(const OpcodeLocation::Acir &lhs, const OpcodeLocation::Acir &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector OpcodeLocation::Brillig::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector OpcodeLocation::Acir::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline OpcodeLocation::Brillig -OpcodeLocation::Brillig::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline OpcodeLocation::Acir OpcodeLocation::Acir::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.acir_index, - serializer); - serde::Serializable::serialize(obj.brillig_index, - serializer); +void serde::Serializable::serialize(const Program::OpcodeLocation::Acir &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::OpcodeLocation::Brillig -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::OpcodeLocation::Brillig obj; - obj.acir_index = serde::Deserializable::deserialize( - deserializer); - obj.brillig_index = - serde::Deserializable::deserialize( - deserializer); - return obj; +Program::OpcodeLocation::Acir serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::OpcodeLocation::Acir obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Program &lhs, const Program &rhs) { - if (!(lhs.functions == rhs.functions)) { - return false; - } - if (!(lhs.unconstrained_functions == rhs.unconstrained_functions)) { - return false; - } - return true; -} + inline bool operator==(const OpcodeLocation::Brillig &lhs, const OpcodeLocation::Brillig &rhs) { + if (!(lhs.acir_index == rhs.acir_index)) { return false; } + if (!(lhs.brillig_index == rhs.brillig_index)) { return false; } + return true; + } -inline std::vector Program::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector OpcodeLocation::Brillig::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline Program Program::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline OpcodeLocation::Brillig OpcodeLocation::Brillig::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Program &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.functions, - serializer); - serde::Serializable::serialize( - obj.unconstrained_functions, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::OpcodeLocation::Brillig &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.acir_index, serializer); + serde::Serializable::serialize(obj.brillig_index, serializer); } template <> template -Program::Program serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Program obj; - obj.functions = - serde::Deserializable::deserialize(deserializer); - obj.unconstrained_functions = - serde::Deserializable::deserialize( - deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::OpcodeLocation::Brillig serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::OpcodeLocation::Brillig obj; + obj.acir_index = serde::Deserializable::deserialize(deserializer); + obj.brillig_index = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const Program &lhs, const Program &rhs) { + if (!(lhs.functions == rhs.functions)) { return false; } + if (!(lhs.unconstrained_functions == rhs.unconstrained_functions)) { return false; } + return true; + } -inline std::vector PublicInputs::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector Program::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline PublicInputs -PublicInputs::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline Program Program::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::PublicInputs &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Program &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.functions, serializer); + serde::Serializable::serialize(obj.unconstrained_functions, serializer); + serializer.decrease_container_depth(); } template <> template -Program::PublicInputs serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::PublicInputs obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Program serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Program obj; + obj.functions = serde::Deserializable::deserialize(deserializer); + obj.unconstrained_functions = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const PublicInputs &lhs, const PublicInputs &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ValueOrArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector PublicInputs::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray -ValueOrArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline PublicInputs PublicInputs::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::PublicInputs &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ValueOrArray serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::ValueOrArray obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::PublicInputs serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::PublicInputs obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray::MemoryAddress &lhs, - const ValueOrArray::MemoryAddress &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray &lhs, const ValueOrArray &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector -ValueOrArray::MemoryAddress::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, - serializer); - return std::move(serializer).bytes(); -} + inline std::vector ValueOrArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray::MemoryAddress -ValueOrArray::MemoryAddress::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ValueOrArray ValueOrArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ValueOrArray &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::ValueOrArray::MemoryAddress -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ValueOrArray::MemoryAddress obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ValueOrArray serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::ValueOrArray obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray::HeapArray &lhs, - const ValueOrArray::HeapArray &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray::MemoryAddress &lhs, const ValueOrArray::MemoryAddress &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ValueOrArray::HeapArray::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ValueOrArray::MemoryAddress::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray::HeapArray -ValueOrArray::HeapArray::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = - serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ValueOrArray::MemoryAddress ValueOrArray::MemoryAddress::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ValueOrArray::MemoryAddress &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ValueOrArray::HeapArray -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ValueOrArray::HeapArray obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ValueOrArray::MemoryAddress serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ValueOrArray::MemoryAddress obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const ValueOrArray::HeapVector &lhs, - const ValueOrArray::HeapVector &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray::HeapArray &lhs, const ValueOrArray::HeapArray &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } -inline std::vector ValueOrArray::HeapVector::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); -} + inline std::vector ValueOrArray::HeapArray::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline ValueOrArray::HeapVector -ValueOrArray::HeapVector::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize( - deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; -} + inline ValueOrArray::HeapArray ValueOrArray::HeapArray::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) { - serde::Serializable::serialize(obj.value, serializer); +void serde::Serializable::serialize(const Program::ValueOrArray::HeapArray &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } template <> template -Program::ValueOrArray::HeapVector -serde::Deserializable::deserialize( - Deserializer &deserializer) { - Program::ValueOrArray::HeapVector obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - return obj; +Program::ValueOrArray::HeapArray serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ValueOrArray::HeapArray obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } namespace Program { -inline bool operator==(const Witness &lhs, const Witness &rhs) { - if (!(lhs.value == rhs.value)) { - return false; - } - return true; -} + inline bool operator==(const ValueOrArray::HeapVector &lhs, const ValueOrArray::HeapVector &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } + + inline std::vector ValueOrArray::HeapVector::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } -inline std::vector Witness::bincodeSerialize() const { - auto serializer = serde::BincodeSerializer(); - serde::Serializable::serialize(*this, serializer); - return std::move(serializer).bytes(); + inline ValueOrArray::HeapVector ValueOrArray::HeapVector::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 +void serde::Serializable::serialize(const Program::ValueOrArray::HeapVector &obj, Serializer &serializer) { + serde::Serializable::serialize(obj.value, serializer); } -inline Witness Witness::bincodeDeserialize(std::vector input) { - auto deserializer = serde::BincodeDeserializer(input); - auto value = serde::Deserializable::deserialize(deserializer); - if (deserializer.get_buffer_offset() < input.size()) { - throw serde::deserialization_error("Some input bytes were not read"); - } - return value; +template <> +template +Program::ValueOrArray::HeapVector serde::Deserializable::deserialize(Deserializer &deserializer) { + Program::ValueOrArray::HeapVector obj; + obj.value = serde::Deserializable::deserialize(deserializer); + return obj; } +namespace Program { + + inline bool operator==(const Witness &lhs, const Witness &rhs) { + if (!(lhs.value == rhs.value)) { return false; } + return true; + } + + inline std::vector Witness::bincodeSerialize() const { + auto serializer = serde::BincodeSerializer(); + serde::Serializable::serialize(*this, serializer); + return std::move(serializer).bytes(); + } + + inline Witness Witness::bincodeDeserialize(std::vector input) { + auto deserializer = serde::BincodeDeserializer(input); + auto value = serde::Deserializable::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 -void serde::Serializable::serialize( - const Program::Witness &obj, Serializer &serializer) { - serializer.increase_container_depth(); - serde::Serializable::serialize(obj.value, serializer); - serializer.decrease_container_depth(); +void serde::Serializable::serialize(const Program::Witness &obj, Serializer &serializer) { + serializer.increase_container_depth(); + serde::Serializable::serialize(obj.value, serializer); + serializer.decrease_container_depth(); } template <> template -Program::Witness serde::Deserializable::deserialize( - Deserializer &deserializer) { - deserializer.increase_container_depth(); - Program::Witness obj; - obj.value = - serde::Deserializable::deserialize(deserializer); - deserializer.decrease_container_depth(); - return obj; +Program::Witness serde::Deserializable::deserialize(Deserializer &deserializer) { + deserializer.increase_container_depth(); + Program::Witness obj; + obj.value = serde::Deserializable::deserialize(deserializer); + deserializer.decrease_container_depth(); + return obj; }