diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs index f7c3d224577..deeeec104e3 100644 --- a/compiler/noirc_frontend/src/elaborator/statements.rs +++ b/compiler/noirc_frontend/src/elaborator/statements.rs @@ -14,10 +14,13 @@ use crate::{ type_check::{Source, TypeCheckError}, }, hir_def::{ - expr::HirIdent, - stmt::{HirAssignStatement, HirForStatement, HirLValue, HirLetStatement, HirStatement}, + expr::{HirBlockExpression, HirExpression, HirIdent}, + stmt::{ + HirAssignStatement, HirForStatement, HirLValue, HirLetStatement, HirPattern, + HirStatement, + }, }, - node_interner::{DefinitionId, DefinitionKind, GlobalId, StmtId}, + node_interner::{DefinitionId, DefinitionKind, ExprId, GlobalId, StmtId}, }; use super::{Elaborator, Loop, lints}; @@ -152,7 +155,9 @@ impl Elaborator<'_> { pub(super) fn elaborate_assign(&mut self, assign: AssignStatement) -> (HirStatement, Type) { let expr_location = assign.expression.location; let (expression, expr_type) = self.elaborate_expression(assign.expression); - let (lvalue, lvalue_type, mutable) = self.elaborate_lvalue(assign.lvalue); + + let (lvalue, lvalue_type, mutable, mut new_statements) = + self.elaborate_lvalue(assign.lvalue); if !mutable { let (_, name, location) = self.get_lvalue_error_info(&lvalue); @@ -171,8 +176,19 @@ impl Elaborator<'_> { } }); - let stmt = HirAssignStatement { lvalue, expression }; - (HirStatement::Assign(stmt), Type::Unit) + let assign = HirAssignStatement { lvalue, expression }; + let assign = HirStatement::Assign(assign); + + if new_statements.is_empty() { + (assign, Type::Unit) + } else { + let assign = self.interner.push_stmt(assign); + self.interner.push_stmt_location(assign, expr_location); + new_statements.push(assign); + let block = HirExpression::Block(HirBlockExpression { statements: new_statements }); + let block = self.interner.push_expr_full(block, expr_location, Type::Unit); + (HirStatement::Expression(block), Type::Unit) + } } pub(super) fn elaborate_for(&mut self, for_loop: ForLoopStatement) -> (HirStatement, Type) { @@ -354,7 +370,13 @@ impl Elaborator<'_> { } } - fn elaborate_lvalue(&mut self, lvalue: LValue) -> (HirLValue, Type, bool) { + /// Elaborates an lvalue returning: + /// - The HirLValue equivalent of the given `lvalue` + /// - The type being assigned to + /// - Whether the underlying variable is mutable + /// - A vector of new statements which need to prefix the resulting assign statement. + /// This hoists out any sub-expressions to simplify sequencing of side-effects. + fn elaborate_lvalue(&mut self, lvalue: LValue) -> (HirLValue, Type, bool, Vec) { match lvalue { LValue::Ident(ident) => { let mut mutable = true; @@ -384,10 +406,10 @@ impl Elaborator<'_> { self.interner.add_local_reference(ident.id, location); - (HirLValue::Ident(ident.clone(), typ.clone()), typ, mutable) + (HirLValue::Ident(ident.clone(), typ.clone()), typ, mutable, Vec::new()) } LValue::MemberAccess { object, field_name, location } => { - let (object, lhs_type, mut mutable) = self.elaborate_lvalue(*object); + let (object, lhs_type, mut mutable, statements) = self.elaborate_lvalue(*object); let mut object = Box::new(object); let field_name = field_name.clone(); @@ -425,11 +447,11 @@ impl Elaborator<'_> { let typ = object_type.clone(); let lvalue = HirLValue::MemberAccess { object, field_name, field_index, typ, location }; - (lvalue, object_type, mutable) + (lvalue, object_type, mutable, statements) } LValue::Index { array, index, location } => { let expr_location = index.location; - let (index, index_type) = self.elaborate_expression(index); + let (mut index, index_type) = self.elaborate_expression(index); self.push_index_to_check(index); @@ -440,7 +462,19 @@ impl Elaborator<'_> { expr_location, }); - let (mut lvalue, mut lvalue_type, mut mutable) = self.elaborate_lvalue(*array); + let (mut lvalue, mut lvalue_type, mut mutable, mut statements) = + self.elaborate_lvalue(*array); + + // Push the index expression to the end of the new statements list, referring to it + // afterward with a let binding. Note that since we recur first then push to the + // end of the list we're evaluating side-effects such that in `a[i][j]`, `i` will + // be evaluated first, followed by `j`. + if let Some((index_definition, new_index)) = + self.fresh_definition_for_lvalue_index(index, index_type, expr_location) + { + index = new_index; + statements.push(index_definition); + } // Before we check that the lvalue is an array, try to dereference it as many times // as needed to unwrap any `&` or `&mut` wrappers. @@ -485,10 +519,10 @@ impl Elaborator<'_> { let array = Box::new(lvalue); let array_type = typ.clone(); - (HirLValue::Index { array, index, typ, location }, array_type, mutable) + (HirLValue::Index { array, index, typ, location }, array_type, mutable, statements) } LValue::Dereference(lvalue, location) => { - let (lvalue, reference_type, _) = self.elaborate_lvalue(*lvalue); + let (lvalue, reference_type, _, statements) = self.elaborate_lvalue(*lvalue); let lvalue = Box::new(lvalue); let element_type = Type::type_variable(self.interner.next_type_variable_id()); @@ -510,7 +544,7 @@ impl Elaborator<'_> { location, implicitly_added: false, }; - (lvalue, typ, true) + (lvalue, typ, true, statements) } LValue::Interned(id, location) => { let lvalue = self.interner.get_lvalue(id, location).clone(); @@ -519,6 +553,41 @@ impl Elaborator<'_> { } } + fn fresh_definition_for_lvalue_index( + &mut self, + expr: ExprId, + typ: Type, + location: Location, + ) -> Option<(StmtId, ExprId)> { + // If the original expression trivially cannot have side-effects, don't bother cluttering + // the output with a let binding. Note that array literals can have side-effects but these + // would produce type errors anyway. + if matches!( + self.interner.expression(&expr), + HirExpression::Ident(..) | HirExpression::Literal(..) + ) { + return None; + } + + let id = self.interner.push_definition( + format!("i_{}", self.interner.definition_count()), + false, + false, + DefinitionKind::Local(None), + location, + ); + let ident = HirIdent::non_trait_method(id, location); + let ident_expr = HirExpression::Ident(ident.clone(), None); + + let ident_id = self.interner.push_expr_full(ident_expr, location, typ.clone()); + + let pattern = HirPattern::Identifier(ident); + let let_ = HirStatement::Let(HirLetStatement::basic(pattern, typ, expr)); + let let_ = self.interner.push_stmt(let_); + self.interner.push_stmt_location(let_, location); + Some((let_, ident_id)) + } + /// Type checks a field access, adding dereference operators as necessary pub(super) fn check_field_access( &mut self, diff --git a/compiler/noirc_frontend/src/hir_def/stmt.rs b/compiler/noirc_frontend/src/hir_def/stmt.rs index 08a98ccf162..2cba6e7accf 100644 --- a/compiler/noirc_frontend/src/hir_def/stmt.rs +++ b/compiler/noirc_frontend/src/hir_def/stmt.rs @@ -143,6 +143,9 @@ pub enum HirLValue { }, Index { array: Box, + /// `index` is required to be an identifier to simplify sequencing of side-effects. + /// However we also store types and locations on ExprIds which makes these necessary + /// for evaluating/compiling HirIdents so we don't directly require a HirIdent type here. index: ExprId, typ: Type, location: Location, diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs index 30e2aedc023..3a1f33b3534 100644 --- a/compiler/noirc_frontend/src/node_interner.rs +++ b/compiler/noirc_frontend/src/node_interner.rs @@ -980,6 +980,10 @@ impl NodeInterner { self.func_meta.insert(func_id, func_data); } + pub fn definition_count(&self) -> usize { + self.definitions.len() + } + pub fn push_definition( &mut self, name: String, diff --git a/test_programs/compile_failure/assign_mutation_in_lvalue/Nargo.toml b/test_programs/execution_success/assign_mutation_in_lvalue/Nargo.toml similarity index 100% rename from test_programs/compile_failure/assign_mutation_in_lvalue/Nargo.toml rename to test_programs/execution_success/assign_mutation_in_lvalue/Nargo.toml diff --git a/test_programs/compile_failure/assign_mutation_in_lvalue/src/main.nr b/test_programs/execution_success/assign_mutation_in_lvalue/src/main.nr similarity index 63% rename from test_programs/compile_failure/assign_mutation_in_lvalue/src/main.nr rename to test_programs/execution_success/assign_mutation_in_lvalue/src/main.nr index 346d3285fef..2aea233bf8a 100644 --- a/test_programs/compile_failure/assign_mutation_in_lvalue/src/main.nr +++ b/test_programs/execution_success/assign_mutation_in_lvalue/src/main.nr @@ -10,8 +10,5 @@ fn bug() { 1 }] = 7; - // acir+brillig yield ([1, 7], 3) - // comptime yields ([1, 7], 6) - // both should yield: assert_eq(a, ([4, 7], 6)); } diff --git a/test_programs/compile_failure/assign_mutation_in_lvalue/stderr.txt b/test_programs/execution_success/assign_mutation_in_lvalue/stderr.txt similarity index 100% rename from test_programs/compile_failure/assign_mutation_in_lvalue/stderr.txt rename to test_programs/execution_success/assign_mutation_in_lvalue/stderr.txt diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 142b51444fe..3e2abcd905b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -64,8 +64,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZfdbuIwEIXfJddc2OO/cV+lQhVtsxUSApTCSquKd98Ze07avWC1695wvkDOCYwnzvAxvc7P17en/fHH6X16ePyYnpf94bB/ezqcXnaX/eko735MTl9Kmh78Ziq5S+nCXWoTdl18F+oSusQuPYV7CvcU7incU2pPqT2l9hTvRElVAoKqWKMqm4o5iXpnmkyzqZyfVdm0diU5v6h6UzINptE0mWZTyWNVNq1dgzP1ppJXVYNpNE2m2bSYsqkWwwlEB/AALYnWJAZABCRABhQAAzRZS5kcwAMIEACarPVOCZABBcB9SVLtmp2pNyXTYBpNbSlbE+katTZSaK2jq9Oap4FeVeveWqYBA6pBa5wG6tLi1whIgAwoHUgby1eFAIiABFBXvYlN7wTvtV7adJ4AARABCZABBcCAaqBN2KEl3+RKuAGfLss861W/3JFyn553y3y8TA/H6+GwmX7uDtd20vt5d2x62S3yqXTLfHwVlcAf+8OsdNt8ut19KzGZmTis9vTP/hDY/CHUAX902fzRj/hDCrh+4u/588jvjyHh+8c84ida/eV7/kQj/lLg5yF/5tU/VL+01o/j937/mN+Htf9G+ifrXtv8eaj/Eto/j3SPPC7NLnvUiH+tvuzSI35C9eTBN+Bfm49Her8wNj5OI/4a8O1r8iP+jMWrfHfttT/vbr5u3f3I+S8F/I8EX9YESncS/tpBeV1CP7QDy0MxrgnF3a1DHqrDVg52L/vlz0lVp1NyfTwlm0/JBlSyCZVsRCWbUcmGVLIplWxMJZtTyQZVskmVbFQlm1XJhlWyabWp5ekAosuk80fTbFpM2bR29c4BPIAAARABCZABBcAAJOtgTG0S9gACBEAEJEAGFAADqgEhmZBMSCYkE5IJyYRknaQp2yjdoRroMN3BAwgQABGQABmA5IDkgOSI5Ijk2JJv2ozLfvd8mLWhtOOuxxf0lxxefp3xCf4rnZfTy/x6XWbtxc8/TPLySHIXUuDtZpKv+5hpU2iriyIHXh6QvgQ99HpmqBuKfoshU8+vcobj1UBxI6XZ3rT5fwM=", + "bytecode": "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", + "debug_symbols": "pZfNbuJAEITfxWcOMz3/eZUIRYQ4kSXLIAdWWkW8+3bPdDnZA6vN5EJ9BlcZetrj5mN4GZ+vb0/T8np6Hx4eP4bndZrn6e1pPh0Pl+m08Lsfg5GXFIYHuxtSbJKa5CalSjZNbBNq4pr4Ji0lt5TcUnJLyS2ltJTSUkpLsYaVRDnAibLVi2ZVNgdWa1T5vCgaVZMqn59ES1Myqny5LEqqTtWrBtWomlQ5r4iWps6oWlVSlTIYAQ8IgAhIgAwoCl6KInXwFkAASZbSeA8IgAhIgAwoCkGSpaLBAgjgAB4QABGQALktTChNo1G1qqTqVL2qLmhtJVm52kwCtYFkzWoLVZCrymrVxqmQAUWhtk8FcckSFQ8IgAhIDUjayxYBB/CAABBXubFN7gdrpV7SepYADuABARABCZABRUFasUFNvvGVcBs+XdZxlKt+uS/5bj0f1nG5DA/LdZ53w6/DfK0nvZ8PS9XLYeVPuX/G5YWVA1+neRS67T7d5r6VMqmZstvs4b/9zmX1O1c6/N5E9Xvb43fB4foh/8wfe36/t277/j3X9y7A72OPn2jzp5/5A/X4U4I/d/lj3vxd9Q9b/bL/2e/v8kfZoas/dvVfQPvHntXnh6baeY/q8W/V4126x0/ofn78dfi35sk9vZsyNr4cevzF4duXYHv8EYtX8t21l/66u/mabfcjY78U8BsJNm0JFO4k/LOD4raEtmsH5oei3xKSuVuH2FWHPR8cjtP697wqMyqZNqSSTqmkYyrpnEo6qJJOqqSjKumsSjqskk6rpOMq6bxKOrCSTqykIyvpzFpV82QAkWWS+aNqVE2qWbU0tcYALIAADuABARABCZABSJbxmOp8bAEEcAAPCIAISIAMKAqEZEIyIZmQTEgmJBOSZZ6WJqgDdYOiICN1AwsggAN4QABEAJIdkh2SPZI9kn1NvkkzrtPheR6loaTjrssR/cWHl99nfIJ/TOf1dBxfrusovfj5t4lfHonvQnJ5vxv46z5G2iXay6LwgeUHnE1ODq2c6cqOvN1jyJTzC59h8mYgv+PS7G/S/H8A", "file_map": { "50": { "source": "unconstrained fn decode_ascii(ascii: u8) -> u8 {\n if ascii < 58 {\n ascii - 48\n } else if ascii < 71 {\n ascii - 55\n } else {\n ascii - 87\n }\n}\n\nunconstrained fn decode_hex(s: str) -> [u8; M] {\n let mut result: [u8; M] = [0; M];\n let as_bytes = s.as_bytes();\n for i in 0..N {\n if i % 2 != 0 {\n continue;\n }\n result[i / 2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]);\n }\n result\n}\n\nunconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] {\n let result = std::aes128::aes128_encrypt(plaintext, iv, key);\n result\n}\n\nfn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {\n let result: [u8; 16] =\n std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());\n\n // Safety: testing context\n let output_bytes: [u8; 16] = unsafe { decode_hex(output) };\n assert(result == output_bytes);\n\n // Safety: testing context\n let unconstrained_result = unsafe { cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()) };\n assert(unconstrained_result == output_bytes);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_0.snap index 142b51444fe..3e2abcd905b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_0.snap @@ -64,8 +64,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZfdbuIwEIXfJddc2OO/cV+lQhVtsxUSApTCSquKd98Ze07avWC1695wvkDOCYwnzvAxvc7P17en/fHH6X16ePyYnpf94bB/ezqcXnaX/eko735MTl9Kmh78Ziq5S+nCXWoTdl18F+oSusQuPYV7CvcU7incU2pPqT2l9hTvRElVAoKqWKMqm4o5iXpnmkyzqZyfVdm0diU5v6h6UzINptE0mWZTyWNVNq1dgzP1ppJXVYNpNE2m2bSYsqkWwwlEB/AALYnWJAZABCRABhQAAzRZS5kcwAMIEACarPVOCZABBcB9SVLtmp2pNyXTYBpNbSlbE+katTZSaK2jq9Oap4FeVeveWqYBA6pBa5wG6tLi1whIgAwoHUgby1eFAIiABFBXvYlN7wTvtV7adJ4AARABCZABBcCAaqBN2KEl3+RKuAGfLss861W/3JFyn553y3y8TA/H6+GwmX7uDtd20vt5d2x62S3yqXTLfHwVlcAf+8OsdNt8ut19KzGZmTis9vTP/hDY/CHUAX902fzRj/hDCrh+4u/588jvjyHh+8c84ida/eV7/kQj/lLg5yF/5tU/VL+01o/j937/mN+Htf9G+ifrXtv8eaj/Eto/j3SPPC7NLnvUiH+tvuzSI35C9eTBN+Bfm49Her8wNj5OI/4a8O1r8iP+jMWrfHfttT/vbr5u3f3I+S8F/I8EX9YESncS/tpBeV1CP7QDy0MxrgnF3a1DHqrDVg52L/vlz0lVp1NyfTwlm0/JBlSyCZVsRCWbUcmGVLIplWxMJZtTyQZVskmVbFQlm1XJhlWyabWp5ekAosuk80fTbFpM2bR29c4BPIAAARABCZABBcAAJOtgTG0S9gACBEAEJEAGFAADqgEhmZBMSCYkE5IJyYRknaQp2yjdoRroMN3BAwgQABGQABmA5IDkgOSI5Ijk2JJv2ozLfvd8mLWhtOOuxxf0lxxefp3xCf4rnZfTy/x6XWbtxc8/TPLySHIXUuDtZpKv+5hpU2iriyIHXh6QvgQ99HpmqBuKfoshU8+vcobj1UBxI6XZ3rT5fwM=", + "bytecode": "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", + "debug_symbols": "pZfNbuJAEITfxWcOMz3/eZUIRYQ4kSXLIAdWWkW8+3bPdDnZA6vN5EJ9BlcZetrj5mN4GZ+vb0/T8np6Hx4eP4bndZrn6e1pPh0Pl+m08Lsfg5GXFIYHuxtSbJKa5CalSjZNbBNq4pr4Ji0lt5TcUnJLyS2ltJTSUkpLsYaVRDnAibLVi2ZVNgdWa1T5vCgaVZMqn59ES1Myqny5LEqqTtWrBtWomlQ5r4iWps6oWlVSlTIYAQ8IgAhIgAwoCl6KInXwFkAASZbSeA8IgAhIgAwoCkGSpaLBAgjgAB4QABGQALktTChNo1G1qqTqVL2qLmhtJVm52kwCtYFkzWoLVZCrymrVxqmQAUWhtk8FcckSFQ8IgAhIDUjayxYBB/CAABBXubFN7gdrpV7SepYADuABARABCZABRUFasUFNvvGVcBs+XdZxlKt+uS/5bj0f1nG5DA/LdZ53w6/DfK0nvZ8PS9XLYeVPuX/G5YWVA1+neRS67T7d5r6VMqmZstvs4b/9zmX1O1c6/N5E9Xvb43fB4foh/8wfe36/t277/j3X9y7A72OPn2jzp5/5A/X4U4I/d/lj3vxd9Q9b/bL/2e/v8kfZoas/dvVfQPvHntXnh6baeY/q8W/V4126x0/ofn78dfi35sk9vZsyNr4cevzF4duXYHv8EYtX8t21l/66u/mabfcjY78U8BsJNm0JFO4k/LOD4raEtmsH5oei3xKSuVuH2FWHPR8cjtP697wqMyqZNqSSTqmkYyrpnEo6qJJOqqSjKumsSjqskk6rpOMq6bxKOrCSTqykIyvpzFpV82QAkWWS+aNqVE2qWbU0tcYALIAADuABARABCZABSJbxmOp8bAEEcAAPCIAISIAMKAqEZEIyIZmQTEgmJBOSZZ6WJqgDdYOiICN1AwsggAN4QABEAJIdkh2SPZI9kn1NvkkzrtPheR6loaTjrssR/cWHl99nfIJ/TOf1dBxfrusovfj5t4lfHonvQnJ5vxv46z5G2iXay6LwgeUHnE1ODq2c6cqOvN1jyJTzC59h8mYgv+PS7G/S/H8A", "file_map": { "50": { "source": "unconstrained fn decode_ascii(ascii: u8) -> u8 {\n if ascii < 58 {\n ascii - 48\n } else if ascii < 71 {\n ascii - 55\n } else {\n ascii - 87\n }\n}\n\nunconstrained fn decode_hex(s: str) -> [u8; M] {\n let mut result: [u8; M] = [0; M];\n let as_bytes = s.as_bytes();\n for i in 0..N {\n if i % 2 != 0 {\n continue;\n }\n result[i / 2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]);\n }\n result\n}\n\nunconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] {\n let result = std::aes128::aes128_encrypt(plaintext, iv, key);\n result\n}\n\nfn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {\n let result: [u8; 16] =\n std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());\n\n // Safety: testing context\n let output_bytes: [u8; 16] = unsafe { decode_hex(output) };\n assert(result == output_bytes);\n\n // Safety: testing context\n let unconstrained_result = unsafe { cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()) };\n assert(unconstrained_result == output_bytes);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 768114e5d23..8f261f35edc 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -64,8 +64,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "rZdNbuMwDIXv4rUXEvXfqxRBkbZuESBIAjcZYFDk7kNKfG5n4SCjzibvc2w+yRQt05/D6/R8eX/aHd6OH8PD4+fwPO/2+9370/74sj3vjgf+93Mw8pPC8GDHIcUmqUluUqpk08Q2oSauiW/SXHJzyc0lN5fcXEpzKc2lNBdr+FJitXzWifL/XtSpsn8QDe08mXZMVpWvj6JO1avy9VmU51BYnQxrBAjgAB4g05ZJuQwoCt4A5EZlwj4CEiArBBlLJhsI4AAeEADiI3caEiADikI0AAsggDhLIqIHBIA4JwHxkWQkiZJsJAfwgADg0UmyIYtfQZa/gQWwM0k2ZKEbZEBRkAUmyUZxAA8IgAgQH8lGyYDSgIwB2FoBZEjVqXrVoBpVkypbuitbSrVbK/fgtdAIlUYotQYBEAEJkAFFQQqyQXW+8kh4yJ7O8zTJqN+eOn4WT9t5OpyHh8Nlvx+HX9v9pV70cdoeqp63M5/lPE+HV1Y2fNvtJ6Hr+BVt1kMpkwZTdkt4uDveuazxzpWOeG+ixnvbE++Cw/gh/yw+9ty/dwHz97EnnmiJT2vxaT0+IH0xdkRbg9G5xnviA+6et5KeeEL2eYvtiE9Jw3P6We4D9cQvw/vcFR/zEt9Ve0v2ffZr8Tb+qHhuhd9VPTcN7imfmwb31M8tg/9WQOsLcCveumXz69m8orQZbQG7Nr+U8ebIoef+i8P8S7A98REFWPLq/OnG889vfDjwO/9bBfyDg02LA4UVB3PrIYhLDdquVxh3FX5xSGbNwdmuPGz4YPuym/9u56WFp9B6eIqtia9amtY+LrY+viqpOlWvGlSjqvpl9cvqV9SvqF9Rv6J+td/jhajtnmhUTapZtTS1tdWrYAEEcAAPCIAISIAMgHP9upDOVdq/BgRwAA8IgAhIgAwoCgRngjPBmeBMcCY4E5wptSKo3ykNioIzAAsggAN4QABEAJwdnB2cPZw9nH11vkoxzrvt836SgpKKuxxeUF98eP59whl8UJ7m48v0epknqcWvr0r+eSQqIwWzGQee7mOkMdFGFkVO8SZHNsqhrVeakYg26NLl+pJHXkgEcA5HTs3mKsX/Bw==", + "bytecode": "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", + "debug_symbols": "rZfdbuIwEIXfJde5sMf/fZUKVbRNKyQEKIWVVhXvvjP2nLR7EcS6e8P5IDnHzniSmM/hdXq+vD/tDm/Hj+Hh8XN4nnf7/e79aX982Z53xwP/+jkY+UhheLDjkGKT1CQ3KVWyaWKbUBPXxDdpKbml5JaSW0puKaWllJZSWoo1fCqxWj7qRPl3L+pUOT+Ihnac+LwoalVJlc9Pol41qPKMiqhMwjA4GVhGdg7gAQEgE5dZuaLgDcAC5FJlRj4BMqAoBBlLriI4gAcEQARIjlxqyICiEA3AAgjgAJIslYgBEAGSnBmS5Eg1ErtIqpE8IAAigEcnqYYsfwMLIICsnlRDlrpBUZDlbiBjSTWKBwRABCRABpQGZAzA1g4gQ6pO1asG1aiaVDnSXTlSut1auQavjUboNEKrNQiACEiADCgK0pANavKVR8JN9nSep0lG/XbX8b142s7T4Tw8HC77/Tj82u4v9aSP0/ZQ9byd+SgvwXR4ZeXAt91+ErqOX26zbqVMaqbsFnu42+9cVr9zpcPvTVS/tz1+FxzGD/ln/thz/d66Zf4943sX4Pexx0+0+NOaP6/7A8ofY4fbGozO90iPP+Dq+VHU4ydUnx/RHf6U1J7Tz2ofqMe/DO9zlz/mxd/Vu0v1ffZrfpt+1Dy37Hd1z82Ae9rnZsA9/XMr4L810PoC3PBH2YG0Beh6+KWMN0cOPfMvDuUrwfb4Ixqo5NX5043y8xsfCfzO/7aC/5Bg05JAYSXB3GriuPSQ7XqF8a7CLwnJrCU421WHDX/Zvuzmv7fzdecW2h6eYtvEVy1N6z4utn18VVJ1ql41qEZVzcualzWvaF7RvKJ5RfPqfo8Xom73RKNqUs2qpamtW70KFkAAB/CAAIiABMgAJNd/F7Kple1fAwI4gAcEQAQkQAYUBUIyIZmQTEgmJBOSCcmUWhNYyoCi4AzAAgjgAB4QABGAZIdkh2SPZI9kX5Ov0ozzbvu8n6ShpOMuhxf0F389/z7hCP5Qnubjy/R6mSfpxa9/lfzxSFRGCmYzDjzdx0hjoo0sihzihxzZKF9tPdOMRLTBLl3OL3nkhYSBazhyaTZXaf4/", "file_map": { "50": { "source": "unconstrained fn decode_ascii(ascii: u8) -> u8 {\n if ascii < 58 {\n ascii - 48\n } else if ascii < 71 {\n ascii - 55\n } else {\n ascii - 87\n }\n}\n\nunconstrained fn decode_hex(s: str) -> [u8; M] {\n let mut result: [u8; M] = [0; M];\n let as_bytes = s.as_bytes();\n for i in 0..N {\n if i % 2 != 0 {\n continue;\n }\n result[i / 2] = decode_ascii(as_bytes[i]) * 16 + decode_ascii(as_bytes[i + 1]);\n }\n result\n}\n\nunconstrained fn cipher(plaintext: [u8; 12], iv: [u8; 16], key: [u8; 16]) -> [u8; 16] {\n let result = std::aes128::aes128_encrypt(plaintext, iv, key);\n result\n}\n\nfn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {\n let result: [u8; 16] =\n std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());\n\n // Safety: testing context\n let output_bytes: [u8; 16] = unsafe { decode_hex(output) };\n assert(result == output_bytes);\n\n // Safety: testing context\n let unconstrained_result = unsafe { cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()) };\n assert(unconstrained_result == output_bytes);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 00afc0e206a..b5b613a6fad 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -68,8 +68,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZfdThsxEIXfJde58Hj8y6sghAIsVaQooDSpVKG8e+fEZwK9aAXmJt+X7M6J1ztred9WT8vD6cf9dv/88nN1c/u2ejhsd7vtj/vdy+PmuH3Z269vq4APKQZZG4WMpJKJzGQhK9lWNxHsgzWQQkZSyURm0vIUrGQj+2ALpJCRVDKRmWRes7wENrIP9kAKGUklE5nJQjKvM6+PvBgCKaTlZVDJRGaykJVsZB+UQArJvGg5BcxkISvZyD6ogRQykkoyT5mnzFPmKfOUeYl5iXnJzqvGbL830PI7qCT6JkAy5dJpFxEX9JpA1CW5oCpCikt1aS6dgp4bIi5IVoi6JJfsUlyQjHuH3hvSKei+IeISXdQFybhFaMEhxQXJmC104ZBOQR8OEZfooi5IxiSjGYcUl+rSXJBsd0LRkUPEJbro5WYpmvLCTBayko3sgxJIDKhDsktxsdIYIM2lU2JwEZfooi7JxXPQwFEgfjJaN0ZIcskuNoyokOrSXDAMuxmaPBAtPCS64BybcUU3D8F/VUhyQTImITeXTkFnDxEXVGFa0MdDikt1aRT0qOIC0aNDsktxwfIYzuf1ytfw++NhWbCEf1jUbal/3RyW/XF1sz/tduvVr83udDnp5+tmf+Fxc7CjFrnsn4wW+LzdLbDz+r06/Lu0hcbiFvVanj9fj9kc9dom6mvzwbdcJ+q7Kut7lpn6Ury+zYzfVhDW2xIyUW+dzXpr7Yn6FHz8SWbq7dHw/8/te/Vl5vqTZh9/KjP1MV7r6/fqc5ypr97/qU3Vl3atn5q/fJ2/lr53/XP1otf+m+mfgv3Bpb5M9Z/t5DzANnMfVoDPB3R/gmy3V74eYHvG9wDRmQCp7yPI3x3Bvy4hpv9Mgm1sfRaj1K8PIfsAysxDLMGbUGTmIZLrQ2AvNjP10ZtYdOYhvK4B7e8l6M6+bR63h7/e1M7IOWw3D7uFX59P+8cPR4+/X/2Iv+m9Hl4el6fTYUHS++uefdxqa+sU+p3tKuyb2HIqKds3bPJuo21po+AgXkBuk+3Tk8S7M4b2Bw==", + "bytecode": "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", + "debug_symbols": "pZfdThsxEIXfJde58Hj8y6sghAIsVaQooDSpVKG8e+fEZwK9aAXmJt+X7M6J1ztred9WT8vD6cf9dv/88nN1c/u2ejhsd7vtj/vdy+PmuH3Z269vq4APKQZZG4WMpJKJzGQhK9lWNxHsgzWQQkZSyURm0vIUrGQj+2ALpJCRVDKRmWRes7wENrIP9kAKGUklE5nJQjKvM6+PvBgCKaTlZVDJRGaykJVsZB+UQArJvGg5BcxkISvZyD6ogRQykkoyT5mnzFPmKfOUeYl5iXnJzqvGbL830PI7qCT6JkAy5dJpAhGX6IJmi5Dkkl3QbwqpLs2lU9BzQ8QluiAZ9wV9NyS7FJfqgmRMNprvIui+IeISXdQluSAZc4MeHFJdkIzpQhteBH04RFyii7okFyRjltGNQ6pLc+lDFB05RFyii15ulqIpL8xkISvZyD4ogcSAOiS7FBcrjQHSXDolBhdxiS7qklw8Bw0cBeIno3VjhCSX7GLDiAqpLs0Fw7Dbo8kD0cJDogvOsfuk6OYh+K8KSS5IxiTk5tIp6Owh4oIqTAv6eEhxqS6Ngh5VXCB6dEh2KS5YHsP5vF75Gn5/PCwLlvAPi7ot9a+bw7I/rm72p91uvfq12Z0uJ/183ewvPG4OdtQil/2T0QKft7sFdl6/V4d/l7bQWNyiXsvz5+sxm6Ne20R9bT74lutEfVdlfc8yU1+K17eZ8dsKwnpbQibqrbNZb609UZ+Cjz/JTL09Gv7/uX2vvsxcfxK9jn/m/5Nmr09lpj7Ga339Xn2OM/XVn5/UpupLu9ZPzX++zl9L37v+qfqCHcOlvkz1n+3kPMA2cx9WgM8HdH+CbLdXvh5ge8b3ANGZAKnvI8jfHcG/LiGm/0yCbWx9FqPUrw8h+wDKzEMowZtIZOYhkGsT24vNTH30RUh05iG6PsPt7yXkzr5tHreHv97Uzsg5bDcPu4Vfn0/7xw9Hj79f/Yi/6b0eXh6Xp9NhQdL765593Gpr6xT6ne0q7JvYcigp2zds8m6jbYSj4CBeQG6T7dyTxLszhvYH", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_0.snap index 3b7c4e02bbf..89b3b6c5057 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_0.snap @@ -68,8 +68,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZfdTioxFIXfhWsu2u7++irGGNTRkBAkCCc5Mbz72Wu6NugFJ1pu/D6YWZtOZ0/tfC5epqfj2+N6+/r+sbi7/1w87debzfrtcfP+vDqs37f67efC4Y/PCr9UejKQQkYykZksZF3cBbB1Fkd6MpBCRjKRWk/AQlaydVZHejKQQkYykaxXtV4CK9k6myM9GUghI5nITLJeY73W6wXnSE8GUsheL3g9L4P6fQH1+wgmMpOFrGTrDI70pP5OBYWMZCIzWchKtk5xpCdZT7ROAxOJ++0ghRKDiZigRzwkmWQTpAKkmjRKcibeJJiICSoLJJlkk2JSTVAZczP39CzeJJiISTRJJqiMWzW39izVBJVx99DdXbxJMBGTaJJMUBk3HU3epZo0Cvq8CyrjTqDTu4hJNEm9idDsMwtZydaJZp/pyTBTHEbWINmkmOB5dpBGQed28SbBREyiSTKxOmjY4CF2Mlo1BEgyySY6jCCQatIoaNiQIFYQLdtFKBHnZIg3wW/hktGaXVC5QhoFjdjFmwQTpDAtaLsuxaSaNApaSnCBaKku2aSYYHlzp9NyYWvx42E/TViKvyzOumTvVvtpe1jcbY+bzXLxZ7U5zid97FbbmYfVXo9qyWn7otSCr+vNBDstL2l3PVpdZbgGOcfTz/OYzZ6XOpAv1QZfUxnINxHmW/LX8vF6Xp8v5vUBG8iL2PyJtIF8dJn56NvI9WfLt1pHxp9s/rSVb8vnkfmLkuz6Yx7Jh3DOl9vyKYzki/V/rEP5XM/5oflL5/mr8bbrH8t7OffvyPOfsT+Y8zmN5HVHZgV0U/ZlBfh5gWZPkO7a8u8L6N7vUsDLSAFfLiNIt47g2iWE/9xFrxtUm0Xde/5+CMkGkPPITXTWhN6Hkfz5IdAXlJF8sCb2MvJP8LwG1O9L0IN+Wj2v99/euE6os1+vnjYTP74et89fjh7+7uyIvbHt9u/P08txP6HS5bVN/9xLacvo3IPuKvST1+XUx6SfsF+7Dy0tZT6IXdt9dF7PlYcThvYP", + "bytecode": "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", + "debug_symbols": "pZfdTioxFIXfhWsu2u7++irGGNTxhIQgQTjJieHdz17TtUEvMFpu/D5g1p5OZ0/tfCxepqfjn8f19vXtfXF3/7F42q83m/Wfx83b8+qwftvqtx8Lhz8+K/xS6clAChnJRGaykHVxF8DWWRzpyUAKGclEaj0BC1nJ1lkd6clAChnJRLJe1XoJrGTrbI70ZCCFjGQiM8l6jfVarxecIz0ZSCF7veD1uAzq9wXU7yOYyEwWspKtMzjSk3qeCgoZyURmspCVbJ3iSE+ynmidBiYS99tBCiWiQzxETKIJmiRAskkx0fN7gTRKcibeJJiISTRBZVx3yibFpJo0ytzTmPS5qWcJJmISTZJJNkFl3Cv0dpdGQXd73D60d5dgIibRJJlkE1TGLKPLuzQK+ryLNwkmYhJNUm8iNPvMQlaydaLZZ3oyzBSHkTVINikmeJ4dpFHQuV28STARk2iSTKwOGjZ4iB2MVg0BkkyyiQ4jCKSaNAoaNiSIFUTLdhFKxDEZ4k1wLlwyWrMLKldIo6ARu3iTYIIUpgVt16WYVJNGQUsJLhAt1SWbFBMsb+50Wi5sLX487KcJS/GnxVmX7N1qP20Pi7vtcbNZLv6uNsf5oPfdajvzsNrrr1py2r4oteDrejPBTstL2l2PVlcZrkHO8fTzPGaz56UO5Eu1wddUBvJNhPmW/LV8vJ7X54t5fcAG8iI2fyJtIB9dZj76NnL92fKt1pHxJ5s/beXb8nlk/qKX8/WPnD9KsnzMI/kQzvlyWz6FkXyx5yfWoXyu5/zQ/Kfz/NV42/Vfz3/Tvxk7hjmf08j6oTsyK6Cbsk8rwM8LNHuCdNeWf19A936XAl5GCvhyGUG6dQTXLiF8cxe9blBtFnXv+fshJBtAziM30VkTeR9G8ucm1heUkXywRcjLyD/B8zNcvy4hD/pp9bzef3njOqHOfr162kz8+HrcPn/69fBvZ7/YG9tu//Y8vRz3EypdXtv0z72UtozOPeiuQj95XQ59TPoJ+7X70NJS5h+xa7uPzuux8nDC0P4D", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index bc9ebd76a91..388ea122395 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/aes128_encrypt/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -68,8 +68,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "rZjdbuIwEIXfJddc2B7/9lWqqqI0XSEhQCmstKp4950Tz4T2IlHW7A3nC2FOnPGJDXx17/3b9dfr/vhx+uyenr+6t2F/OOx/vR5Ou+1lfzryu1+dwYsNsXuyG9YkmkVL1WhEragTJVHfPTloEI2iSTSLlqrJiFpR9iMoiXrRIBpFk2gWLVWzEbWi4pfZL0C9aBCNokk0i5aqxYhaUScqfkX8ivgV8SviV8SvVD9nqp+z/PkI5fMJyuc9qzOiVtSJkqgXDaJRlK9XoFm0VCXMlwFYBadACl4hKESFJODVx6PKArgqQ4NoFEUJAbJCEQgwwWiDVXAKpOAVgkJUSAJRfcbUoZ2InXWAoBAVsn4Yw0DPkbkKVgHDwDQgdhW8AgzRSSRvvBaiVyELZO0t0uZGIAWvgAcCfUPiKiQFPBPoD0I39hapq2AV4IO7QNAqwAdXR9R4pGRcfYMMKaAoAoJCVMDFebrI4gEsADxxBuAVgkJUwFPGwyHEtIJVcAp4Mh0gKxQBhLECrkUArxAUokJSgI8HFAGEsYJVcAqk4BXgjG4goBWSApzROuSR0A2kj9ANpK9CVEgCSJ9HN7AGVnAKpMDOHt1A6EZA6CpYBTzK6AYiViEqJIWsAB90AwtcBavgFKgGAZkbNYhGUQlKzqKlKtKWbrdNp/vB62Xoe2wH3zYI3jbO26E/Xrqn4/Vw2HS/t4fr+KHP8/Y46mU78Fm+/f74zsqGH/tDD7pt7tVmvjSbLMXZ0VQe1te7pPWUG+pT1sHnkBrqC/I61pdg5+r9fD2vH1LPC0hDPZH2j5+VhnpvotR7W1ruP2p9ybP9z/P1EUvdWB9DSz3vumrAG++3GVhvUPQOnHFxxmChA9Zizakj4O82c/eAjemhJiwZrOvCssOaNiw58Pecu4OlJgeb7mMID49h9i6W4uDMNJvOpn/P07o25Ee7kB9tgnOPNmFpVQq6KtJ8oNfVx5ZV0WOvr6uajy31zk31s7sCdp45g6AzEGNLuTVuWlJck0HQBvDPsiYDpzNgiVoM0rQvp8cmILiW+unyPjfVxzzVNwVw6r/Pfq6e4kMBWipfFaBFgzUBWjRYE6Alg/8WoPkJWKq3NH0v+rmCvfDRdrcffvyVcoPTsN++HXo5/Lged9/OXv6c9Yz+FXMeTrv+/Tr0cLr/H8Mvz55/vfIa9sLf1PnI8mpmPY7wy+2ZCm2oZBxafNaEjTfp5Yah/QU=", + "bytecode": "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", + "debug_symbols": "rZhdbuM4EITvomc/sNn8zVUGQeAkysCA4QQee4FF4Ltvl9itZAeQoKHnJfUpUpeoZom0/Tm8js/Xn0+H09v7r+Hhx+fwfD4cj4efT8f3l/3l8H6S/34ODn8opuGBdqJZtajWpsmpkqpXZdUwPHhoVE2qWbWo1qbZqZKq+DGUVYNqVE2qWbWo1qbFqZKq+hXxi9CgGlWTalYtqrVpdaqk6lXVr6pfVb+qflX9qvrV5udd8/Mk1yeonM9QOR9EvVMlVa/KqkE1qiZVuV+FFtXalDFfDkAG3oANgkE0SAZZIZhPQBUBpKpAo2pSRQkDikFViDDBaCMZeAM2CAbRIBlkhWQ+U+rQTsSOPCAaJINiF2MY6Dky14AMMAxMA2LXIBjAEJ1E8qZ7IXoNikKx3iJtfgI2CAZ4IdA3JK5BNsA7gf4gdFNvkboGZAAfPAWC1gA+uDuiJiNlh5snABsEAxRN1ySDbICby/Mx4Y1xALxyBIgGySArIKbsAWTgDdgAryYDqgLC2IAMcK8AiAbJIBsUA/jIEzPC2IAMvAEbBINoAGd0AwltUAzgLOFl5JHRDaQvoBtIX4NsUBSwBgZ0A4tgAzYIBniv0Q2ErgEZeAPcC91AxBpkg2JQFbDANSADb8AtCMjcpFE1qWpQSlGtTZG2fLvtBtsPni7nccR28G2DkG3jY38eT5fh4XQ9HnfDP/vjdbro18f+NOllf5az0pnx9Coqhm+H4wi67b6q3XJpcUWLi+e5PG6vR6JbPZeO+lxs8CXmjvqKTE/1NdJSfViul/VD62UB6ahntv7Ju9JRH1zS+kC15/mT1dey2P+yXJ+w1E31KfbUy65rBrLxfpuB7QbVnsA7nxYMVjpAhJWqjUA+2yw9Azamu5qwZrCtC+sOW9qw5iCfc74ciLscKH+NId49hsWnWIuDd/Nsesp/nqdtbSj3dqHc2wTv723C2qoUbVXk5UBvq089q2Ignle1nvsHfHpo9SH11Hs/1y/uKn5lDqPNYEo95eT8vCT5LoNoDZCvdV0G3maAmHsM8ryv5/smIPqe+vn2oXTVpzLXdwV47n8oYame810BWivfFKBVgy0BWjXYEqA1g78WoN8m4FGO9i+H8/9+SrnB6XzYPx9HPXy7nl6+nb38+2Fn7KeYj/P7y/h6PY9w+vo9Rv78CPLtVdagR/mkLkckqxEFHBFOcuUd14JDwrUu7oLLjzcM7T8=", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 376eba4d04b..02e4ebbd9b8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+2azW7bOBDHqViyLduJ3aTtbrDAPsCeLEu2nMMCAbrYF9gHWMhyDOylXRQFWqBAoR6KXnor0L5uy5Qj/T0aJf0Ytj6UQCCKHP7mg+SIkhOYpgTuGrJ7I8hcuuv820qiyJqLht5USOZ3V4nd/RH09xSdjZleTf56ni1jwT9F+9PYMX3Gh5ge+POB4/xVNXzui4EryfExtv/Y1XGdkczQ9VN96uoxG+Nj/j3Oz/xMsP8IfLPlQdX0GUXdYxfLxyyWNFeKuup1GOqzF8SO9Nn1/uzrszNiD/TZS9pLQ2AHbJ4xdyqu6VXA9Bmzn38M0z9itmrnwIDpI3t4fGjfUexGgq0zoQ99wz7UMxL0SKxQkRUpsvqKLFrvU9OOH80HzxfaeTdgMQrBD66T/OExxXwTsbY/3NX68wzG8PzaE9p47Pi+wPj4eq7Hgr+K/CXPq9qHYH+5dT33nD8Tyj/SOcrGK4V2XK+RadYTjo2gH+VzYK5c3Z4Jpqa9D/i+HPnxvd6XY8fDfSnlySMmj3X0mdr+dFdpX+LZpCe03bQvw89gSWc87m+/Qz7s8OcB+PO8gxkZObdFHcy/gfnC1ens3aua8bgmbAmhT/M8YfW8BDtac1zt+z2Bvp4gz2N/LMhPQIZiNmPy0rMMx40hPnycjz1z4ni4Z1DnBPxHeazbErG2f9xV2jOTG2JHujB2Y8Ge2LRjpxifq2PBRyrUNwXdfdY3gz60n5ceu0efbOzeA5fLYR3H4VxKz4OIyT9yV+vDv4zJczbPB3GHDZiTUCbssKE0jc+/BftM6VklnVn5s2oHzBcddhqjs9/JHuk5iGNRNhJkB0b2PRTG20Lv+Zz10F1j016DmnnkFLjGtJ9Ljzr8MUZeo7RWpPNMCNwU/LuOT6XvX77+lCevba2aOPM9i/ojJv/U3eN6RX8uv9LOXV4ku7TYFctiu83Kgs+DgdiNPegv8nRdLrIy3yzTIl19d/3ZssjLIk+Siyy5ypLl99ZfLleb8qMR86vE3i5u00/Pin7V9OO5yJaBu6f8zeWJFzH5VyT78e+1q1POiQR9Vu7dDXJBx/WaIbSF1X5bXLXle1VbnnSPqraN1DeGPjyz2TJx9xgvZJEdEZN/6+5pToYwhsbPBP1Dpn/PbqENcxdn9YQ2krfz84Z47oq+a3/nutbJ+NjGbaO1c9u3YMr5lyq25hvp+44ef7GQvl/o8Vcb6fuFIv+Cf79Q5l8Rf+iHn0nfSPT4aSF9h1C0P5HOWorrfyG98yjyL6R3TsX9VRL/xE/8a/7UD7/+/jjzw8+Jf8fP/Nb769SP/Wvin3nhp3X87/qJT/2N9p6f+KyIf9+P/Vt6Z/rFNKU+k7n6r9Cud45Is885K6L+EbPVx7kG9ZE9PD7897tzwdaZ0MfPOOeCnnNBj8QKFVmRIquvyBoosoaKLM3Yxwdq10iRNT5QlqaPE0WW5jweH6hdJ4qsqSJLM+fMFFl3FFmniqxDzYVniqxD3UOaa0Izf91VZGnu7UNdqz/PhT8uR/88F34Z654iS3NNaOYJzbPJoa6v+x5Z0v8dHgmsgPmF8tL7tn1GUU76//F/D58YVhBEcMmwqMOAlPHoh3LO5XzTweW2pALHxw+Ni/V6dbHYzLN8W+62WXrbD40fAOfF/BJKNAAA", - "debug_symbols": "pdbdTupQEIbhe+kxB51Zf7O8FWMMajUkBAjCTnYM977X6vRF94GJwRO/r+A8EMq0fAwv09P57XGze92/D3f3H8PTcbPdbt4et/vn9Wmz37VHP4ax/5E83MlqkOJhHnUOHT3EQz2CR/RIHq6oK+qKuhJcCa4EV4IrwZXgSmiKtige5lHniKOHeKhHmCO1B0OL5EeuJFeSK8mV7Ep2JbuSmxJbRI/kkT2Kh3nUOUpTUgvxUI/gET2SR/YoHuZR5zBXzBVzxVwxV6wppUX2KB7mUeeoo4d4NMVatLnaInsUD/Ooc8g4LilL9hMz9hIokdJPT/9ajJlSKEapSxFZSuqg9hIokZIomVIoRqlL6efMi1CQM3JGzsgZOSNn5IxckAtyQS7IBbkgF+SCXJALsiEbsiEbsiEbsiEbsiEbckWuyBW5IlfkilyRK3JFrous40gRilICJVISJVMKxSjIgizIgizIgizIgizIgizIiqzIiqzIiqzIiqzIiqzIATkgB+SAHJADckAOyAE5IEfkiByRI3JEjsgROSJH5IickBMyO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDOu9g6DehkdLlcLmsBm5/j6fjNPW735f7YbtLHtbHaXca7nbn7XY1/Flvz/M/vR/WuzlP62N7tl0Rp91Lywa+brZTb5fV5/T4/WiyZTbV63D68bRIWcZF7Ib5UpdxG2959aC8eii3zGu9zt/y7tvdg/mcvpvP389blWW+arjOq/749a8fX7tg3/D+VfjitMvXLfMjZ79d9X45f8v5++3nVyKvX758//r8QztaP2+O//06vXTpuFk/bafl8PW8e/7y7OnvgWf4dXs47p+nl/Nx6tLnT9z2575/+ySND/2XSj+UuBKp/bBdHO7VwkotPVz6m/kH", + "debug_symbols": "pdbdTupQEIbhe+kxB51Zf7O8FWMMajUkBAjCTnYM977X6vRF94GJwRO/D3GeInRaPoaX6en89rjZve7fh7v7j+HpuNluN2+P2/3z+rTZ79pvP4ax/5A83MlqkOJhHnUOHT3EQz2CR/RIHq6oK+qKuhJcCa4EV4IrwZXgSmiKtige5lHniKOHeKhHmCO1X4YWyR+5klxJriRXsivZlexKbkpsET2SR/ZoSmphHnWO0pTcQjzUI3hEj+SRPYqHedQ5zBVzxVwxV8wVa4q1yB7FwzzqHHX0EI+m1Bb9/Rxb5iXLkrZk9ZRxpAilfz79FBgDJVK6qr1kSqEYpS5FZCmpg6GXQImURMmUQjFKXUr/6LwIBTkjZ+SMnJEzckbOyAW5IBfkglyQC3JBLsgFuSAbsiEbsiEbsiEbsiEbsiFX5IpckStyRa7IFbkiV+S6yDqOFKEoJVAiJVEypVCMgizIgizIgizIgizIgizIgqzIiqzIiqzIiqzIiqzIihyQA3JADsgBOSAH5IAckANyRI7IETkiR+SIHJEjckSOyAk5IbODyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jzDsZ+LxopXY6Xy2rgLvh4Ok5Tvwl+uS22m+VhfZx2p+Fud95uV8Of9fY8/9H7Yb2b87Q+tmfbxXLavbRs4OtmO/V2WX1Oj9+PJltmU70Opx9Pi5RlXMRumC91GbfxlqMH5eih3DIfhfkYb5nXej3+Lf99u/swn9N38+X7eau8/qrhOq/64+Nf3/52wb/h9atw4rXL3y3zI2dPu2r+cv6Wz/+371+JHL98OX/7/EN7tH7eHP/7knvp0nGzftpOy8PX8+75y7Onvwee4Uvy4bh/nl7Ox6lLn9+U24/7fvZJGh/6N53+sF1YRGp/2C4u92phpZYeLv3F/AM=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_0.snap index e9ba684dcf9..3d7eaeaebcb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_0.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1azW7TQBBe13YaO0kTKBTaigfgZsdOnN564EWcpJW4IIR4AD8TEpw4IfECHDlyQOIIEheQELjsOF8m4/A3CzmwUrTr3dlvfnZ2PNm1Z1bFs3XAno1Ac27r5M9KqoiViIJuK0RzxzYi+7wH476ishHjq4k/S/JJJOinKH8WWUyX9iFMB/jJvsW5V63wuS4GaqLjc+rxgW2jnxFN145T+8C2IzbHxfo7XJ/kUJCfePWsrh+Zrj7YR0mOxk8CfewxYYf62M3+6ehj54S9r489IV/vArbH1hljm6LPTT3Gz5j1+GAY/5jJqh2jPMaP5OH2oX1BtosFWUfCGOqGY8gnFvhIWIEiVqiI1VHEIn8fmk370XrweKEdFz1mowD04DxJH25TjDch67tr61qfzzCHx1df6OO24/sC7cN971zFPsU8MrIP6eCPxzyu6uJP5zy2KuOfSTFUEf+C8GM3+M27p+cEPysJv+9G/iafGLjx/8Y/D9zgN/4zdII/XhD+yI39G/xrbvCbvPi6G/yC8A/drG+zv264kX9G+Ded4GeN/Y/c2Cch/Ftu7DMl/Ntu5F9SjnhsVoXn1yfQr5e7ZPnP5tfEP2ayusqvT5g83D48vz4VZB0JYzzHORX4nAp8JKxQEaujiLWviBUpYsWKWJq27+2oXH1FrMGOYmnqeKCIpbmOwx2Va6SIdU0RSzPmXFfEOlTEuqGItaux8KYi1q7uIU2f0IxfR4pYmnt7V331f17472L0/7zw17BuKWJp+oRmnNDMTXbVv247wHJ9hy6d5SviT6SzfKOHn7q7J50lju9CU+kcX9E2CZ2lSN9E1OvxBPrrH91thWblrzg3hHGkfwaYT227jrVDRle3+R1ez41tmzs8+j+Kd3jIk2TbY/TYRp2p77mtpTs8/I7BF/q23eEFP4HlAc0eoyf5Oi30QYs+L0CfLy2YoZHvQcMWzJeA6Vkh6KzBr1bz0SfqEsCY5rcHNZ8A5NhY42pd7wGM+QI9t/2BQI9nK2SzEaPH+DUU5vXBPnyeiz1D/81wzyDPAeiP9NiuS8j6Xtla2jODLbYjXmi7viCPZLtjZruhY9uNBNsNt9gO8yJqo+2o77XRs92xIM/v+vxIoJfO9ftmFScePrr/4LFhBQMdTxhQsLBFgIzNj1twcS6WsGWMnrMtOAPgJb04feCB9B9sXev6hmHyFyMPulGLDBj4kSZokeGtrWvHOvHWMaWEAOVqSwjeAabnyXIaoxNUSR4p2cC5SBsKtPyPE40Fwnz0L4713tbSRw6aAQcPQo3ZfPl/aNHHGNlHyVekpDEA3Ceg35V9Kn39itn3gHola7WyM34IZRj/kNF/ss88uSZ9zn9TzsuiTC+z8rKclMtlvij5Ohiz/hGtNv+yyGaLcb4o5pOszKZ/nX8+KYtFWaTpWZ5e5Onkb/NfTKbzxTchkou0fhz/iD+9fDvVahyTz7rs22eK35ye8EJG37UA9b6Ibbt5Twn8arrjLXReS32FIfQF1XpfVG3S+9UmPfGOq00ZaawHYyHj07fPaC/EIjlCRn9kAWhNujCH5o8E/l3Gf01uoQ9jF8fyhT6ir9dnaCc18R14a38YccWT4WMfl418x8W+Gs9m07PxPMmL5eJymWc/2ldfATd8RiZqNAAA", - "debug_symbols": "pZbdTioxFIXfZa65mLX776ucGIM6GhICZISTnBje/bSzVlEvMAZv+HYd95cWVtt5H56nx9Prw2b3sn8b7v68D4/zZrvdvD5s90/r42a/q399H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5hzYAtAPQohzbqcPtjJbbhV4MYhSTmEWeDWjxTY0QTXSiF4MYxerLjVksC63leCFEE53oxSBGMYlZlA/yQT7l2JRjU45NOTbl2JRjU45NObaW49II0cR2qo6taOfxcmanXuReFBXLubwU6IX1onmsFb4XoRfN7FqRepF7UVS0GLNoQnc+r4Z+/zwc52lq18+nC6leU4f1PO2Ow93utN2uhr/r7Wn5p7fDerfwuJ7r07qyafdcWYUvm+3UqvPqo3u83hqyekO5NIcfd9cDRe31SLmlP/jeH8O1fne9Pxeov5i79Jt96fe/7P9m/qmoPY+3rN5ZX71Lt/RbufRf/fa/WX3y/ddLn+b/89Xjsvx6IN0wf0MPbt3At/SPff514/+y/+v3f19H66fN/OX18NxM82b9uJ00fDntnj49Pf479Cf99fIw75+m59M8NdPHO2b9+GNxXFnGfbvW29CHlYWxDdGG2epTf39uk/kP", + "debug_symbols": "pZbNbuJAEITfxWcOrp7/vMoqikjiREgIkAMrrSLefWdcNSQ5EEXkwtfG9MfYLrf9PjxPj6fXh83uZf823P15Hx7nzXa7eX3Y7p/Wx81+V799H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5h24A6A5Ai3JsU4e3M1puF3oxiFFMYhY5G9DimxohmujE6suNQYxi9ZXGLJaF1nK8EKKJTvRiEKOYxCzKB/kgn3JsyrEpx6Ycm3JsyrEpx6Yc2zKYx1agF9aLNliXad1GsrUi9SL3oqhYRvNSoBfWi+ZxrfC9CL1oZt+K1Ivci6KiJZlFE/rzeTX0R9DDcZ6m9gT69EyqT6rDep52x+Fud9puV8Pf9fa0/OjtsN4tPK7nurce4rR7rqzCl812atV59dE9Xm8NWb2hXJrDj7vrTFF7nSq39Aff+2O41u+u9+cC9Rdzl36zL/3+l/3frD8VtefxlqN31o/epVv6fV99nYG39Fu5/P/Vq/fN2Uu+X/306fh/fvZwOX11pt2wfkMPfp0Bt/SPff11dvyy/+v1u69b66fN/OUN89xM82b9uJ20+XLaPX3ae/x36Hv6G+ph3j9Nz6d5aqaP19T68cfiuLKM+/Zm0DZ9WFkY2ybaZra619+f22L+Aw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index e9ba684dcf9..3d7eaeaebcb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1azW7TQBBe13YaO0kTKBTaigfgZsdOnN564EWcpJW4IIR4AD8TEpw4IfECHDlyQOIIEheQELjsOF8m4/A3CzmwUrTr3dlvfnZ2PNm1Z1bFs3XAno1Ac27r5M9KqoiViIJuK0RzxzYi+7wH476ishHjq4k/S/JJJOinKH8WWUyX9iFMB/jJvsW5V63wuS4GaqLjc+rxgW2jnxFN145T+8C2IzbHxfo7XJ/kUJCfePWsrh+Zrj7YR0mOxk8CfewxYYf62M3+6ehj54S9r489IV/vArbH1hljm6LPTT3Gz5j1+GAY/5jJqh2jPMaP5OH2oX1BtosFWUfCGOqGY8gnFvhIWIEiVqiI1VHEIn8fmk370XrweKEdFz1mowD04DxJH25TjDch67tr61qfzzCHx1df6OO24/sC7cN971zFPsU8MrIP6eCPxzyu6uJP5zy2KuOfSTFUEf+C8GM3+M27p+cEPysJv+9G/iafGLjx/8Y/D9zgN/4zdII/XhD+yI39G/xrbvCbvPi6G/yC8A/drG+zv264kX9G+Ded4GeN/Y/c2Cch/Ftu7DMl/Ntu5F9SjnhsVoXn1yfQr5e7ZPnP5tfEP2ayusqvT5g83D48vz4VZB0JYzzHORX4nAp8JKxQEaujiLWviBUpYsWKWJq27+2oXH1FrMGOYmnqeKCIpbmOwx2Va6SIdU0RSzPmXFfEOlTEuqGItaux8KYi1q7uIU2f0IxfR4pYmnt7V331f17472L0/7zw17BuKWJp+oRmnNDMTXbVv247wHJ9hy6d5SviT6SzfKOHn7q7J50lju9CU+kcX9E2CZ2lSN9E1OvxBPrrH91thWblrzg3hHGkfwaYT227jrVDRle3+R1ez41tmzs8+j+Kd3jIk2TbY/TYRp2p77mtpTs8/I7BF/q23eEFP4HlAc0eoyf5Oi30QYs+L0CfLy2YoZHvQcMWzJeA6Vkh6KzBr1bz0SfqEsCY5rcHNZ8A5NhY42pd7wGM+QI9t/2BQI9nK2SzEaPH+DUU5vXBPnyeiz1D/81wzyDPAeiP9NiuS8j6Xtla2jODLbYjXmi7viCPZLtjZruhY9uNBNsNt9gO8yJqo+2o77XRs92xIM/v+vxIoJfO9ftmFScePrr/4LFhBQMdTxhQsLBFgIzNj1twcS6WsGWMnrMtOAPgJb04feCB9B9sXev6hmHyFyMPulGLDBj4kSZokeGtrWvHOvHWMaWEAOVqSwjeAabnyXIaoxNUSR4p2cC5SBsKtPyPE40Fwnz0L4713tbSRw6aAQcPQo3ZfPl/aNHHGNlHyVekpDEA3Ceg35V9Kn39itn3gHola7WyM34IZRj/kNF/ss88uSZ9zn9TzsuiTC+z8rKclMtlvij5Ohiz/hGtNv+yyGaLcb4o5pOszKZ/nX8+KYtFWaTpWZ5e5Onkb/NfTKbzxTchkou0fhz/iD+9fDvVahyTz7rs22eK35ye8EJG37UA9b6Ibbt5Twn8arrjLXReS32FIfQF1XpfVG3S+9UmPfGOq00ZaawHYyHj07fPaC/EIjlCRn9kAWhNujCH5o8E/l3Gf01uoQ9jF8fyhT6ir9dnaCc18R14a38YccWT4WMfl418x8W+Gs9m07PxPMmL5eJymWc/2ldfATd8RiZqNAAA", - "debug_symbols": "pZbdTioxFIXfZa65mLX776ucGIM6GhICZISTnBje/bSzVlEvMAZv+HYd95cWVtt5H56nx9Prw2b3sn8b7v68D4/zZrvdvD5s90/r42a/q399H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5hzYAtAPQohzbqcPtjJbbhV4MYhSTmEWeDWjxTY0QTXSiF4MYxerLjVksC63leCFEE53oxSBGMYlZlA/yQT7l2JRjU45NOTbl2JRjU45NObaW49II0cR2qo6taOfxcmanXuReFBXLubwU6IX1onmsFb4XoRfN7FqRepF7UVS0GLNoQnc+r4Z+/zwc52lq18+nC6leU4f1PO2Ow93utN2uhr/r7Wn5p7fDerfwuJ7r07qyafdcWYUvm+3UqvPqo3u83hqyekO5NIcfd9cDRe31SLmlP/jeH8O1fne9Pxeov5i79Jt96fe/7P9m/qmoPY+3rN5ZX71Lt/RbufRf/fa/WX3y/ddLn+b/89Xjsvx6IN0wf0MPbt3At/SPff514/+y/+v3f19H66fN/OX18NxM82b9uJ00fDntnj49Pf479Cf99fIw75+m59M8NdPHO2b9+GNxXFnGfbvW29CHlYWxDdGG2epTf39uk/kP", + "debug_symbols": "pZbNbuJAEITfxWcOrp7/vMoqikjiREgIkAMrrSLefWdcNSQ5EEXkwtfG9MfYLrf9PjxPj6fXh83uZf823P15Hx7nzXa7eX3Y7p/Wx81+V799H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5h24A6A5Ai3JsU4e3M1puF3oxiFFMYhY5G9DimxohmujE6suNQYxi9ZXGLJaF1nK8EKKJTvRiEKOYxCzKB/kgn3JsyrEpx6Ycm3JsyrEpx6Yc2zKYx1agF9aLNliXad1GsrUi9SL3oqhYRvNSoBfWi+ZxrfC9CL1oZt+K1Ivci6KiJZlFE/rzeTX0R9DDcZ6m9gT69EyqT6rDep52x+Fud9puV8Pf9fa0/OjtsN4tPK7nurce4rR7rqzCl812atV59dE9Xm8NWb2hXJrDj7vrTFF7nSq39Aff+2O41u+u9+cC9Rdzl36zL/3+l/3frD8VtefxlqN31o/epVv6fV99nYG39Fu5/P/Vq/fN2Uu+X/306fh/fvZwOX11pt2wfkMPfp0Bt/SPff11dvyy/+v1u69b66fN/OUN89xM82b9uJ20+XLaPX3ae/x36Hv6G+ph3j9Nz6d5aqaP19T68cfiuLKM+/Zm0DZ9WFkY2ybaZra619+f22L+Aw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 376eba4d04b..02e4ebbd9b8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+2azW7bOBDHqViyLduJ3aTtbrDAPsCeLEu2nMMCAbrYF9gHWMhyDOylXRQFWqBAoR6KXnor0L5uy5Qj/T0aJf0Ytj6UQCCKHP7mg+SIkhOYpgTuGrJ7I8hcuuv820qiyJqLht5USOZ3V4nd/RH09xSdjZleTf56ni1jwT9F+9PYMX3Gh5ge+POB4/xVNXzui4EryfExtv/Y1XGdkczQ9VN96uoxG+Nj/j3Oz/xMsP8IfLPlQdX0GUXdYxfLxyyWNFeKuup1GOqzF8SO9Nn1/uzrszNiD/TZS9pLQ2AHbJ4xdyqu6VXA9Bmzn38M0z9itmrnwIDpI3t4fGjfUexGgq0zoQ99wz7UMxL0SKxQkRUpsvqKLFrvU9OOH80HzxfaeTdgMQrBD66T/OExxXwTsbY/3NX68wzG8PzaE9p47Pi+wPj4eq7Hgr+K/CXPq9qHYH+5dT33nD8Tyj/SOcrGK4V2XK+RadYTjo2gH+VzYK5c3Z4Jpqa9D/i+HPnxvd6XY8fDfSnlySMmj3X0mdr+dFdpX+LZpCe03bQvw89gSWc87m+/Qz7s8OcB+PO8gxkZObdFHcy/gfnC1ens3aua8bgmbAmhT/M8YfW8BDtac1zt+z2Bvp4gz2N/LMhPQIZiNmPy0rMMx40hPnycjz1z4ni4Z1DnBPxHeazbErG2f9xV2jOTG2JHujB2Y8Ge2LRjpxifq2PBRyrUNwXdfdY3gz60n5ceu0efbOzeA5fLYR3H4VxKz4OIyT9yV+vDv4zJczbPB3GHDZiTUCbssKE0jc+/BftM6VklnVn5s2oHzBcddhqjs9/JHuk5iGNRNhJkB0b2PRTG20Lv+Zz10F1j016DmnnkFLjGtJ9Ljzr8MUZeo7RWpPNMCNwU/LuOT6XvX77+lCevba2aOPM9i/ojJv/U3eN6RX8uv9LOXV4ku7TYFctiu83Kgs+DgdiNPegv8nRdLrIy3yzTIl19d/3ZssjLIk+Siyy5ypLl99ZfLleb8qMR86vE3i5u00/Pin7V9OO5yJaBu6f8zeWJFzH5VyT78e+1q1POiQR9Vu7dDXJBx/WaIbSF1X5bXLXle1VbnnSPqraN1DeGPjyz2TJx9xgvZJEdEZN/6+5pToYwhsbPBP1Dpn/PbqENcxdn9YQ2krfz84Z47oq+a3/nutbJ+NjGbaO1c9u3YMr5lyq25hvp+44ef7GQvl/o8Vcb6fuFIv+Cf79Q5l8Rf+iHn0nfSPT4aSF9h1C0P5HOWorrfyG98yjyL6R3TsX9VRL/xE/8a/7UD7/+/jjzw8+Jf8fP/Nb769SP/Wvin3nhp3X87/qJT/2N9p6f+KyIf9+P/Vt6Z/rFNKU+k7n6r9Cud45Is885K6L+EbPVx7kG9ZE9PD7897tzwdaZ0MfPOOeCnnNBj8QKFVmRIquvyBoosoaKLM3Yxwdq10iRNT5QlqaPE0WW5jweH6hdJ4qsqSJLM+fMFFl3FFmniqxDzYVniqxD3UOaa0Izf91VZGnu7UNdqz/PhT8uR/88F34Z654iS3NNaOYJzbPJoa6v+x5Z0v8dHgmsgPmF8tL7tn1GUU76//F/D58YVhBEcMmwqMOAlPHoh3LO5XzTweW2pALHxw+Ni/V6dbHYzLN8W+62WXrbD40fAOfF/BJKNAAA", - "debug_symbols": "pdbdTupQEIbhe+kxB51Zf7O8FWMMajUkBAjCTnYM977X6vRF94GJwRO/r+A8EMq0fAwv09P57XGze92/D3f3H8PTcbPdbt4et/vn9Wmz37VHP4ax/5E83MlqkOJhHnUOHT3EQz2CR/RIHq6oK+qKuhJcCa4EV4IrwZXgSmiKtige5lHniKOHeKhHmCO1B0OL5EeuJFeSK8mV7Ep2JbuSmxJbRI/kkT2Kh3nUOUpTUgvxUI/gET2SR/YoHuZR5zBXzBVzxVwxV6wppUX2KB7mUeeoo4d4NMVatLnaInsUD/Ooc8g4LilL9hMz9hIokdJPT/9ajJlSKEapSxFZSuqg9hIokZIomVIoRqlL6efMi1CQM3JGzsgZOSNn5IxckAtyQS7IBbkgF+SCXJALsiEbsiEbsiEbsiEbsiEbckWuyBW5IlfkilyRK3JFrous40gRilICJVISJVMKxSjIgizIgizIgizIgizIgizIiqzIiqzIiqzIiqzIiqzIATkgB+SAHJADckAOyAE5IEfkiByRI3JEjsgROSJH5IickBMyO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDOu9g6DehkdLlcLmsBm5/j6fjNPW735f7YbtLHtbHaXca7nbn7XY1/Flvz/M/vR/WuzlP62N7tl0Rp91Lywa+brZTb5fV5/T4/WiyZTbV63D68bRIWcZF7Ib5UpdxG2959aC8eii3zGu9zt/y7tvdg/mcvpvP389blWW+arjOq/749a8fX7tg3/D+VfjitMvXLfMjZ79d9X45f8v5++3nVyKvX758//r8QztaP2+O//06vXTpuFk/bafl8PW8e/7y7OnvgWf4dXs47p+nl/Nx6tLnT9z2575/+ySND/2XSj+UuBKp/bBdHO7VwkotPVz6m/kH", + "debug_symbols": "pdbdTupQEIbhe+kxB51Zf7O8FWMMajUkBAjCTnYM977X6vRF94GJwRO/D3GeInRaPoaX6en89rjZve7fh7v7j+HpuNluN2+P2/3z+rTZ79pvP4ax/5A83MlqkOJhHnUOHT3EQz2CR/RIHq6oK+qKuhJcCa4EV4IrwZXgSmiKtige5lHniKOHeKhHmCO1X4YWyR+5klxJriRXsivZlexKbkpsET2SR/ZoSmphHnWO0pTcQjzUI3hEj+SRPYqHedQ5zBVzxVwxV8wVa4q1yB7FwzzqHHX0EI+m1Bb9/Rxb5iXLkrZk9ZRxpAilfz79FBgDJVK6qr1kSqEYpS5FZCmpg6GXQImURMmUQjFKXUr/6LwIBTkjZ+SMnJEzckbOyAW5IBfkglyQC3JBLsgFuSAbsiEbsiEbsiEbsiEbsiFX5IpckStyRa7IFbkiV+S6yDqOFKEoJVAiJVEypVCMgizIgizIgizIgizIgizIgqzIiqzIiqzIiqzIiqzIihyQA3JADsgBOSAH5IAckANyRI7IETkiR+SIHJEjckSOyAk5IbODyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jsoLKDyg4qO6jzDsZ+LxopXY6Xy2rgLvh4Ok5Tvwl+uS22m+VhfZx2p+Fud95uV8Of9fY8/9H7Yb2b87Q+tmfbxXLavbRs4OtmO/V2WX1Oj9+PJltmU70Opx9Pi5RlXMRumC91GbfxlqMH5eih3DIfhfkYb5nXej3+Lf99u/swn9N38+X7eau8/qrhOq/64+Nf3/52wb/h9atw4rXL3y3zI2dPu2r+cv6Wz/+371+JHL98OX/7/EN7tH7eHP/7knvp0nGzftpOy8PX8+75y7Onvwee4Uvy4bh/nl7Ox6lLn9+U24/7fvZJGh/6N53+sF1YRGp/2C4u92phpZYeLv3F/AM=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_0.snap index e9ba684dcf9..3d7eaeaebcb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_0.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1azW7TQBBe13YaO0kTKBTaigfgZsdOnN564EWcpJW4IIR4AD8TEpw4IfECHDlyQOIIEheQELjsOF8m4/A3CzmwUrTr3dlvfnZ2PNm1Z1bFs3XAno1Ac27r5M9KqoiViIJuK0RzxzYi+7wH476ishHjq4k/S/JJJOinKH8WWUyX9iFMB/jJvsW5V63wuS4GaqLjc+rxgW2jnxFN145T+8C2IzbHxfo7XJ/kUJCfePWsrh+Zrj7YR0mOxk8CfewxYYf62M3+6ehj54S9r489IV/vArbH1hljm6LPTT3Gz5j1+GAY/5jJqh2jPMaP5OH2oX1BtosFWUfCGOqGY8gnFvhIWIEiVqiI1VHEIn8fmk370XrweKEdFz1mowD04DxJH25TjDch67tr61qfzzCHx1df6OO24/sC7cN971zFPsU8MrIP6eCPxzyu6uJP5zy2KuOfSTFUEf+C8GM3+M27p+cEPysJv+9G/iafGLjx/8Y/D9zgN/4zdII/XhD+yI39G/xrbvCbvPi6G/yC8A/drG+zv264kX9G+Ded4GeN/Y/c2Cch/Ftu7DMl/Ntu5F9SjnhsVoXn1yfQr5e7ZPnP5tfEP2ayusqvT5g83D48vz4VZB0JYzzHORX4nAp8JKxQEaujiLWviBUpYsWKWJq27+2oXH1FrMGOYmnqeKCIpbmOwx2Va6SIdU0RSzPmXFfEOlTEuqGItaux8KYi1q7uIU2f0IxfR4pYmnt7V331f17472L0/7zw17BuKWJp+oRmnNDMTXbVv247wHJ9hy6d5SviT6SzfKOHn7q7J50lju9CU+kcX9E2CZ2lSN9E1OvxBPrrH91thWblrzg3hHGkfwaYT227jrVDRle3+R1ez41tmzs8+j+Kd3jIk2TbY/TYRp2p77mtpTs8/I7BF/q23eEFP4HlAc0eoyf5Oi30QYs+L0CfLy2YoZHvQcMWzJeA6Vkh6KzBr1bz0SfqEsCY5rcHNZ8A5NhY42pd7wGM+QI9t/2BQI9nK2SzEaPH+DUU5vXBPnyeiz1D/81wzyDPAeiP9NiuS8j6Xtla2jODLbYjXmi7viCPZLtjZruhY9uNBNsNt9gO8yJqo+2o77XRs92xIM/v+vxIoJfO9ftmFScePrr/4LFhBQMdTxhQsLBFgIzNj1twcS6WsGWMnrMtOAPgJb04feCB9B9sXev6hmHyFyMPulGLDBj4kSZokeGtrWvHOvHWMaWEAOVqSwjeAabnyXIaoxNUSR4p2cC5SBsKtPyPE40Fwnz0L4713tbSRw6aAQcPQo3ZfPl/aNHHGNlHyVekpDEA3Ceg35V9Kn39itn3gHola7WyM34IZRj/kNF/ss88uSZ9zn9TzsuiTC+z8rKclMtlvij5Ohiz/hGtNv+yyGaLcb4o5pOszKZ/nX8+KYtFWaTpWZ5e5Onkb/NfTKbzxTchkou0fhz/iD+9fDvVahyTz7rs22eK35ye8EJG37UA9b6Ibbt5Twn8arrjLXReS32FIfQF1XpfVG3S+9UmPfGOq00ZaawHYyHj07fPaC/EIjlCRn9kAWhNujCH5o8E/l3Gf01uoQ9jF8fyhT6ir9dnaCc18R14a38YccWT4WMfl418x8W+Gs9m07PxPMmL5eJymWc/2ldfATd8RiZqNAAA", - "debug_symbols": "pZbdTioxFIXfZa65mLX776ucGIM6GhICZISTnBje/bSzVlEvMAZv+HYd95cWVtt5H56nx9Prw2b3sn8b7v68D4/zZrvdvD5s90/r42a/q399H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5hzYAtAPQohzbqcPtjJbbhV4MYhSTmEWeDWjxTY0QTXSiF4MYxerLjVksC63leCFEE53oxSBGMYlZlA/yQT7l2JRjU45NOTbl2JRjU45NObaW49II0cR2qo6taOfxcmanXuReFBXLubwU6IX1onmsFb4XoRfN7FqRepF7UVS0GLNoQnc+r4Z+/zwc52lq18+nC6leU4f1PO2Ow93utN2uhr/r7Wn5p7fDerfwuJ7r07qyafdcWYUvm+3UqvPqo3u83hqyekO5NIcfd9cDRe31SLmlP/jeH8O1fne9Pxeov5i79Jt96fe/7P9m/qmoPY+3rN5ZX71Lt/RbufRf/fa/WX3y/ddLn+b/89Xjsvx6IN0wf0MPbt3At/SPff514/+y/+v3f19H66fN/OX18NxM82b9uJ00fDntnj49Pf479Cf99fIw75+m59M8NdPHO2b9+GNxXFnGfbvW29CHlYWxDdGG2epTf39uk/kP", + "debug_symbols": "pZbNbuJAEITfxWcOrp7/vMoqikjiREgIkAMrrSLefWdcNSQ5EEXkwtfG9MfYLrf9PjxPj6fXh83uZf823P15Hx7nzXa7eX3Y7p/Wx81+V799H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5h24A6A5Ai3JsU4e3M1puF3oxiFFMYhY5G9DimxohmujE6suNQYxi9ZXGLJaF1nK8EKKJTvRiEKOYxCzKB/kgn3JsyrEpx6Ycm3JsyrEpx6Yc2zKYx1agF9aLNliXad1GsrUi9SL3oqhYRvNSoBfWi+ZxrfC9CL1oZt+K1Ivci6KiJZlFE/rzeTX0R9DDcZ6m9gT69EyqT6rDep52x+Fud9puV8Pf9fa0/OjtsN4tPK7nurce4rR7rqzCl812atV59dE9Xm8NWb2hXJrDj7vrTFF7nSq39Aff+2O41u+u9+cC9Rdzl36zL/3+l/3frD8VtefxlqN31o/epVv6fV99nYG39Fu5/P/Vq/fN2Uu+X/306fh/fvZwOX11pt2wfkMPfp0Bt/SPff11dvyy/+v1u69b66fN/OUN89xM82b9uJ20+XLaPX3ae/x36Hv6G+ph3j9Nz6d5aqaP19T68cfiuLKM+/Zm0DZ9WFkY2ybaZra619+f22L+Aw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index e9ba684dcf9..3d7eaeaebcb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dedup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1azW7TQBBe13YaO0kTKBTaigfgZsdOnN564EWcpJW4IIR4AD8TEpw4IfECHDlyQOIIEheQELjsOF8m4/A3CzmwUrTr3dlvfnZ2PNm1Z1bFs3XAno1Ac27r5M9KqoiViIJuK0RzxzYi+7wH476ishHjq4k/S/JJJOinKH8WWUyX9iFMB/jJvsW5V63wuS4GaqLjc+rxgW2jnxFN145T+8C2IzbHxfo7XJ/kUJCfePWsrh+Zrj7YR0mOxk8CfewxYYf62M3+6ehj54S9r489IV/vArbH1hljm6LPTT3Gz5j1+GAY/5jJqh2jPMaP5OH2oX1BtosFWUfCGOqGY8gnFvhIWIEiVqiI1VHEIn8fmk370XrweKEdFz1mowD04DxJH25TjDch67tr61qfzzCHx1df6OO24/sC7cN971zFPsU8MrIP6eCPxzyu6uJP5zy2KuOfSTFUEf+C8GM3+M27p+cEPysJv+9G/iafGLjx/8Y/D9zgN/4zdII/XhD+yI39G/xrbvCbvPi6G/yC8A/drG+zv264kX9G+Ded4GeN/Y/c2Cch/Ftu7DMl/Ntu5F9SjnhsVoXn1yfQr5e7ZPnP5tfEP2ayusqvT5g83D48vz4VZB0JYzzHORX4nAp8JKxQEaujiLWviBUpYsWKWJq27+2oXH1FrMGOYmnqeKCIpbmOwx2Va6SIdU0RSzPmXFfEOlTEuqGItaux8KYi1q7uIU2f0IxfR4pYmnt7V331f17472L0/7zw17BuKWJp+oRmnNDMTXbVv247wHJ9hy6d5SviT6SzfKOHn7q7J50lju9CU+kcX9E2CZ2lSN9E1OvxBPrrH91thWblrzg3hHGkfwaYT227jrVDRle3+R1ez41tmzs8+j+Kd3jIk2TbY/TYRp2p77mtpTs8/I7BF/q23eEFP4HlAc0eoyf5Oi30QYs+L0CfLy2YoZHvQcMWzJeA6Vkh6KzBr1bz0SfqEsCY5rcHNZ8A5NhY42pd7wGM+QI9t/2BQI9nK2SzEaPH+DUU5vXBPnyeiz1D/81wzyDPAeiP9NiuS8j6Xtla2jODLbYjXmi7viCPZLtjZruhY9uNBNsNt9gO8yJqo+2o77XRs92xIM/v+vxIoJfO9ftmFScePrr/4LFhBQMdTxhQsLBFgIzNj1twcS6WsGWMnrMtOAPgJb04feCB9B9sXev6hmHyFyMPulGLDBj4kSZokeGtrWvHOvHWMaWEAOVqSwjeAabnyXIaoxNUSR4p2cC5SBsKtPyPE40Fwnz0L4713tbSRw6aAQcPQo3ZfPl/aNHHGNlHyVekpDEA3Ceg35V9Kn39itn3gHola7WyM34IZRj/kNF/ss88uSZ9zn9TzsuiTC+z8rKclMtlvij5Ohiz/hGtNv+yyGaLcb4o5pOszKZ/nX8+KYtFWaTpWZ5e5Onkb/NfTKbzxTchkou0fhz/iD+9fDvVahyTz7rs22eK35ye8EJG37UA9b6Ibbt5Twn8arrjLXReS32FIfQF1XpfVG3S+9UmPfGOq00ZaawHYyHj07fPaC/EIjlCRn9kAWhNujCH5o8E/l3Gf01uoQ9jF8fyhT6ir9dnaCc18R14a38YccWT4WMfl418x8W+Gs9m07PxPMmL5eJymWc/2ldfATd8RiZqNAAA", - "debug_symbols": "pZbdTioxFIXfZa65mLX776ucGIM6GhICZISTnBje/bSzVlEvMAZv+HYd95cWVtt5H56nx9Prw2b3sn8b7v68D4/zZrvdvD5s90/r42a/q399H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5hzYAtAPQohzbqcPtjJbbhV4MYhSTmEWeDWjxTY0QTXSiF4MYxerLjVksC63leCFEE53oxSBGMYlZlA/yQT7l2JRjU45NOTbl2JRjU45NObaW49II0cR2qo6taOfxcmanXuReFBXLubwU6IX1onmsFb4XoRfN7FqRepF7UVS0GLNoQnc+r4Z+/zwc52lq18+nC6leU4f1PO2Ow93utN2uhr/r7Wn5p7fDerfwuJ7r07qyafdcWYUvm+3UqvPqo3u83hqyekO5NIcfd9cDRe31SLmlP/jeH8O1fne9Pxeov5i79Jt96fe/7P9m/qmoPY+3rN5ZX71Lt/RbufRf/fa/WX3y/ddLn+b/89Xjsvx6IN0wf0MPbt3At/SPff514/+y/+v3f19H66fN/OX18NxM82b9uJ00fDntnj49Pf479Cf99fIw75+m59M8NdPHO2b9+GNxXFnGfbvW29CHlYWxDdGG2epTf39uk/kP", + "debug_symbols": "pZbNbuJAEITfxWcOrp7/vMoqikjiREgIkAMrrSLefWdcNSQ5EEXkwtfG9MfYLrf9PjxPj6fXh83uZf823P15Hx7nzXa7eX3Y7p/Wx81+V799H8b2gTDcYTUgEonIRFlgIwHCCEd4ghajxWgxWowWR4ujxdHiaHG0uGqxikgkIhNlgR8JEEZUS6jwRCAikYhMlAVhJEAYQUugJdASaAm0BFoCLZGWSEukJdISaYm0RFoiLZGWSEuiJdGSaEm0JFoSLYmWREuiJdGSacm0ZFoyLZmWTEumJdOSacm0FFoKLYWWQkuhpdBSaCm0FFoKLRhHEaKJTvRiEKOYxCzKB/kgH+SDfJAP8kE+yAf5IJ/JZ/KZfCafyWfymXwmn8ln8jn5nHxOPiefk8/J5+Rz8jn5nHxePi+fl085h4IOJR2KOpR1KOxQ2qG4Q3mHAg8lHoo8lHko9FDqodhDuYeCDyUfij6UfSj8UPqh+EP5h24A6A5Ai3JsU4e3M1puF3oxiFFMYhY5G9DimxohmujE6suNQYxi9ZXGLJaF1nK8EKKJTvRiEKOYxCzKB/kgn3JsyrEpx6Ycm3JsyrEpx6Yc2zKYx1agF9aLNliXad1GsrUi9SL3oqhYRvNSoBfWi+ZxrfC9CL1oZt+K1Ivci6KiJZlFE/rzeTX0R9DDcZ6m9gT69EyqT6rDep52x+Fud9puV8Pf9fa0/OjtsN4tPK7nurce4rR7rqzCl812atV59dE9Xm8NWb2hXJrDj7vrTFF7nSq39Aff+2O41u+u9+cC9Rdzl36zL/3+l/3frD8VtefxlqN31o/epVv6fV99nYG39Fu5/P/Vq/fN2Uu+X/306fh/fvZwOX11pt2wfkMPfp0Bt/SPff11dvyy/+v1u69b66fN/OUN89xM82b9uJ20+XLaPX3ae/x36Hv6G+ph3j9Nz6d5aqaP19T68cfiuLKM+/Zm0DZ9WFkY2ybaZra619+f22L+Aw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: str) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 03c4b5bb4cf..9ed3b418195 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -69,7 +69,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(leaf: [u8; 32], path: [u8; 64], index: u32, root: [u8; 32]) {\n compute_root(leaf, path, index, root);\n}\n\nfn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {\n let mut current = leaf;\n let mut index = _index;\n\n for i in 0..2 {\n let mut hash_input = [0; 64];\n let offset = i * 32;\n let is_right = (index & 1) != 0;\n let a = if is_right { 32 } else { 0 };\n let b = if is_right { 0 } else { 32 };\n\n for j in 0..32 {\n hash_input[j + a] = current[j];\n hash_input[j + b] = path[offset + j];\n }\n\n current = std::hash::blake3(hash_input);\n index = index >> 1;\n }\n\n // Regression for issue #4258\n assert(root == current);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap index 03c4b5bb4cf..9ed3b418195 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap @@ -69,7 +69,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(leaf: [u8; 32], path: [u8; 64], index: u32, root: [u8; 32]) {\n compute_root(leaf, path, index, root);\n}\n\nfn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {\n let mut current = leaf;\n let mut index = _index;\n\n for i in 0..2 {\n let mut hash_input = [0; 64];\n let offset = i * 32;\n let is_right = (index & 1) != 0;\n let a = if is_right { 32 } else { 0 };\n let b = if is_right { 0 } else { 32 };\n\n for j in 0..32 {\n hash_input[j + a] = current[j];\n hash_input[j + b] = path[offset + j];\n }\n\n current = std::hash::blake3(hash_input);\n index = index >> 1;\n }\n\n // Regression for issue #4258\n assert(root == current);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 03c4b5bb4cf..9ed3b418195 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -69,7 +69,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(leaf: [u8; 32], path: [u8; 64], index: u32, root: [u8; 32]) {\n compute_root(leaf, path, index, root);\n}\n\nfn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) {\n let mut current = leaf;\n let mut index = _index;\n\n for i in 0..2 {\n let mut hash_input = [0; 64];\n let offset = i * 32;\n let is_right = (index & 1) != 0;\n let a = if is_right { 32 } else { 0 };\n let b = if is_right { 0 } else { 32 };\n\n for j in 0..32 {\n hash_input[j + a] = current[j];\n hash_input[j + b] = path[offset + j];\n }\n\n current = std::hash::blake3(hash_input);\n index = index >> 1;\n }\n\n // Regression for issue #4258\n assert(root == current);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 4fd489f9f99..852f18363b3 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -76,8 +76,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZbNbuMwDITfxeccrB/qp69SFEWaukUAIwncZIFFkXdf0p5xsocuuuol88k2x6RFKfrsXoeXy/vz/vB2/OgeHj+7l2k/jvv35/G42573x4Ne/ex6+3E1dg9uoyrQBM3QAq2z+r6HOqhf1GHsOA7QCBVogqq/Ny3QuqjvoQ7qoQEaoQJNUPh5+Hn4BfgF+AV9LqhGvR5N9bqYemiARqhAEzRDC7QuKj0UfoJ8BfkK8hXkK8hXkK8g34R8E/JNqD/BL6lfMhWo+mXTDFW/YloXzXq/mtr89QrFJtBmoDiCJwRCJAghETKhECqg4pNWB/VQWVKYW8tqmHtrhkKoC4S5vYKBI3hCIESCEBLBnKNBIVSA6wmO4AmBYM5iIIREyIRCqABr2QXMORl4QiCYczYQQiJkQiFUgDXvAm6ZvRA8IRAiQQiJkAmFgC4IaPOANg9o82Bt7opBJhRCBVirL+AInhAI9LG+djr7IfHhuaMth7mlZ4gEWyTOIBEywdaJTXGiYe4J5lyv103H/e35PA2DbW93G55ug6ftNBzO3cPhMo6b7td2vMwPfZy2h1nP20nvaiLD4VVVDd/242B03dyi+69Dc0Ssc26Nlm+Ha68jXpu9IV4XP+J1+TfEp8zaU+kb4nNg/Tm2vF/bnPWH3BKfAuOzb4pfv38uDfGxCuJjbclfJCFecsv8J8/6k7TUL4H1S2yKX98vvuX7iVvf71v6Rwr7R2rL+pO8fv/aVH/K6/y1xOuhiwXoueuugu8bVFagB7P0/wZ6vLsZuNBi4PItA/lpBl+V4P0/PoLv121Yj5n3Dk862O72018H4atZTfvtyzhg+HY57O7unn+feIcH6dN03A2vl2kwp9tpWn8eQwmb2Mcn/WPSkct540rWkZ0/Hi0131cbOntW74Zcn66W2h8=", + "bytecode": "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", + "debug_symbols": "pZZLbuMwEETvorUX4qf5yVWCIHAcJTAg2IZiDzAIfPfplqpkzyKDDLNxPYrqUpNs0vzsXoeXy/vz/vB2/OgeHj+7l2k/jvv35/G42573x4M+/ex6+3E1dg9uoyrQBM3QAq2z+r6HOqhf1KHt2A7QCBVogqq/Ny3QuqjvoQ7qoQEaoQJNUPh5+Hn4BfgF+AV9L6hGfR5N9bmYemiARqhAEzRDC7QuKj0UfoJ8BfkK8hXkK8hXkK8g34R8E/JNGH+CX1K/ZCpQ9cumGap+xbQumrW/mtr69QrFFtBWoDiCJwRCJAghETKhECqgYkqrg3qomVjuc23NkAmFUBcIc30FA0fwhECIBCEkgjlHg0KoANcTHMETAsGcxUAIiZAJ5pwMKsBqdgFH8IRAiARzzgaJkAmFUAFWvQu4ZflC8IRAiAQhJEImFALKIKDOA+o8oM6D1bkrBplQCBVgtb6AI3hCINDHCttpBYbEl+eSthzmmp4hEmyXOINEyATbKLbEiYa5J5hzvV43HQ+45/M0DHa+3Z14eg6ettNwOHcPh8s4brpf2/Eyv/Rx2h5mPW8n7dVEhsOrqhq+7cfB6Lq5Rfdfh+aIWOfcGi3fDtdaR7wWe0O87n7E6/5viE+ZY0+lb4jPgePPseX7WuYcf8gt8SkwPvum+HX+c2mIj1UQH2tL/iIJ8ZJb1j95jj9Jy/hljRffMn4JnD+JTd93a7xvqR9JeZ2/pu8X1p/Ulv0reV2/2vJ9vXUxAb143WXwfYPKDPRmlv7fQO93NwMXWgxcvmUgP83gqyF4/49J8P16DOs9897hSRvb3X766yZ8Natpv30ZBzTfLofdXe/594k9vEmfpuNueL1MgzndrtP68xhK2MQ+Pukfk7ZczhtXsrbs/vFoqfm+WtPZu9obcn26Wmp/AA==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap index 5e2f5204970..e8a3f33dcd7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap @@ -76,8 +76,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "tZZBbuMwDEXv4nUWpiRScq9SFIWbuoUBwwncZIBBkbsPafOn7SLFjAbd5D/FIiV9UbLfm+fh6fz6OM4vh7fm7v69eVrGaRpfH6fDvj+Nh1n/fW9a+6FOJexUyTW4Rtfkyq7S3EXT7Fpcu1VD27qSa3CNrsmVXcU1uxZXz0eeL6gmU83Dpponm7KruGqeYlpcu01j60quwTW6JlePT9q/M9X+Yhpcoyt7Px2XWoMMKAAdmkiBWwABNBvZsjhuw3ByZVe3gd0GcRvEbRW3VdxWcVvFbRW3VdxW8XxiczIfcwuwOZmjOQA0J9kac3Io1sfcLfaPLbvoOGQTLQLIgALoHKzGNiBAAERAAvC2wVZoq+ZVoxWWzSFaZYXWIAAiIAGsWslAABlQAJ2DldgGBLDMwSACEoABAsiAArDM6na0ot2AAAEQAQnAAMucDDKgACyzuWHlvAEBAiACEoABsm1ftCrfoAA6Byv8DQgQABGwlsHlsmtwozyelmGwC+XTFaMXz7FfhvnU3M3nado1v/rpvHZ6O/bzqqd+0ae6Y8P8rKoJX8ZpMLrsPqLb26E5eSwRXaP5azj9WLiWoMdrDVbE67H0eD2YFfGSYZ2Utmb5EevP6eb48nPx+hYhbEBXPu3A3yfoBA62Qf49gb6vPhJQrElglxJmwP87g1tLoPCNCfpShYuB8q0M35RxxC7oxVBzDCQiPoeq+OsxyqUiPnXs8amrmT8zdoBzzTGWgPUL16yfI9bPqSr+Oj6HGv+YruOHmmuIC+qHu5prlPPV/65q/ZKv+/c1/kFb/X5cvnz5XizTMvZP0+DNl/O8//T09PuIJ/hyPi6H/fB8XgbL9PH5rD/3Vr2xxAd9L2qLct5Rydqi9WHKu8jBmmRNrbTI5eFiU/sD", + "bytecode": "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", + "debug_symbols": "tZZBbuMwDEXv4nUWpiRScq9SFIWbuoUBwwncZIBBkbsPafOn7SLFjAbd5D/FIiV9UbLfm+fh6fz6OM4vh7fm7v69eVrGaRpfH6fDvj+Nh1n/fW9a+6FOJexUyTW4Rtfkyq7S3EXT7Fpcu1VD27qSa3CNrsmVXcU1uxZXz0eeL6gmU83Dpponm7KruGqeYlpcu01j60quwTW6JlePT9q/M9X+Yhpcoyt7Px2XWoMMKAAdmkiBWwABNBvZsjhuw3ByZVe3gd0GcRvEbRW3VdxWcVvFbRW3VdxW8XxiczIfcwuwOZmjOQA0J9kac3Io1sfcLfaPLbvoOGQTLQLIgALoHKzGNiBAAERAAvC2wVZoq+ZVoxVWaA0IEAARkABWrWQggAwogM7BSmwDAljmYBABCcAAAWRAAVhmdTta0W5AgACwzMkgARgggAwogM7ByjmYLVbPGwRABCQAA2TbvmhVvkEBdA5W+BsQIAAiYC2Dy2XX4EZ5PC3DYBfKpytGL55jvwzzqbmbz9O0a37103nt9Hbs51VP/aJPdceG+VlVE76M02B02X1Et7dDc/JYIrpG89dw+rFwLUGP1xqsiNdj6fF6MCviJcM6KW3N8iPWn9PN8eXn4vUtQtiArnzagb9P0AkcbIP8ewJ9X30koFiTwC5GzID/dwa3lkDhGxP0pQoXA+VbGb4p44hd0Iuh5hhIRHwOVfHXY5RLRXzq2ONTVzN/ZuwA55pjLAHrF65ZP1/jOdSsnyP841Q1Pl3jQ801xJKv/lWNX1B/3NVcw5yv+9d9Hf9BW/1+XL58+V4s0zL2T9PgzZfzvP/09PT7iCf4cj4uh/3wfF4Gy/Tx+aw/91a9scQHfS9qi3LeUcnaovVhyrvIwZpkTa20yOXhYlP7Aw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 5e2f5204970..e8a3f33dcd7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -76,8 +76,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "tZZBbuMwDEXv4nUWpiRScq9SFIWbuoUBwwncZIBBkbsPafOn7SLFjAbd5D/FIiV9UbLfm+fh6fz6OM4vh7fm7v69eVrGaRpfH6fDvj+Nh1n/fW9a+6FOJexUyTW4Rtfkyq7S3EXT7Fpcu1VD27qSa3CNrsmVXcU1uxZXz0eeL6gmU83Dpponm7KruGqeYlpcu01j60quwTW6JlePT9q/M9X+Yhpcoyt7Px2XWoMMKAAdmkiBWwABNBvZsjhuw3ByZVe3gd0GcRvEbRW3VdxWcVvFbRW3VdxW8XxiczIfcwuwOZmjOQA0J9kac3Io1sfcLfaPLbvoOGQTLQLIgALoHKzGNiBAAERAAvC2wVZoq+ZVoxWWzSFaZYXWIAAiIAGsWslAABlQAJ2DldgGBLDMwSACEoABAsiAArDM6na0ot2AAAEQAQnAAMucDDKgACyzuWHlvAEBAiACEoABsm1ftCrfoAA6Byv8DQgQABGwlsHlsmtwozyelmGwC+XTFaMXz7FfhvnU3M3nado1v/rpvHZ6O/bzqqd+0ae6Y8P8rKoJX8ZpMLrsPqLb26E5eSwRXaP5azj9WLiWoMdrDVbE67H0eD2YFfGSYZ2Utmb5EevP6eb48nPx+hYhbEBXPu3A3yfoBA62Qf49gb6vPhJQrElglxJmwP87g1tLoPCNCfpShYuB8q0M35RxxC7oxVBzDCQiPoeq+OsxyqUiPnXs8amrmT8zdoBzzTGWgPUL16yfI9bPqSr+Oj6HGv+YruOHmmuIC+qHu5prlPPV/65q/ZKv+/c1/kFb/X5cvnz5XizTMvZP0+DNl/O8//T09PuIJ/hyPi6H/fB8XgbL9PH5rD/3Vr2xxAd9L2qLct5Rydqi9WHKu8jBmmRNrbTI5eFiU/sD", + "bytecode": "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", + "debug_symbols": "tZZBbuMwDEXv4nUWpiRScq9SFIWbuoUBwwncZIBBkbsPafOn7SLFjAbd5D/FIiV9UbLfm+fh6fz6OM4vh7fm7v69eVrGaRpfH6fDvj+Nh1n/fW9a+6FOJexUyTW4Rtfkyq7S3EXT7Fpcu1VD27qSa3CNrsmVXcU1uxZXz0eeL6gmU83Dpponm7KruGqeYlpcu01j60quwTW6JlePT9q/M9X+Yhpcoyt7Px2XWoMMKAAdmkiBWwABNBvZsjhuw3ByZVe3gd0GcRvEbRW3VdxWcVvFbRW3VdxW8XxiczIfcwuwOZmjOQA0J9kac3Io1sfcLfaPLbvoOGQTLQLIgALoHKzGNiBAAERAAvC2wVZoq+ZVoxVWaA0IEAARkABWrWQggAwogM7BSmwDAljmYBABCcAAAWRAAVhmdTta0W5AgACwzMkgARgggAwogM7ByjmYLVbPGwRABCQAA2TbvmhVvkEBdA5W+BsQIAAiYC2Dy2XX4EZ5PC3DYBfKpytGL55jvwzzqbmbz9O0a37103nt9Hbs51VP/aJPdceG+VlVE76M02B02X1Et7dDc/JYIrpG89dw+rFwLUGP1xqsiNdj6fF6MCviJcM6KW3N8iPWn9PN8eXn4vUtQtiArnzagb9P0AkcbIP8ewJ9X30koFiTwC5GzID/dwa3lkDhGxP0pQoXA+VbGb4p44hd0Iuh5hhIRHwOVfHXY5RLRXzq2ONTVzN/ZuwA55pjLAHrF65ZP1/jOdSsnyP841Q1Pl3jQ801xJKv/lWNX1B/3NVcw5yv+9d9Hf9BW/1+XL58+V4s0zL2T9PgzZfzvP/09PT7iCf4cj4uh/3wfF4Gy/Tx+aw/91a9scQHfS9qi3LeUcnaovVhyrvIwZpkTa20yOXhYlP7Aw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 9f74679cbc1..2988507f242 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -88,7 +88,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1cd3PTThC9OPn9gIQeek3oLaCTLFumht57J7SY2JTQey/5bPC92CUnIuSFf/Ruhh28MztSnuzze7d7p5VOSocZtzHyL26/g7zTbbvIJ+ew/wTsfwHrEbCpAjZNwGYLWK+AzXFYp+M+10wYHy+5Y12ON/Oc5L4zhbzb8ZzqeEwnn0E+k3yW49HrfiffN/MEPvMFbIGALRSwRQK2WMCWCNhSAVsmYMsFrE/A+gVshYCtFLBVArZawNYI2FoBWydg6wVsg4BtFLBNAjYgYJsFbIuABQJmBSwUsEjAygIWO4zzmK1kWq3DbQfdNihmdi6grea43RLoFm3bpjvZvqi4bdXkOpCBvhyBTo8dFgWVcrlRDRs2ssNBWKsncVCO65XEJjZO4pEwiaJGUk6qtXqtGtRsOWrYZlwLm66tSvG2ItdWUPUUyHzCFeVZwcUi8MkzUcKzBsxtnzy34niWffLchuNZ9clzO45n4pPnDhzPuk+eO3E8Gz557sLxbPrkOQjjaUOfPHfjeMZca3Ch0u3a44HF8zPPfTyv8Jjl8cC5lsZxt2m1Uk5jUMwiQM3ys7/2ANsqGbnIBekOfpczQTGzexRw3OuBo0i0aBLsgxGtDEvJhOxUTcFCc8TFKZdQ4Nnul84smpz7PSSPFJyiPA/AeFbqWgcRMFbeBhEuTp4H0X5gch40OgbRIRxPtWciYKy8DaJDSI5aa9BEAcfD7UAFtqaA4xEPHEWiRafooziiodaEOqqA4zGjJKGO44hGWhPquAKOJ0z7VGK3KuB40igZ+adwRGOtCXVKAcfTRklCncERrWhNqDMKOJ417VOJ3aaA47l2oAK7XQHH8x44ikSLTtEXcERrWhPqggKOF5EceVWePV2V57tSfMODr1H5soIrVi4y+LzAUw5n80XTan/zqvwlYFslM/HUZNZAur0lzSUFHC8b8CnNKAwUtBM8cbzigeMPQy/UZTuz6MgfAvLSmpxDCjheNUqScwiYnNfayWmvKeB43YBrN34dJq1HeFrm7L9uWg2dvMj67IbB1mddxlvyenu04Ib5+5MXuqruOVD/9KMFN9uB0vFowXA7UDqW7OtIjkyOX8XuzJC9aSZeeR3O7NfdPr92OELOr8/wqym3ye+Q3yW/Rz5Kfp/8AflD8kfkj8mfkD8lf0b+nPwF+UvyV+Svyd+QvyV/R/6e/AP5R/JP5J/N+CvxY+ZXy9cSRc/Z84CBumXwyeRD83yg5hElmhcANTeUaF4I1NxUonkRUPNtJZoXAzXfUaJ5CVDzXSWalwI131OieRlQ86gSzcuBmu8r0dwH1PxAieZ+oOaHSjSvAGp+pETzSqDmx0o0rwJqfqJE82qg5qdKNK8Ban6mRPNaoObnSjSvA2p+oUTzeqDml0o0bwBqfqVE80ag5tdKNG8Can6jRPMAUPNbJZo3AzW/U6J5C1DzeyWaA6DmD0o0W6Dmj0o0h0DNn5RojoCaPyvRXAZq/qJEcwzUPAbUzGvh6cMNPv/FeX/mN3hdmtdped2S1/F4XYvXeXjdg9cB+L443yfuc9/j+2p8n4nvu/B9CL4u5+tUvm7j6xiu67nO5bqP6yCuC/g8yQHleZTnFR5nnHdxTmNqAz/jPnP6la+j3/Kfmey2U9y2O3Oc+2jQ/R0UszBtv8dP+8Ek02rdmf2e3LF0HEgPwHT85u9Sbvunz+bxLDZNOJa22eu2Wb6pju+ooNMOe2AAAA==", - "debug_symbols": "ndTNbqpQFIbhe9ljBnut/d9bOTkxqNuGhKCh0KQx3nuXfAtrB20aRq+K36MEwtUc635+3XXD6fxmXv5dzX7s+r573fXnQzt150E+vd4as77dTWOt8pF5Oi6rSzvWYTIvw9z3jXlv+3n50tulHZZO7ShHbWPqcJQKeOr6en91a77W9ucpR6djjuExD3/fu8fe5U17euzLln1Zf99Z2rD3IereJ7dlX7zuA2/ZB1fWfYg/7dMv52/tegJs6ekf/B2g9AA4PAP/5U176MZv96zxLN9sjHeIRwIS5TpIEpKRsiRYhBBGHOKRgEAJUAKUACVCiVAilAglQolQIpQoilyimJGyJFmEEEYc4pGARARKgpKgZCgZSoaSoWQoGUqGkqFkKBlKESVICGFEFLmuxSMBiUhaLmjJSFlC1mpJy1qn9dqgjdqkzVr1SD1Sj9Qj9Ug9Uo/UI/VIPVKP1WP1WD1Wj9Vj9Vg9Vo/v3u1+H49du++rPj9P83B4epxOH5f1yPrAvYznQz3OY73fxssxubE/AQ==", + "debug_symbols": "ndTdarNAEMbxe9ljD3Zmv3srLy/BJJsiiAlWCyXk3jvxGdP0oKV49I8f8zOyi1dzrPv5ddcNp/Obefl3Nfux6/vuddefD+3UnQc5e701Zj3cTWOtcso8XZepSzvWYTIvw9z3jXlv+3m56e3SDkundpSrtjF1OEoFPHV9vf+6NV/T9udRdk6H2eXHePj7fHzMx7Bl3tHj+WXLfFmf7yxtmPch6rxPbst88TofeMt8cGWdD/Gn+fTL+1u7vgBbevoHfwcoPQAOz8B/OWgP3fhtzxrPcmdjvEM8EpAo6yBJSEbKkmARQhhxiEcCAiVACVAClAglQolQIpQIJUKJUKIoskQxI2VJsgghjDjEIwGJCJQEJUHJUDKUDCVDyVAylAwlQ8lQMpQiSpAQwogosq7FIwGJSFoWtGSkLCFrtaRlrdN6bdBGbdJmrXqkHqlH6pF6pB6pR+qReqQeqcfqsXqsHqvH6rF6rB6rx3fvdt/HY9fu+6rfz9M8HJ4+p9PHZb2yfnAv4/lQj/NY79t4uSYb+xM=", "file_map": { "50": { "source": "struct Bar {\n inner: [u8; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nfn main(mut x: [Foo; 3], y: pub Field, hash_result: pub [u8; 32]) {\n // Simple dynamic array set for entire inner most array\n x[y - 1].bar.inner = [106, 107, 10];\n let mut hash_input = x[y - 1].bar.inner;\n // Make sure that we are passing a dynamic array to the black box function call\n // by setting the array using a dynamic index here\n hash_input[y - 1] = 0;\n let hash = std::hash::blake3(hash_input);\n assert_eq(hash, hash_result);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap index 9f74679cbc1..2988507f242 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_0.snap @@ -88,7 +88,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1cd3PTThC9OPn9gIQeek3oLaCTLFumht57J7SY2JTQey/5bPC92CUnIuSFf/Ruhh28MztSnuzze7d7p5VOSocZtzHyL26/g7zTbbvIJ+ew/wTsfwHrEbCpAjZNwGYLWK+AzXFYp+M+10wYHy+5Y12ON/Oc5L4zhbzb8ZzqeEwnn0E+k3yW49HrfiffN/MEPvMFbIGALRSwRQK2WMCWCNhSAVsmYMsFrE/A+gVshYCtFLBVArZawNYI2FoBWydg6wVsg4BtFLBNAjYgYJsFbIuABQJmBSwUsEjAygIWO4zzmK1kWq3DbQfdNihmdi6grea43RLoFm3bpjvZvqi4bdXkOpCBvhyBTo8dFgWVcrlRDRs2ssNBWKsncVCO65XEJjZO4pEwiaJGUk6qtXqtGtRsOWrYZlwLm66tSvG2ItdWUPUUyHzCFeVZwcUi8MkzUcKzBsxtnzy34niWffLchuNZ9clzO45n4pPnDhzPuk+eO3E8Gz557sLxbPrkOQjjaUOfPHfjeMZca3Ch0u3a44HF8zPPfTyv8Jjl8cC5lsZxt2m1Uk5jUMwiQM3ys7/2ANsqGbnIBekOfpczQTGzexRw3OuBo0i0aBLsgxGtDEvJhOxUTcFCc8TFKZdQ4Nnul84smpz7PSSPFJyiPA/AeFbqWgcRMFbeBhEuTp4H0X5gch40OgbRIRxPtWciYKy8DaJDSI5aa9BEAcfD7UAFtqaA4xEPHEWiRafooziiodaEOqqA4zGjJKGO44hGWhPquAKOJ0z7VGK3KuB40igZ+adwRGOtCXVKAcfTRklCncERrWhNqDMKOJ417VOJ3aaA47l2oAK7XQHH8x44ikSLTtEXcERrWhPqggKOF5EceVWePV2V57tSfMODr1H5soIrVi4y+LzAUw5n80XTan/zqvwlYFslM/HUZNZAur0lzSUFHC8b8CnNKAwUtBM8cbzigeMPQy/UZTuz6MgfAvLSmpxDCjheNUqScwiYnNfayWmvKeB43YBrN34dJq1HeFrm7L9uWg2dvMj67IbB1mddxlvyenu04Ib5+5MXuqruOVD/9KMFN9uB0vFowXA7UDqW7OtIjkyOX8XuzJC9aSZeeR3O7NfdPr92OELOr8/wqym3ye+Q3yW/Rz5Kfp/8AflD8kfkj8mfkD8lf0b+nPwF+UvyV+Svyd+QvyV/R/6e/AP5R/JP5J/N+CvxY+ZXy9cSRc/Z84CBumXwyeRD83yg5hElmhcANTeUaF4I1NxUonkRUPNtJZoXAzXfUaJ5CVDzXSWalwI131OieRlQ86gSzcuBmu8r0dwH1PxAieZ+oOaHSjSvAGp+pETzSqDmx0o0rwJqfqJE82qg5qdKNK8Ban6mRPNaoObnSjSvA2p+oUTzeqDml0o0bwBqfqVE80ag5tdKNG8Can6jRPMAUPNbJZo3AzW/U6J5C1DzeyWaA6DmD0o0W6Dmj0o0h0DNn5RojoCaPyvRXAZq/qJEcwzUPAbUzGvh6cMNPv/FeX/mN3hdmtdped2S1/F4XYvXeXjdg9cB+L443yfuc9/j+2p8n4nvu/B9CL4u5+tUvm7j6xiu67nO5bqP6yCuC/g8yQHleZTnFR5nnHdxTmNqAz/jPnP6la+j3/Kfmey2U9y2O3Oc+2jQ/R0UszBtv8dP+8Ek02rdmf2e3LF0HEgPwHT85u9Sbvunz+bxLDZNOJa22eu2Wb6pju+ooNMOe2AAAA==", - "debug_symbols": "ndTNbqpQFIbhe9ljBnut/d9bOTkxqNuGhKCh0KQx3nuXfAtrB20aRq+K36MEwtUc635+3XXD6fxmXv5dzX7s+r573fXnQzt150E+vd4as77dTWOt8pF5Oi6rSzvWYTIvw9z3jXlv+3n50tulHZZO7ShHbWPqcJQKeOr6en91a77W9ucpR6djjuExD3/fu8fe5U17euzLln1Zf99Z2rD3IereJ7dlX7zuA2/ZB1fWfYg/7dMv52/tegJs6ekf/B2g9AA4PAP/5U176MZv96zxLN9sjHeIRwIS5TpIEpKRsiRYhBBGHOKRgEAJUAKUACVCiVAilAglQolQIpQoilyimJGyJFmEEEYc4pGARARKgpKgZCgZSoaSoWQoGUqGkqFkKBlKESVICGFEFLmuxSMBiUhaLmjJSFlC1mpJy1qn9dqgjdqkzVr1SD1Sj9Qj9Ug9Uo/UI/VIPVKP1WP1WD1Wj9Vj9Vg9Vo/v3u1+H49du++rPj9P83B4epxOH5f1yPrAvYznQz3OY73fxssxubE/AQ==", + "debug_symbols": "ndTdarNAEMbxe9ljD3Zmv3srLy/BJJsiiAlWCyXk3jvxGdP0oKV49I8f8zOyi1dzrPv5ddcNp/Obefl3Nfux6/vuddefD+3UnQc5e701Zj3cTWOtcso8XZepSzvWYTIvw9z3jXlv+3m56e3SDkundpSrtjF1OEoFPHV9vf+6NV/T9udRdk6H2eXHePj7fHzMx7Bl3tHj+WXLfFmf7yxtmPch6rxPbst88TofeMt8cGWdD/Gn+fTL+1u7vgBbevoHfwcoPQAOz8B/OWgP3fhtzxrPcmdjvEM8EpAo6yBJSEbKkmARQhhxiEcCAiVACVAClAglQolQIpQIJUKJUKIoskQxI2VJsgghjDjEIwGJCJQEJUHJUDKUDCVDyVAylAwlQ8lQMpQiSpAQwogosq7FIwGJSFoWtGSkLCFrtaRlrdN6bdBGbdJmrXqkHqlH6pF6pB6pR+qReqQeqcfqsXqsHqvH6rF6rB6rx3fvdt/HY9fu+6rfz9M8HJ4+p9PHZb2yfnAv4/lQj/NY79t4uSYb+xM=", "file_map": { "50": { "source": "struct Bar {\n inner: [u8; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nfn main(mut x: [Foo; 3], y: pub Field, hash_result: pub [u8; 32]) {\n // Simple dynamic array set for entire inner most array\n x[y - 1].bar.inner = [106, 107, 10];\n let mut hash_input = x[y - 1].bar.inner;\n // Make sure that we are passing a dynamic array to the black box function call\n // by setting the array using a dynamic index here\n hash_input[y - 1] = 0;\n let hash = std::hash::blake3(hash_input);\n assert_eq(hash, hash_result);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 9f74679cbc1..2988507f242 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -88,7 +88,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1cd3PTThC9OPn9gIQeek3oLaCTLFumht57J7SY2JTQey/5bPC92CUnIuSFf/Ruhh28MztSnuzze7d7p5VOSocZtzHyL26/g7zTbbvIJ+ew/wTsfwHrEbCpAjZNwGYLWK+AzXFYp+M+10wYHy+5Y12ON/Oc5L4zhbzb8ZzqeEwnn0E+k3yW49HrfiffN/MEPvMFbIGALRSwRQK2WMCWCNhSAVsmYMsFrE/A+gVshYCtFLBVArZawNYI2FoBWydg6wVsg4BtFLBNAjYgYJsFbIuABQJmBSwUsEjAygIWO4zzmK1kWq3DbQfdNihmdi6grea43RLoFm3bpjvZvqi4bdXkOpCBvhyBTo8dFgWVcrlRDRs2ssNBWKsncVCO65XEJjZO4pEwiaJGUk6qtXqtGtRsOWrYZlwLm66tSvG2ItdWUPUUyHzCFeVZwcUi8MkzUcKzBsxtnzy34niWffLchuNZ9clzO45n4pPnDhzPuk+eO3E8Gz557sLxbPrkOQjjaUOfPHfjeMZca3Ch0u3a44HF8zPPfTyv8Jjl8cC5lsZxt2m1Uk5jUMwiQM3ys7/2ANsqGbnIBekOfpczQTGzexRw3OuBo0i0aBLsgxGtDEvJhOxUTcFCc8TFKZdQ4Nnul84smpz7PSSPFJyiPA/AeFbqWgcRMFbeBhEuTp4H0X5gch40OgbRIRxPtWciYKy8DaJDSI5aa9BEAcfD7UAFtqaA4xEPHEWiRafooziiodaEOqqA4zGjJKGO44hGWhPquAKOJ0z7VGK3KuB40igZ+adwRGOtCXVKAcfTRklCncERrWhNqDMKOJ417VOJ3aaA47l2oAK7XQHH8x44ikSLTtEXcERrWhPqggKOF5EceVWePV2V57tSfMODr1H5soIrVi4y+LzAUw5n80XTan/zqvwlYFslM/HUZNZAur0lzSUFHC8b8CnNKAwUtBM8cbzigeMPQy/UZTuz6MgfAvLSmpxDCjheNUqScwiYnNfayWmvKeB43YBrN34dJq1HeFrm7L9uWg2dvMj67IbB1mddxlvyenu04Ib5+5MXuqruOVD/9KMFN9uB0vFowXA7UDqW7OtIjkyOX8XuzJC9aSZeeR3O7NfdPr92OELOr8/wqym3ye+Q3yW/Rz5Kfp/8AflD8kfkj8mfkD8lf0b+nPwF+UvyV+Svyd+QvyV/R/6e/AP5R/JP5J/N+CvxY+ZXy9cSRc/Z84CBumXwyeRD83yg5hElmhcANTeUaF4I1NxUonkRUPNtJZoXAzXfUaJ5CVDzXSWalwI131OieRlQ86gSzcuBmu8r0dwH1PxAieZ+oOaHSjSvAGp+pETzSqDmx0o0rwJqfqJE82qg5qdKNK8Ban6mRPNaoObnSjSvA2p+oUTzeqDml0o0bwBqfqVE80ag5tdKNG8Can6jRPMAUPNbJZo3AzW/U6J5C1DzeyWaA6DmD0o0W6Dmj0o0h0DNn5RojoCaPyvRXAZq/qJEcwzUPAbUzGvh6cMNPv/FeX/mN3hdmtdped2S1/F4XYvXeXjdg9cB+L443yfuc9/j+2p8n4nvu/B9CL4u5+tUvm7j6xiu67nO5bqP6yCuC/g8yQHleZTnFR5nnHdxTmNqAz/jPnP6la+j3/Kfmey2U9y2O3Oc+2jQ/R0UszBtv8dP+8Ek02rdmf2e3LF0HEgPwHT85u9Sbvunz+bxLDZNOJa22eu2Wb6pju+ooNMOe2AAAA==", - "debug_symbols": "ndTNbqpQFIbhe9ljBnut/d9bOTkxqNuGhKCh0KQx3nuXfAtrB20aRq+K36MEwtUc635+3XXD6fxmXv5dzX7s+r573fXnQzt150E+vd4as77dTWOt8pF5Oi6rSzvWYTIvw9z3jXlv+3n50tulHZZO7ShHbWPqcJQKeOr6en91a77W9ucpR6djjuExD3/fu8fe5U17euzLln1Zf99Z2rD3IereJ7dlX7zuA2/ZB1fWfYg/7dMv52/tegJs6ekf/B2g9AA4PAP/5U176MZv96zxLN9sjHeIRwIS5TpIEpKRsiRYhBBGHOKRgEAJUAKUACVCiVAilAglQolQIpQoilyimJGyJFmEEEYc4pGARARKgpKgZCgZSoaSoWQoGUqGkqFkKBlKESVICGFEFLmuxSMBiUhaLmjJSFlC1mpJy1qn9dqgjdqkzVr1SD1Sj9Qj9Ug9Uo/UI/VIPVKP1WP1WD1Wj9Vj9Vg9Vo/v3u1+H49du++rPj9P83B4epxOH5f1yPrAvYznQz3OY73fxssxubE/AQ==", + "debug_symbols": "ndTdarNAEMbxe9ljD3Zmv3srLy/BJJsiiAlWCyXk3jvxGdP0oKV49I8f8zOyi1dzrPv5ddcNp/Obefl3Nfux6/vuddefD+3UnQc5e701Zj3cTWOtcso8XZepSzvWYTIvw9z3jXlv+3m56e3SDkundpSrtjF1OEoFPHV9vf+6NV/T9udRdk6H2eXHePj7fHzMx7Bl3tHj+WXLfFmf7yxtmPch6rxPbst88TofeMt8cGWdD/Gn+fTL+1u7vgBbevoHfwcoPQAOz8B/OWgP3fhtzxrPcmdjvEM8EpAo6yBJSEbKkmARQhhxiEcCAiVACVAClAglQolQIpQIJUKJUKIoskQxI2VJsgghjDjEIwGJCJQEJUHJUDKUDCVDyVAylAwlQ8lQMpQiSpAQwogosq7FIwGJSFoWtGSkLCFrtaRlrdN6bdBGbdJmrXqkHqlH6pF6pB6pR+qReqQeqcfqsXqsHqvH6rF6rB6rx3fvdt/HY9fu+6rfz9M8HJ4+p9PHZb2yfnAv4/lQj/NY79t4uSYb+xM=", "file_map": { "50": { "source": "struct Bar {\n inner: [u8; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nfn main(mut x: [Foo; 3], y: pub Field, hash_result: pub [u8; 32]) {\n // Simple dynamic array set for entire inner most array\n x[y - 1].bar.inner = [106, 107, 10];\n let mut hash_input = x[y - 1].bar.inner;\n // Make sure that we are passing a dynamic array to the black box function call\n // by setting the array using a dynamic index here\n hash_input[y - 1] = 0;\n let hash = std::hash::blake3(hash_input);\n assert_eq(hash, hash_result);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 031fe9af695..243a9e713c9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -95,8 +95,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pdXfjqowEAbwd+Gai06nf32VjTGouCEhaFg9yYnh3c8MfFXPxW522Rt+LWU+sYVyr47t/va+64bT+aPavN2r/dj1ffe+68+H5tqdBzl7r4weKIdqQ7UYYYJ51hoDCVrI0EEPA4wwQeSR5FmVoIUMHfQwQMljNcG8aA0kaCFDBz0MEHkWeVbynMgGErSQoYMeBhhhgshzkudVghYydNDDACOUvKDmRW8gQQsZOuih5EU1wgTzYjCQoIUMHfRwyWPD0EEPZTypESaYF3X9ZwlayBDX63pmFed1Hclow5dGKA191EgbqTQyGrqaxNpAnC7nrMTmaaqr8krsrmPb6hvx8o7Im3Npxna4Vpvh1vd19afpb/NFH5dmmL02o4zKXbTDUZTAU9e32prqZ7X5vFQmGsUyxY9y//16ftRzWlVPj/q8pj6X32dDK+qdD6h3kdfUZ4d6b9fUe86l3ocV9bJxlgmUvfNlBr4fkMsMyOYafh4gW/QzgHhNAMXnHfjf3sFnf4HsF5Mg35Eyi7LVvyZspdMcuvG/j9ekUWPX7PsW3dNtOLyMXv9eykj5+F3G86E93sZWk55fQDm82Rhrm9NWNgbpUaKaMkmP5sGQahtZu6TdnGt51LeT3to/", + "bytecode": "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", + "debug_symbols": "pdXNbqMwFAXgd2HNwtf/zqtUUUQSp0JCJKIw0iji3edeOE4yi1Yt3eSzMfdAbDD36pyP0/uh7S/Xj2r3dq+OQ9t17fuhu56asb32fPReKfmh5Ksd1WyAsdppMS1qpSBBDQ200EEPA4wQeYQ8Qh4hj5BHyCPkEfKI84wYYVrVChLU0EALHfQQeRp5mvMsaxQkqKGBFjroYYARIs9ynhMJamighQ56GCDneTGtOgUJamighQ5yXhADjDCtegUJamighQ6ueUYZaKGDPB7FACNMq7L+iwQ1NBDny3omEcdlHUlJw5WGLw15dEkasTQSGrKaZKSBOFnORY5N81xX5ZU4jEPO8ka8vCP85tyaIfdjteunrqurP003LSd93Jp+cWwGHuW7yP2Z5cBL22VpzfWzWn1eyg8WivnReZS779f7R713W+oNPa6fttSncn2jaEO9dR71Npgt9cmi3ukt9c6kUu/8hnreOMsE8t75MgPfD0hlBnhz9T8P4C36GUBmSwCF5x24397BZ3+B9BeTwN+RMou81b8m7LnTnNrhv4/XLFFD2xy7jO5l6k8vo+PfWxkpH7/bcD3l8zRkSXp+AfnnTYdQ6xT3vDFwjyLVlIh7tAz6WOtgpEvSTanmR30/y639Aw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap index 05ac992c70f..e07459eaccb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_0.snap @@ -95,8 +95,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "tdVNjuIwEAXgu2Sdhav8z1UQQgFCK1IUUJqMNEK5+1TBMzALRj1p9YbPJq6X4Bj7Wh3a3fSx7Ybj6bNara/Vbuz6vvvY9qd9c+lOg3x7rYx+UHbVimrRwwAjTDDfZGMgQYYWOuhhgBFKHqv5LhlIkKGFDnooeVaNMMF8lw0kyNBCBz1EHiOPkceS50RrIEGGFjroYYARJog8J3leJcjQQgc9DDBCyQtqvusNJMjQQgc9lLykRpig5GUxGEiQoYUOehjuRoyP+v6NNmRAVAOMEDdKupB0RSQqDS4NXUv6spMrDV8aupx0HlPEfVIqDV2hZp7rqizz7WVsW13lL+te/g3nZmyHS7Uapr6vq19NP90GfZ6b4ealGeWqRLbDQZTAY9e32prrZ7V5XyqThWKZpke5/3q9fdTbtKieHvV5SX0u97eGFtQ7H1Dvol1Snx3qPS+p9zaXeh/e1cefq5fNs7wA2T9fZvDrAbnMoGyw4f8DZJt+BpBdEkDx+QT+u0/w7ieQ/cckyFlSZlG2+9eEjXSafTf+daDNGjV2za5v0T1Ow/7l6uX3uVwpB+J5PO3bwzS2mvQ8FeVjLUu/tsybupLdaE2JasokPT2w1py55hy1SzqWrYz1m1kf7Q8=", + "bytecode": "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", + "debug_symbols": "tdVNjuIwEAXgu2Sdhav8z1UQQgFCK1IUUJqMNEK5+1TBMzALRj1p9YbPIa7n4Bj7Wh3a3fSx7Ybj6bNara/Vbuz6vvvY9qd9c+lOg3x7rYx+UHbVimrRw1CtWI0wwXyTjYEEGVrooIcBRpgg8gh5hDxCHiGPkEfII8mzaoQJ5rtsIEGGFjroIfIYeYw8ljwnWgMJMrTQQQ8DjDBB5DnJ8ypBhhY66GGAEUpeUPNdbyBBhhY66KHkJTXCBCUvi8FAggwtdNDDcDeif9T1ZLQhHaIaYIQYKMlARNqg0uDSkLFIX3ZypeFLQ9JI5zFFjJNSaWRtzHNdlWW+vYxtq6v8Zd3Lv+HcjO1wqVbD1Pd19avpp1unz3Mz3Lw0o9yVyHY4iBJ47PpWW3P9rDbvS2VxoFhe/6Pcf70+POqDX1Jv6TF+XlKfy/jW0IJ65wPqXbRL6rNDvecl9d7mUu/Du/r4c/WyeZYXIPvnywx+PSCXGZQNNvx/gGzTzwCySwIoPp/Af/cJ3v0Esv+YBDlLyizKdv+asJGLZt+Nfx1os0aNXbPrW1wep2H/cvfy+1zulAPxPJ727WEaW016norysZalX1vmTV3JbrSmRDVlkis9sNacueYc9ZK0L1vp6zezPtof", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 05ac992c70f..e07459eaccb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/array_dynamic_nested_blackbox_input/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -95,8 +95,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "tdVNjuIwEAXgu2Sdhav8z1UQQgFCK1IUUJqMNEK5+1TBMzALRj1p9YbPJq6X4Bj7Wh3a3fSx7Ybj6bNara/Vbuz6vvvY9qd9c+lOg3x7rYx+UHbVimrRwwAjTDDfZGMgQYYWOuhhgBFKHqv5LhlIkKGFDnooeVaNMMF8lw0kyNBCBz1EHiOPkceS50RrIEGGFjroYYARJog8J3leJcjQQgc9DDBCyQtqvusNJMjQQgc9lLykRpig5GUxGEiQoYUOehjuRoyP+v6NNmRAVAOMEDdKupB0RSQqDS4NXUv6spMrDV8aupx0HlPEfVIqDV2hZp7rqizz7WVsW13lL+te/g3nZmyHS7Uapr6vq19NP90GfZ6b4ealGeWqRLbDQZTAY9e32prrZ7V5XyqThWKZpke5/3q9fdTbtKieHvV5SX0u97eGFtQ7H1Dvol1Snx3qPS+p9zaXeh/e1cefq5fNs7wA2T9fZvDrAbnMoGyw4f8DZJt+BpBdEkDx+QT+u0/w7ieQ/cckyFlSZlG2+9eEjXSafTf+daDNGjV2za5v0T1Ow/7l6uX3uVwpB+J5PO3bwzS2mvQ8FeVjLUu/tsybupLdaE2JasokPT2w1py55hy1SzqWrYz1m1kf7Q8=", + "bytecode": "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", + "debug_symbols": "tdVNjuIwEAXgu2Sdhav8z1UQQgFCK1IUUJqMNEK5+1TBMzALRj1p9YbPIa7n4Bj7Wh3a3fSx7Ybj6bNara/Vbuz6vvvY9qd9c+lOg3x7rYx+UHbVimrRw1CtWI0wwXyTjYEEGVrooIcBRpgg8gh5hDxCHiGPkEfII8mzaoQJ5rtsIEGGFjroIfIYeYw8ljwnWgMJMrTQQQ8DjDBB5DnJ8ypBhhY66GGAEUpeUPNdbyBBhhY66KHkJTXCBCUvi8FAggwtdNDDcDeif9T1ZLQhHaIaYIQYKMlARNqg0uDSkLFIX3ZypeFLQ9JI5zFFjJNSaWRtzHNdlWW+vYxtq6v8Zd3Lv+HcjO1wqVbD1Pd19avpp1unz3Mz3Lw0o9yVyHY4iBJ47PpWW3P9rDbvS2VxoFhe/6Pcf70+POqDX1Jv6TF+XlKfy/jW0IJ65wPqXbRL6rNDvecl9d7mUu/Du/r4c/WyeZYXIPvnywx+PSCXGZQNNvx/gGzTzwCySwIoPp/Af/cJ3v0Esv+YBDlLyizKdv+asJGLZt+Nfx1os0aNXbPrW1wep2H/cvfy+1zulAPxPJ727WEaW016norysZalX1vmTV3JbrSmRDVlkis9sNacueYc9ZK0L1vp6zezPtof", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..dfc940b091f --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,20 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": {} + }, + "bytecode": "H4sIAAAAAAAA/5XDsQkAAADCMAv+f7PuTgaCFm19Arunwj5IAAAA", + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..dfc940b091f --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,20 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": {} + }, + "bytecode": "H4sIAAAAAAAA/5XDsQkAAADCMAv+f7PuTgaCFm19Arunwj5IAAAA", + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..dfc940b091f --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,20 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": {} + }, + "bytecode": "H4sIAAAAAAAA/5XDsQkAAADCMAv+f7PuTgaCFm19Arunwj5IAAAA", + "debug_symbols": "XY5BCsQwCEXv4rqLWfcqw1BsaosgJtikMITefWyYQOlK/3/6tcJCc9km1jXuML4rzMYivE0SA2aO6m49B+hyykbkFty4byU00gyjFpEBDpTShvaE2mpGc/oagHTx6oErC13d+XGBge158UBjnIX+ci0abjR/Uyf942Qx0FKMrqTGPPsH", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..3d37d3ebb4e --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,40 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/71W207jMBAdN3HTtFvtannZ/QZeQlOaIoHEAxKPfAEPoVW/gA/g02kkj3p0MjJFtbEUOfFlZs7x+EycnJoLfSkXNDXyHvo69BOYL47PY/huLms3NflNaX/brNe1gS9h/G0dbLo89hu1n4n/pgp2nj5O9hGL+p0dnwW8/5JTfuTCr+eXE/9VBPMiYL36AazHtlqSf2zOGCuMNQ7O6H94XxrrBDDqHSk/0uPqtk2j/opg38s4dvTvaf2/8D2n+Ie+vCDOQ9ffHNr+0N/2+/161/8l+0M7NxdEkuXBKOcT2u40x5B/R5hKGE+plY78CcTBZzq0OcWauvY48qfxMD96DsqdN2L9Y8w5eveGH2/4sWzp3G+xNWhoubWS+SoBx8TAPZFxPiHXnsauQz/csweyxznDY8xdYcST8c5u1LbPw/1Gc28q46ZzFfnGuZnBh87VkX1zY9+5tUi5mAEPsVqkPjFfFJNVe0XSaQHn4j35zaRBDdcc9DXUnNQ1r+/a7W613nVvt23fbr5V81R7LI1TnqaZeFJfmg+oPejTAwa+ExVg9DT2HHpLe76r286Ix+KOdbvKzN3M4K6KcIeaoe/InY69SDruCiOe2ognIT93rIPYYjqocwuKS+R8jVRMQ/8Kdnkdx4N5NKe1ul7PCWtzSet0DtdY93sp49z+SidiNTjTP2bDeYe5zj4VN2PG/PQ0tg+9let4vrH/SEsnWAty//NOjViteCzdmhLuyrA1idjC/bgX1/qI38z/WqsYrpi2W7jO5YhtOcOW0D4v9nngu35b58F3+BNqmpaBTRQAAA==", + "debug_symbols": "tZXfiqswEIffJddeZPJvkr7KUopt7SKILW49cCi++5n4M7Z7UVg87I3fpM58Y+xgHurcHMfPQ9tfrl9q9/FQx6Htuvbz0F1P9b299vLrQ+l8Iat2VClygAcCwDOMrIyAgQikGVYDBBjAAg7wACxWLFYQgTTDaYAAA1jAAWJxggAwEIE0w2uAAANYwAGweFg8LB4WD0tASkBKQEpASkAKoxGjEaMRoxGjEcPCsDAsDAvDEmGJYvECA1jAAR4IAAMREAtXKoklCqQgCTwQAAYikGaQ1gtpoXQmnQNbAleCPA55EHQoQR4Jm4NYctISkC4BLclkSmCXqnnM3DRVqkzi4T40TR7El9GUgb3VQ9Pf1a4fu65Sf+punJO+bnU/814Pcle6Nf1ZKMJL2zU5mqpntX5fSmGpNbQW+x9XJ7dUk7UbyimYUh821fu1f4gb6k3QsWw/ED8NPxeYtApsfCMI7wXMdqnnGLb0f9mA27ABSkzlFaZIG55A63WCNNktAuJVYPz/PsG7l0jm1/4ESun5AOabYC+L+tQO3w6cKauGtj52zbK8jP3p5e79763cKQfWbbiemvM4NNn0cmrJ9YNSZdw+f1VkEagKdj/l1v8A", + "file_map": { + "5": { + "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", + "path": "std/cmp.nr" + }, + "50": { + "source": "fn main() {\n bug();\n comptime { bug() };\n}\n\nfn bug() {\n let mut a = ([1, 2], 3);\n a.0[{\n a = ([4, 5], 6);\n 1\n }] = 7;\n\n assert_eq(a, ([4, 7], 6));\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..794ec2870f2 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,32 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/71TSw7CIBAFoVGs3diNxktQi2mXLrwIseEcPbqQDGGC6AboS8gwMHlvHh9KAihETjLgSW4QBcQd2md2PCGXeRhEpFuSf5ZKiYS/gv2PAjhpHX7p+Sudv9wDz2sN/NiL1z3Y0aL5iYT3Ucu/v7+a/vs/nlvw2m/g1eLeRfoYNLHGEjUU3dEV5l2ijiCP/o/wtbyvaZbS6zHgb8h371i/ieovkB+j/l3kGX2aSQ9m1EY/9LKotz5H/A6/3oLLP7CfgiF9BQAA", + "debug_symbols": "dZBNDoMgEIXvMmsWYtWmXsUYgzoaEgIEoUljuHsHf1q76GYew+N7ZGaFEfswd1JPZoG6WaF3Uik5d8oMwkuj6XaFLBV+g5oz4MUu5S7VLneSGBmcWOcdYqIuOZRuhUPtodZBKQZPocL2aLFCb+qFIzdjgHokpcBJKkynyL509h/l1cHm/AOXRLfUiUG6n7liynFS9AqPdgp6uLj+ZU/n3It1ZsAxOExJl+VQbfiD5UUb029v", + "file_map": { + "50": { + "source": "fn main() {\n bug();\n comptime { bug() };\n}\n\nfn bug() {\n let mut a = ([1, 2], 3);\n a.0[{\n a = ([4, 5], 6);\n 1\n }] = 7;\n\n assert_eq(a, ([4, 7], 6));\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..462226954f8 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/assign_mutation_in_lvalue/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -0,0 +1,27 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "H4sIAAAAAAAA/7WSwQ7CIAyGwWEUZzw4H6TLMNvRgy/SuPAce3R3+BsaYrwATUhpSr72L7UmmYV3psAE8oD38AeV7/bzQkxlNvqsbk3+QiH4H/oq9j95MG0bPgm/0fzpBM57S3ytReqe99Or+9Wk/WilX/6vpf7hj+YeWm8qln1yW/1+5oVI+ujAP4Kfm1N5/X5AfFF6xLuCPuPMY5w48pPXNXz4nvFNNrcvgErvAJkEAAA=", + "debug_symbols": "XY7BCoRACIbfxfMcCvayvUpE2GQxIM5gM8ESvfs6sUHsRf391N8DZprKOgZZ4gZdf8CkgTmsI0ePOUSx7nE6uOWYlcha8OC2lVBJMnRSmB3syOUa2hLKlTOq0cYByWzZDi6BqVbnYAJ90H/HHTXgxPSTSxH/oPmTbnJ/nDR6motSvVQZNDW0Fvv25dr3cFa3Lw==", + "file_map": {}, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index d898581b331..1d6b0894691 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -89,7 +89,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "pZfBbuowEEX/hTULe8b22O9XqqqibVohIUAUnvRU8e/Pk9wb2kWlKmx6Thrmxo4nMXyuXofny/vTdv92+Fj9efhcPZ+2u932/Wl3eNmct4d9/+/nKvifGDviujOCAiqYwAwW0MAKtonS88QZQQEVTGAGC2hgBdtERZ4iT3ueOhVMYM9LzgIaWME2MQUwggIqmMCel50FNLCCbWIOYAQFVDCByMvIyz2vOCvYJpqvg0/IhKKURMmUQjFKpfh6+ERqoESKUDzZB1MTJVMKxSiV0iAtUCJFKExuTG5MbkxuTG6e7HNvbRIJgRIpQlFKomRKTzangRVsE73VR0ZQQNRF1EXURdQJ6gR1gjpv6ZEJzCDyBHmCPEGeIk+R5y1dnQomMIMFNLCCbaK39MgIIi8hLyEvIS8hLyEvIS8hLyMvIy8jLyMvIy8jz1u6OQ2sYJtYAhhBARX0lQwuvpLRpVCMUikNYoESKULxHhGX6SETq+D0kIk/EyMjKKCCCfQB+RKNj8MoRqkUH5DfhvFxGCVShKKURMmUQjFKpSBZQ6BEilCU4snNJVMKxSiV0iDj23+USMFrR6NSEiVTCsUoeO2o947fevXmmUQovgMEl0TJlEIxSqU0iHfRJKzynpC+3mo85a0gfi1vhUmU4hf1EfrLc5JC8YtmlzmwQbxRJF6v6xW3zqfzaRh85/yyl/Yd9rg5Dfvz6s/+stutV383u8v4oY/jZj/yvDn1s32Mw/61swe+bXeD23V9qw4/l/aNsKG673ltDsi/T+htPSeEem9CDksStM6zSJoXJZTbGGq9MyFpWZIQSmVCqLYgQVtEQBJZUJ+UtzHVsOj6Ya6PS67fDPU53Xf9nJZc3xIXwIotWkGZeyDIsh4I5ZYQFyWY3bpoyRgscBIWltSXWub6RauQbV6FRfewGR+D/iXwywh+H9A4A/m2jL8NkNsq9u+auiQg2m0E+d4R/DQF79YfV8GUq1C/1T/2g83L9vTtZ9/Vg07bzfNuwOHbZf/y5ez535Fn+LPxeDq8DK+X0+BJt9+O/c+D9pFpyo99r+xHJa4tdvevFQ+xH8VS/DD6J1Ppn6yPVx/Yfw==", + "debug_symbols": "pZfRThsxEEX/Jc95sMdjj91fQQgFWKpIUUBpUqlC+fd6du/dwEMrZF44Z0l8ba/H68375nl6vPx82B9fXn9tfty9bx5P+8Nh//Ph8Pq0O+9fj/2/75vgf2LsiNvOCAqYQAUzWEADK9gWSs8TZwQFTKCCGSyggRVsCxPyEvJSz0vOBCrY89RZQAMr2BZqACMoYAIV7HnZWUADK9gW5gBGUMAEKoi8jLzc84qzgm2h+Tr4hEwoiaKUTCkUo1SKr4dPpAZKpAjFk30wVSmZUihGqZQGaYESKUJhcmNyY3JjcmNy82Sfe2uLSAiUSPFkc0kUpWRKT55pYAXbQi/1mREUEO0i2kW0i2gnaCdoJ2jnJT1TwQwiT5AnyBPkJeQl5HlJV2cCFcxgAQ2sYFvoJT0zgshT5CnyFHmKPEWeIk+Rl5GXkZeRl5GXkZeR5yXdnAZWsC0sAYyggAn0lQwuvpLRpVCMUikNYoESKULxGhGXZZOJVXDZZOJ7YmYEBUyggj4gn+K8HWYxSqX4gHwa83aYJVKEkihKyZRCMUqlIDmFQIkUoSSKP1eDS6YUilH82RpdGsS3xCKRgsdOiomilEwpFKPgsZO8dvzWJy+eRYTiJ8AsSsmUQjFKpTSIV9EibOU1Id6p8SMvBVEXoSSKd5pdMqVQvFNzWQMbxAtF0vW63fDofDifpslPzg9naT9h33an6Xje/DheDoft5vfucJm/9Ottd5x53p36p30RpuNzZw982R8mt+v21jr8u2k/CBta9zOvrQH56wm9rNeEUL+bkMNIQqrrLDTloYRyG0Ot30zQVEYSQqlMCNUGElKLCFCRgfaaeBu1hqH+w9o+jvTfDO2zfq//rCP9m3IBrNjQCspaA0HGaiCUW0IcSjC7VdHYGNbb2HWkjizwNlgYGUGpZW0/tI7Z1nUc6d+MN8BsZP79JZQbsb+GfpjB1wMa74B8KqSvBsitjvrbbhoJiHYbQf7uCP41BSn/W4XEVaif2t/3i93T/vTph+fVg0773eNhwuXL5fj04dPznzd+wh+ub6fXp+n5cpo86fbrtf+5S30nJ833/bTuVyVuLXb3F5u72K9iKX4Z/Zta+jfr/dUH9hc=", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_0.snap index fbea9a61f27..0f876c6328a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_0.snap @@ -89,7 +89,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "pZfNbuIwFEbfhTUL3+ufa/dVRlVF27RCQoAojDSqePfxJd8HZQGqwqbnpMEHkzgJfM/eh9fD58ty/bH5mj39+Z697par1fLzZbV5W+yXm3X/7/cs+B8JHTrvFFDBCCYwgwU0sM6eorONlAAK2HvJGcEEZrCABlawjdQACoieoqfoKXqKnqKnvZedbWQMoIAKRjCBGSxg7xVnBdvIFEABFYxg71VnBgtoYAXbyBxAARWMIHoZvYxeRi+jl9ErvdecAioYwQRmsIAGVrCNNPQMPUPP0DP0DD1Dz9Az9Ay9il5Fr6JX0au9J8ElUwrFKJXSIC1QhNK7Ii6RkiiZUihGqZQ2ivr1IuoiFKVESqJkSqEYpVK83Feq+pUzilCUEimJkimF4uXsUikN4tfQKEJRSqQkipfNpVCMUikN4lfTKEJRSqQkCsuR5chyZDmynFj2C0uqi1IiJVEypVCMUikN4lfYKCxnljPLmeXMcmb5tEiai1Eqpb+F9sUWTzfVkwhFKZGSKJlSIMJRfrpVXM67/LarLpXSIH6WNboIRSn+ptmFQT/Lo3hZjsf5jA+Hl/1uGPzZ8ONp0Z8h28VuWO9nT+vDajWf/V2sDqcXfW0X6xP3i13f2+c4rN87e/BjuRrcjvPL6HB7aL81N4zud+F2DuTrgtwuWKoIWLEJ4/vDL3EGQcukQiiXgkwqmJ0LddocSr0Ubh6He2dC6/k4xFBvFezhOdwpxCYIJNUJ41PkYko1TBnfeBpyCo8ewzypEOv5ekgx31wJ8V6ipEuiTEmUygVtQSZ9issUYr25lqQ8vJjuJX61msK98eG8GiYdhWacQP9O8aPw+0DjedCrW9NvA3q5M/WvLnFKQOwyg/zoDG59BL8D37y/W+RarFfjn/vG4m25u/qBc/TQbrl4XQ3Y/Dis337s3f/bcg9/IG13m7fh/bAbvHT5ldT//FELc23y3J+ZfavI3NzltCvXuZbom+KbTfsr0/PRJ/Yf", + "debug_symbols": "pZdNbuJAEEbv4jWLruqfqs5VRlFEEidCsgA5MNIo4u7ThevDYQGKzCbvOaYfjd224bt771+Pny+b7cfuq3v68929jpth2Hy+DLu39WGz27b/fnfB/lBo4FUjOdkZncmZncUpTu2eorFOpOAkZ+slY3QmZ3YWpzjVWSdycJLTe+w99h57j73H3uPWy8Y6MQYnOdnZesWYnNlZnK0nRnXWiSk4ycnO6Gy9aszO4hSnOuvEHJzkZGd0ei97L3svey97L3uvtB4FE4IwJEISJEMKRCAKqS6CsqAsKAvKgrKgLCgLyoKyoKwoK8qKsqKsViaTDCkQgSikutQAIYiVbSHXCEmQDCkQgSikTsJ2HVE0IQhDIiRBMqRABKIQK7eVyXZFTUIQhkRIgmRIgVi5mCikuti1NQlBGBIhCWJlNSkQgSikuthVNglBGBIhCYJyRDmiHFGOKCeU7YKjasKQCEmQDCkQgSikutiVNwnKGeWMckY5o5xRtkXCwUQgCmlvwW2xxfPN9iwEYUiEJEiGFBfCKDvdzCaXXfam0UQh1cXOMicTgjDE3rSYIGhneRIr8+m06vDQeDmMfW/PjB9PkfZs2a/HfnvonrbHYVh1f9fD8fyir/16e+ZhPba97TD02/fGFvzYDL3ZaTWPDreHtlt29dHt7lwvgXxdoNsFSeoBKbJgfHsoJswgcFlUCGUu0KKCyKWgy+ZQw6VQeVGh6DyHm0fy3rlkvRzJGPRWQR+ew51CrOSBxLxgfIpYjknDkvEVJzKn8OgxzIsKUS9XVIr55kpI9xIlzYmyJFEUl4QEWvQp5ilEvbmWSB5eTPcSv1pN4d74cFkNi45CFUygfSv5Ufh9oOI88NXN7bcBnu9t7ctPXBIgmWeQH53BrY/A+c4TQiLWol6Nf24b67fNePXT6WShcbN+HXrf/Dhu337sPfzbYw9+eu3H3Vv/fhx7K82/v9qfPyxhxZWe21O3bRVaiTmdd2VdcYm2SbZZub0yPZ9sYv8B", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 4d7a2feba6c..8f520fe4033 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -89,7 +89,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "tZndTiM7EITfJddc2O3f5lVWCAUIq0hRQFk40hHi3dc17iJwMaPRWHtDfdmMaz013bY1+dg9HR7ef98fz88vf3a3vz52D5fj6XT8fX96edy/HV/O7V8/dg5/tO5u5WanOol3ztSbimkwjabJNO9uA7SYVlPt6p2pN21+ERpMo2kyzabFtJpqV3Gm3tT8xPzE/MT8xPzE/KT5Jah2Dc7Um4ppMI2myTSbNr8MrabaNTpTbyqmwbT5VWgyzabFtJpq1+RMvamYBlPzS+aXzC+ZXzK/ZH65+XkH8AQhNEvvAZGQCJlQCJWgBsUROKrgGhRJaddo0+pMvamYBtNomkyzaTGtpuan5qfmp+an5qfmp5gRnr5mQiFgjnigaACAoAM6eIIQAiESEsF8BIXuMwCjKiAQIgGjFJAJhVAJaoCK7+AJQqAPqlocAG3cshfUdQdPEEIgREIiZEIhwDkA1AAV3sEThBAIkZAIcI6AQqgENUCtd/AEIQQCnBEvCr5DJhRCJagBqr6DJwghEOic6ZzpnOmc6ZzpjKoXPNPiCUKAM55OiYREyIRCqAQ1QLN0oA/aIeApox+kACpBDdASHTxBCIEQCYmQCXRWOqs5B+cIniCE5hwEEAmJgDkHQCFUghpMe8QEniCEQKAP+iK0Sgjoi5ABniAEjMLEsBt0SIRMKIRKUAP0Tgf6oC9CBWCUAipBDdAXHTxBCIEQCYnAaaAdogOoAdqhA/Y6DxBCIGC7Qyxoh2mGiVNFO0yQGS+KPyI6FH+HQIBPAiRCJmDnxAxR/FPymY8Axd/BSjSg1CP+U5R6h0yAz3RNJagBSj3hdrAxoMIDdoYOgWBLZUDxJ5QWir+DGqD4E+4Uxd9BCNjPcTtT8cNwKv4JMsG2gIhSTxngCUKATwFEQiLgaKCA0reAOG0KE6jBtCl4AM4DDhAJidB88nRNIVQCThntduK0KQjAE+Asn583O57x7t8uhwOOeN8Ofe0o+Lq/HM5vu9vz++l0s/tvf3qfLvrzuj9P+ra/tG/bRA7np6bN8Pl4OoA+b66j3fzQdqZSG92OT/plkH46+HmHgoKZDEouG8a3U2vkDJzkTQ4uXx38JodSvhzqtjnkenWYzWHpSUj9yqGtu3MOZXgOCw6tF82glejceF0az1JM0W8Y3456nEA77H1zWG+gLAX5UUxrE4iB7RCrm62DMBjBksG6DJYdRkPQ8nUP8yGU0RDKcAhlNIS1/Zjclo5umx0dYkhzDiJLFjleLfIWi1yZQ3F+011cp9C28dkppOGFacli1cokoyUpwyUpwyW5lMKq1Sn4wRSWDNalsOwwnMKa5Smk0RTScArpXy5P61aGpTnI9dzU3p+EDXfRhpXrXaRNDt/nMJdDXFjfSglc32reUI8rU/DDKfjhFPJYCktr07oUlh3WpLB+DnN3kdxYCn44BT+cgh9PIQ6mEIZTCMMphOEU6lgKOhqCjmagoxHkLUvjXfuwfzxefvzE9Amjy3H/cDrYx+f38+O3b9/+f+U3/Inq9fLyeHh6vxzgdP2dqv35FdubspjqXXtX0z61NyLF3+G3JnzVdvcYHD56fGwvYmL2d5+Y2F8=", + "debug_symbols": "tZndTiM7EITfJddc2O32H6+yQihAWEWKAsrCkY4Q735c4y4CFzOaM9beUF82mVq73G1bycfu6fDw/vv+eH5++bO7/fWxe7gcT6fj7/vTy+P+7fhybv/6sXP4U8vuVm52tU7inTP1pmIaTNU0mqbdbYBm02Jau3pn6k2bn0KDqZpG02SaTYtp7SrO1Juan5ifmJ+Yn5ifmJ80vwitXYMz9aZi2vwSVE2jaTJtfhlaTGtXdabeVEyDafOr0GiaTLNpMa1dozP1pmIaTM0vml80v2h+0fyi+aXm5z3AE4TQLD3WNCkhEhIhEwqhGmRH4FMZn8GiZ3zGNSiO4AlCCAQlREIiZEIh0LnSudK50rnSudK5whmrXBMhE+CMBUZDAAQd0cEThBAISogE8xEUvs8APFUBgaAENJMDJEImFEI1QAd08AQh0AdVLh6Ap9paCOq8gycIIRCUEAmJkAlwVkA1QMV38AQhBIISIgHOEZAJhVANUPsdPEEIgQBnxIsG6JAImVAI1QBd0METhBAIdE50TnROdE50TnRGFwjWNHuCEJpzwOpkJURCImRCIVQD9E4H+qAvAlYZfSEFUAjVAH3RwROEEAhKiIREoHOlczXn4BzBE4SAEQaAEiIBY1ZAJhRCNZjOjAk8QQiBQB/0RWiVENAXIQM8QQh4CgPD6dAhEhIhEwqhGqB3OtAHfREqAMeKAxRCNUBfdPAEIQSCEiKBw0A7qAdUA7RDBxgKQAiBAEPEgnaYRhg5VLTDBInxovgV0aH4OwQCfBIgEhIBU8YIUfxT8olLgOLvYCUaUOqK/xSl3iERmk+cPlMI1QClHjEdHBOo8IBjokMg2FYZUPwRpYXi71ANUPwRM0XxdxBC84mYzlT8MJyKf4JEsCNAUeoxAzxBCPApACVEAq4KDpD7EaDToTBBNZgOBQHgvuEBSogE+EyfyYRCaD6pTUdR/DhqFcXfAc7h8/Nmxzvf/dvlcMCV79slsF0NX/eXw/ltd3t+P51udv/sT+/Th/687s+Tvu0v7d02j8P5qWkzfD6eDqDPm+vTbv7Rdseq9nS7TtUvg/jTwc87ZNTbZJBT3vB8u8UqR+AkbXJw6ergNznk/OVQto2hui+HKpscUrmOYTbJpbWU8pVk27nnHMrwGBYcWjebQSvy2RTckgFzjOq3GLTrIofQLozfLP6HQ2U9yY+KXBuCBvaUFjc7Bx0NQYdD0L8ZQs1fc5gPoYyGUIZDKKMhrG3J6LY0dTsx6aAhzjlIWLJIerVIWyxSYQ7Z+U2zuA6h3QVmh5CG96Yli1Wbk4yWpAyXpAyX5FIKq3anIIMpLBmsS2HZYTiFNdtTSKMppOEU0t/cntbtDEtjkOvlq30JEzbMoj2Wr7OImxy+j2EuB13Y33IO3N9K2lCPK1OQ4RRkOIU8lsLS3rQuhWWHNSmsH8PcLKIfS8EPp+CHU/DjKcTBFHQ4BR1OQYdTqIMpuOEU3HAKbjSFtGV3vGsv9o/Hy4+frj5hdDnuH04He/n8fn789u7bv698hz99vV5eHg9P75cDnK6/f7U/v7R9S6ix3LXvfNqr9qVL9nf4DQtvtW+ZNTi89HjZVlKTv/vEwP4D", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index d898581b331..1d6b0894691 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -89,7 +89,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "pZfBbuowEEX/hTULe8b22O9XqqqibVohIUAUnvRU8e/Pk9wb2kWlKmx6Thrmxo4nMXyuXofny/vTdv92+Fj9efhcPZ+2u932/Wl3eNmct4d9/+/nKvifGDviujOCAiqYwAwW0MAKtonS88QZQQEVTGAGC2hgBdtERZ4iT3ueOhVMYM9LzgIaWME2MQUwggIqmMCel50FNLCCbWIOYAQFVDCByMvIyz2vOCvYJpqvg0/IhKKURMmUQjFKpfh6+ERqoESKUDzZB1MTJVMKxSiV0iAtUCJFKExuTG5MbkxuTG6e7HNvbRIJgRIpQlFKomRKTzangRVsE73VR0ZQQNRF1EXURdQJ6gR1gjpv6ZEJzCDyBHmCPEGeIk+R5y1dnQomMIMFNLCCbaK39MgIIi8hLyEvIS8hLyEvIS8hLyMvIy8jLyMvIy8jz1u6OQ2sYJtYAhhBARX0lQwuvpLRpVCMUikNYoESKULxHhGX6SETq+D0kIk/EyMjKKCCCfQB+RKNj8MoRqkUH5DfhvFxGCVShKKURMmUQjFKpSBZQ6BEilCU4snNJVMKxSiV0iDj23+USMFrR6NSEiVTCsUoeO2o947fevXmmUQovgMEl0TJlEIxSqU0iHfRJKzynpC+3mo85a0gfi1vhUmU4hf1EfrLc5JC8YtmlzmwQbxRJF6v6xW3zqfzaRh85/yyl/Yd9rg5Dfvz6s/+stutV383u8v4oY/jZj/yvDn1s32Mw/61swe+bXeD23V9qw4/l/aNsKG673ltDsi/T+htPSeEem9CDksStM6zSJoXJZTbGGq9MyFpWZIQSmVCqLYgQVtEQBJZUJ+UtzHVsOj6Ya6PS67fDPU53Xf9nJZc3xIXwIotWkGZeyDIsh4I5ZYQFyWY3bpoyRgscBIWltSXWub6RauQbV6FRfewGR+D/iXwywh+H9A4A/m2jL8NkNsq9u+auiQg2m0E+d4R/DQF79YfV8GUq1C/1T/2g83L9vTtZ9/Vg07bzfNuwOHbZf/y5ez535Fn+LPxeDq8DK+X0+BJt9+O/c+D9pFpyo99r+xHJa4tdvevFQ+xH8VS/DD6J1Ppn6yPVx/Yfw==", + "debug_symbols": "pZfRThsxEEX/Jc95sMdjj91fQQgFWKpIUUBpUqlC+fd6du/dwEMrZF44Z0l8ba/H68375nl6vPx82B9fXn9tfty9bx5P+8Nh//Ph8Pq0O+9fj/2/75vgf2LsiNvOCAqYQAUzWEADK9gWSs8TZwQFTKCCGSyggRVsCxPyEvJSz0vOBCrY89RZQAMr2BZqACMoYAIV7HnZWUADK9gW5gBGUMAEKoi8jLzc84qzgm2h+Tr4hEwoiaKUTCkUo1SKr4dPpAZKpAjFk30wVSmZUihGqZQGaYESKUJhcmNyY3JjcmNy82Sfe2uLSAiUSPFkc0kUpWRKT55pYAXbQi/1mREUEO0i2kW0i2gnaCdoJ2jnJT1TwQwiT5AnyBPkJeQl5HlJV2cCFcxgAQ2sYFvoJT0zgshT5CnyFHmKPEWeIk+Rl5GXkZeRl5GXkZeR5yXdnAZWsC0sAYyggAn0lQwuvpLRpVCMUikNYoESKULxGhGXZZOJVXDZZOJ7YmYEBUyggj4gn+K8HWYxSqX4gHwa83aYJVKEkihKyZRCMUqlIDmFQIkUoSSKP1eDS6YUilH82RpdGsS3xCKRgsdOiomilEwpFKPgsZO8dvzWJy+eRYTiJ8AsSsmUQjFKpTSIV9EibOU1Id6p8SMvBVEXoSSKd5pdMqVQvFNzWQMbxAtF0vW63fDofDifpslPzg9naT9h33an6Xje/DheDoft5vfucJm/9Ottd5x53p36p30RpuNzZw982R8mt+v21jr8u2k/CBta9zOvrQH56wm9rNeEUL+bkMNIQqrrLDTloYRyG0Ot30zQVEYSQqlMCNUGElKLCFCRgfaaeBu1hqH+w9o+jvTfDO2zfq//rCP9m3IBrNjQCspaA0HGaiCUW0IcSjC7VdHYGNbb2HWkjizwNlgYGUGpZW0/tI7Z1nUc6d+MN8BsZP79JZQbsb+GfpjB1wMa74B8KqSvBsitjvrbbhoJiHYbQf7uCP41BSn/W4XEVaif2t/3i93T/vTph+fVg0773eNhwuXL5fj04dPznzd+wh+ub6fXp+n5cpo86fbrtf+5S30nJ833/bTuVyVuLXb3F5u72K9iKX4Z/Zta+jfr/dUH9hc=", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_0.snap index fbea9a61f27..0f876c6328a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_0.snap @@ -89,7 +89,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "pZfNbuIwFEbfhTUL3+ufa/dVRlVF27RCQoAojDSqePfxJd8HZQGqwqbnpMEHkzgJfM/eh9fD58ty/bH5mj39+Z697par1fLzZbV5W+yXm3X/7/cs+B8JHTrvFFDBCCYwgwU0sM6eorONlAAK2HvJGcEEZrCABlawjdQACoieoqfoKXqKnqKnvZedbWQMoIAKRjCBGSxg7xVnBdvIFEABFYxg71VnBgtoYAXbyBxAARWMIHoZvYxeRi+jl9ErvdecAioYwQRmsIAGVrCNNPQMPUPP0DP0DD1Dz9Az9Ay9il5Fr6JX0au9J8ElUwrFKJXSIC1QhNK7Ii6RkiiZUihGqZQ2ivr1IuoiFKVESqJkSqEYpVK83Feq+pUzilCUEimJkimF4uXsUikN4tfQKEJRSqQkipfNpVCMUikN4lfTKEJRSqQkCsuR5chyZDmynFj2C0uqi1IiJVEypVCMUikN4lfYKCxnljPLmeXMcmb5tEiai1Eqpb+F9sUWTzfVkwhFKZGSKJlSIMJRfrpVXM67/LarLpXSIH6WNboIRSn+ptmFQT/Lo3hZjsf5jA+Hl/1uGPzZ8ONp0Z8h28VuWO9nT+vDajWf/V2sDqcXfW0X6xP3i13f2+c4rN87e/BjuRrcjvPL6HB7aL81N4zud+F2DuTrgtwuWKoIWLEJ4/vDL3EGQcukQiiXgkwqmJ0LddocSr0Ubh6He2dC6/k4xFBvFezhOdwpxCYIJNUJ41PkYko1TBnfeBpyCo8ewzypEOv5ekgx31wJ8V6ipEuiTEmUygVtQSZ9issUYr25lqQ8vJjuJX61msK98eG8GiYdhWacQP9O8aPw+0DjedCrW9NvA3q5M/WvLnFKQOwyg/zoDG59BL8D37y/W+RarFfjn/vG4m25u/qBc/TQbrl4XQ3Y/Dis337s3f/bcg9/IG13m7fh/bAbvHT5ldT//FELc23y3J+ZfavI3NzltCvXuZbom+KbTfsr0/PRJ/Yf", + "debug_symbols": "pZdNbuJAEEbv4jWLruqfqs5VRlFEEidCsgA5MNIo4u7ThevDYQGKzCbvOaYfjd224bt771+Pny+b7cfuq3v68929jpth2Hy+DLu39WGz27b/fnfB/lBo4FUjOdkZncmZncUpTu2eorFOpOAkZ+slY3QmZ3YWpzjVWSdycJLTe+w99h57j73H3uPWy8Y6MQYnOdnZesWYnNlZnK0nRnXWiSk4ycnO6Gy9aszO4hSnOuvEHJzkZGd0ei97L3svey97L3uvtB4FE4IwJEISJEMKRCAKqS6CsqAsKAvKgrKgLCgLyoKyoKwoK8qKsqKsViaTDCkQgSikutQAIYiVbSHXCEmQDCkQgSikTsJ2HVE0IQhDIiRBMqRABKIQK7eVyXZFTUIQhkRIgmRIgVi5mCikuti1NQlBGBIhCWJlNSkQgSikuthVNglBGBIhCYJyRDmiHFGOKCeU7YKjasKQCEmQDCkQgSikutiVNwnKGeWMckY5o5xRtkXCwUQgCmlvwW2xxfPN9iwEYUiEJEiGFBfCKDvdzCaXXfam0UQh1cXOMicTgjDE3rSYIGhneRIr8+m06vDQeDmMfW/PjB9PkfZs2a/HfnvonrbHYVh1f9fD8fyir/16e+ZhPba97TD02/fGFvzYDL3ZaTWPDreHtlt29dHt7lwvgXxdoNsFSeoBKbJgfHsoJswgcFlUCGUu0KKCyKWgy+ZQw6VQeVGh6DyHm0fy3rlkvRzJGPRWQR+ew51CrOSBxLxgfIpYjknDkvEVJzKn8OgxzIsKUS9XVIr55kpI9xIlzYmyJFEUl4QEWvQp5ilEvbmWSB5eTPcSv1pN4d74cFkNi45CFUygfSv5Ufh9oOI88NXN7bcBnu9t7ctPXBIgmWeQH53BrY/A+c4TQiLWol6Nf24b67fNePXT6WShcbN+HXrf/Dhu337sPfzbYw9+eu3H3Vv/fhx7K82/v9qfPyxhxZWe21O3bRVaiTmdd2VdcYm2SbZZub0yPZ9sYv8B", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 4d7a2feba6c..8f520fe4033 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -89,7 +89,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "tZndTiM7EITfJddc2O3f5lVWCAUIq0hRQFk40hHi3dc17iJwMaPRWHtDfdmMaz013bY1+dg9HR7ef98fz88vf3a3vz52D5fj6XT8fX96edy/HV/O7V8/dg5/tO5u5WanOol3ztSbimkwjabJNO9uA7SYVlPt6p2pN21+ERpMo2kyzabFtJpqV3Gm3tT8xPzE/MT8xPzE/KT5Jah2Dc7Um4ppMI2myTSbNr8MrabaNTpTbyqmwbT5VWgyzabFtJpq1+RMvamYBlPzS+aXzC+ZXzK/ZH65+XkH8AQhNEvvAZGQCJlQCJWgBsUROKrgGhRJaddo0+pMvamYBtNomkyzaTGtpuan5qfmp+an5qfmp5gRnr5mQiFgjnigaACAoAM6eIIQAiESEsF8BIXuMwCjKiAQIgGjFJAJhVAJaoCK7+AJQqAPqlocAG3cshfUdQdPEEIgREIiZEIhwDkA1AAV3sEThBAIkZAIcI6AQqgENUCtd/AEIQQCnBEvCr5DJhRCJagBqr6DJwghEOic6ZzpnOmc6ZzpjKoXPNPiCUKAM55OiYREyIRCqAQ1QLN0oA/aIeApox+kACpBDdASHTxBCIEQCYmQCXRWOqs5B+cIniCE5hwEEAmJgDkHQCFUghpMe8QEniCEQKAP+iK0Sgjoi5ABniAEjMLEsBt0SIRMKIRKUAP0Tgf6oC9CBWCUAipBDdAXHTxBCIEQCYnAaaAdogOoAdqhA/Y6DxBCIGC7Qyxoh2mGiVNFO0yQGS+KPyI6FH+HQIBPAiRCJmDnxAxR/FPymY8Axd/BSjSg1CP+U5R6h0yAz3RNJagBSj3hdrAxoMIDdoYOgWBLZUDxJ5QWir+DGqD4E+4Uxd9BCNjPcTtT8cNwKv4JMsG2gIhSTxngCUKATwFEQiLgaKCA0reAOG0KE6jBtCl4AM4DDhAJidB88nRNIVQCThntduK0KQjAE+Asn583O57x7t8uhwOOeN8Ofe0o+Lq/HM5vu9vz++l0s/tvf3qfLvrzuj9P+ra/tG/bRA7np6bN8Pl4OoA+b66j3fzQdqZSG92OT/plkH46+HmHgoKZDEouG8a3U2vkDJzkTQ4uXx38JodSvhzqtjnkenWYzWHpSUj9yqGtu3MOZXgOCw6tF82glejceF0az1JM0W8Y3456nEA77H1zWG+gLAX5UUxrE4iB7RCrm62DMBjBksG6DJYdRkPQ8nUP8yGU0RDKcAhlNIS1/Zjclo5umx0dYkhzDiJLFjleLfIWi1yZQ3F+011cp9C28dkppOGFacli1cokoyUpwyUpwyW5lMKq1Sn4wRSWDNalsOwwnMKa5Smk0RTScArpXy5P61aGpTnI9dzU3p+EDXfRhpXrXaRNDt/nMJdDXFjfSglc32reUI8rU/DDKfjhFPJYCktr07oUlh3WpLB+DnN3kdxYCn44BT+cgh9PIQ6mEIZTCMMphOEU6lgKOhqCjmagoxHkLUvjXfuwfzxefvzE9Amjy3H/cDrYx+f38+O3b9/+f+U3/Inq9fLyeHh6vxzgdP2dqv35FdubspjqXXtX0z61NyLF3+G3JnzVdvcYHD56fGwvYmL2d5+Y2F8=", + "debug_symbols": "tZndTiM7EITfJddc2O32H6+yQihAWEWKAsrCkY4Q735c4y4CFzOaM9beUF82mVq73G1bycfu6fDw/vv+eH5++bO7/fWxe7gcT6fj7/vTy+P+7fhybv/6sXP4U8vuVm52tU7inTP1pmIaTNU0mqbdbYBm02Jau3pn6k2bn0KDqZpG02SaTYtp7SrO1Juan5ifmJ+Yn5ifmJ80vwitXYMz9aZi2vwSVE2jaTJtfhlaTGtXdabeVEyDafOr0GiaTLNpMa1dozP1pmIaTM0vml80v2h+0fyi+aXm5z3AE4TQLD3WNCkhEhIhEwqhGmRH4FMZn8GiZ3zGNSiO4AlCCAQlREIiZEIh0LnSudK50rnSudK5whmrXBMhE+CMBUZDAAQd0cEThBAISogE8xEUvs8APFUBgaAENJMDJEImFEI1QAd08AQh0AdVLh6Ap9paCOq8gycIIRCUEAmJkAlwVkA1QMV38AQhBIISIgHOEZAJhVANUPsdPEEIgQBnxIsG6JAImVAI1QBd0METhBAIdE50TnROdE50TnRGFwjWNHuCEJpzwOpkJURCImRCIVQD9E4H+qAvAlYZfSEFUAjVAH3RwROEEAhKiIREoHOlczXn4BzBE4SAEQaAEiIBY1ZAJhRCNZjOjAk8QQiBQB/0RWiVENAXIQM8QQh4CgPD6dAhEhIhEwqhGqB3OtAHfREqAMeKAxRCNUBfdPAEIQSCEiKBw0A7qAdUA7RDBxgKQAiBAEPEgnaYRhg5VLTDBInxovgV0aH4OwQCfBIgEhIBU8YIUfxT8olLgOLvYCUaUOqK/xSl3iERmk+cPlMI1QClHjEdHBOo8IBjokMg2FYZUPwRpYXi71ANUPwRM0XxdxBC84mYzlT8MJyKf4JEsCNAUeoxAzxBCPApACVEAq4KDpD7EaDToTBBNZgOBQHgvuEBSogE+EyfyYRCaD6pTUdR/DhqFcXfAc7h8/Nmxzvf/dvlcMCV79slsF0NX/eXw/ltd3t+P51udv/sT+/Th/687s+Tvu0v7d02j8P5qWkzfD6eDqDPm+vTbv7Rdseq9nS7TtUvg/jTwc87ZNTbZJBT3vB8u8UqR+AkbXJw6ergNznk/OVQto2hui+HKpscUrmOYTbJpbWU8pVk27nnHMrwGBYcWjebQSvy2RTckgFzjOq3GLTrIofQLozfLP6HQ2U9yY+KXBuCBvaUFjc7Bx0NQYdD0L8ZQs1fc5gPoYyGUIZDKKMhrG3J6LY0dTsx6aAhzjlIWLJIerVIWyxSYQ7Z+U2zuA6h3QVmh5CG96Yli1Wbk4yWpAyXpAyX5FIKq3anIIMpLBmsS2HZYTiFNdtTSKMppOEU0t/cntbtDEtjkOvlq30JEzbMoj2Wr7OImxy+j2EuB13Y33IO3N9K2lCPK1OQ4RRkOIU8lsLS3rQuhWWHNSmsH8PcLKIfS8EPp+CHU/DjKcTBFHQ4BR1OQYdTqIMpuOEU3HAKbjSFtGV3vGsv9o/Hy4+frj5hdDnuH04He/n8fn789u7bv698hz99vV5eHg9P75cDnK6/f7U/v7R9S6ix3LXvfNqr9qVL9nf4DQtvtW+ZNTi89HjZVlKTv/vEwP4D", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 293967ebbc5..66d8c30729e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -157,8 +157,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "17": { "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap index cbc3f08883f..899f7940feb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_0.snap @@ -157,8 +157,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "17": { "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index b2ffb7f621a..2c44be4db69 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -157,8 +157,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "17": { "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 293967ebbc5..66d8c30729e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -157,8 +157,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "tZ1djh03DoX30s9+KP2L2UoQBE7SGRgwnMCxBxgY3vuIRzzibWDasFmYF+tr+94jkUWxJEoNf3n64/m3z//69d2HP//65+mnn788/fbx3fv37/716/u/fn/76d1fH9bffnm69I9U6tNP6c1qm7Xd2mHttFZ2Wy9rk7XZ2mKt6VXTq6ZXTa+aXjW9ZnrN9JrpNdNrptdMr5leM71mes30uul10+um102vm143vW563fS66XXTG6Y3TG+Y3jC9YXrD9IbpDdMbpjdMb5reNL1petP0pulN05umN01vmt40PTE9MT0xPTE9MT0xPTE9MT0xPVl6+c1Tvi5rk7Xr+0Xb9fmq7fp801Z2my5rk7XZ2tVf13Z9fmi7Pj9Xmy9rk7XZ2mLtGp9oq/ZdC4oamBQSIRMKoRLUKh02wlTHjTjVgSNQAYVQCeobHTSCFTAIk6DjUYMQsIBEyIRCqIRG6IRBmAQqdyojdtVpCF5AIVRCI3TCIKiy+hIxrIAgBiSCKqufEceASljKWT2vobxhECZBDDScNyTCUs76LDSiN1RCI3TCIEyCKusT1MDekAiZUAiV0AidoMoaABrgG2RDQYgDEkF1qoJ+qynot7qCGGigb0iETNDeh4J+ayrot5Yzi4b7hkTIhELQKXYpNEInDMJSLklBDHRebEiETCiESmiEThgEKhcqVypXKlcqVypXKlcq6wQpy/NFY76oVzXCi3pVI7yoVzXCNyRCJhRCJTRCJ+iY1eEa4RvEQCN8QyJkQiGosj4mjfANnTAIkyAGGuEbitml8Vz0KWs8b+iEQVAdfbgazwCN5w1rhFWfqcbzhkKohEbohEFYylUdrvFcl8OrxvOGRMgE1SkK9iyqRm8FZEIhVIJ+qyl0wiBMghhohG9IhGx9aYRvqIRG6IRB4AgR4QqIcEDZoVU1nmtXaIRO0BEOhUkQA43nDYmQCYWgylNBddZjqprn26WwPtOSQiU0QiesbzUdocb8BjHQmN+QCJlQCNX60pjf0AmDMAliMDhCjfkNmaA6+tw1wjcMwiSIgUZ4Uz9rDt+QCYVQCY3QCWMnvTonQQyQwwGJkAmFUAmNoCPUQNIIV2ga4RsSIRN0hF2hEhqhEwZhEsQAWV11kNUBmVAIldAInTAI00BnQRsKmVAIldAIOsKpMAiTIAY6CzYkQiaUvchpWP8AGqETBmESxIBrpIY1EkBHKAqN0AmDMAligJkCSIRMKISl3C8FXRcmhU4YhEkQA507GxJhKfesUAiV0AidMAiToMpqqc6dDYmQCYVQCY3Q96K0YXUPmARbrzYs8AGJkAmFUAk6wqowCWKgc2dDIugINcZ07myohEbohEGYBMFKvOtkQpuszdYWa6u1zdpu7ditTpneFRIhEwqhEnRg+FYnDMIkiIG+SjYkQsauo+scQlutbdZ2a4e101rZrU4ebTWM+1QYhEkQAw3jDYmQCYVQCeqcpNAJgzAJYqBhvCERMqEQKoHKncqdyp3KncqDyoPKg8qDyoPKGsYjK3TCIEyCGGgYb0iETCiESqDypPKk8qTypLJQWagsVBYqC5WFykJlobJQWUx5XBdBlatCJhRCJTRCJwzCJIiBxvwGKicqJyonKicqJyonKicqJypnKmcqZyprkI+moN/qCvqtNS+GxvWGRMiEQqiERuiEQZgEKlcqVypXKlcq62tiTAVVFoVOGIRJEAOdXxsSIRMKoRKo3KjcqNyo3Kjcqdyp3Kncqdyp3Kncqdyp3Kms82uu/Dx0fm1IhEwohEpohE4YhElQ5TUZh86vDaqjQauzaUMjqE5RGIRJEAOdTRsSIRMKoRJUWUNLZ9OGQZgE2TB1Nm1IhEwohEpohE4YhEmgcqJyorLOptkUCqESGqETBmESxADVJUAiUDlTOVNZ59fsCp0wCJMgBjrjNiRCJhRCJVC5ULlQuVC5ULlSuVK5UrlSuVK5UrlSuVK5UnkvTrLSPITlyYqBudcn6vS9QAFhhaI+2UsUENYoqodS5DWU+iH0MZXmISGhKLkJfYhSPoSy3aWEul1Saoe0D63hTZQoN81DYiQX6oJFKR1CZbAqoY+mVA+hj67UD41D8xD6WFZKug6hj6mEPkSpHNI+tPolGq1G/dA4pH1omUs0YjdpyCYtWYnGbNJ6lGjQGmkfWpqSXA+1Q/0Q+lAr8zyEPtQi1FC1QiUoom5CH2oRthGb6qF2CH2olbu4CsJeQi3amwm1Y+8mQOlQPoStilqJquumdgi7FbUXhVfd9Asqr1r2EZReQai9bkIfahuqr1qgEZRftfoiqL9uaof6IfShdqAGu0lIqMJqpUVQhtVSi6AOqwUVQSF2Uz3UDmkfWm8RFGM3zUPahxZYBPVYrZUICrJawBBUZDeVQ/UQ+lArsQfZNA6hD7UN81zrF4J5rsUAwTzflA+VQ9qHFjEE83xTP4RCuNqGea71AsE8162/YJ5vSofyIfShVmKeb2qH0Ifahnmu+2HBPNetrWCeK6ULE90wOaIbARZHFN4vIErvCdgdh+N0RAk+K2LKGyZHlPgLEEX+CkRvDdgcuyN660D0NoDoDVZg8hsmx+yI3mAbEoBhc0T5HxYjBwwYhCQwMHRkgY1IA4bJEYcMsA2ZwLA64qgBFiMZDNiGbDBgG9KBoRxEQjBEbzAeKcGwOKI3WIysMGAb0sKEbcgLhtNRDiI1TBiP3GCYHbW3CYuRHiZsQ36YsA0JwnA4Tkf0BuORJAyTI3qDxcgTE7YhUUzYhkxh2B2HI3qD8fvwBriPbzZqbwKL9xEObNuHOBurY3PU3gTGI2sYTkftTeASJA6BxcgcAtuQOgyLI3qDxcgeAouRPgQGIX8YTkc5iBQisA05xDA7ahnugsUoFV4wCMXCC0PHkY/hcJyOOKxS2xKOfgyTo5b8dCG0EL01IHrrwObYHYcjehtAOYjioiF6m0D0JkAckV3A6tgcuyOOyhJwOspBHDXp0mih9pZgG46bEmzDgZNhdWyO6A3G5+E4HdEbLC7oDbYV9AbbSnYsjtURvcH40h21twwzNZfkDIOKHKyXY3LMjsWxOjbH7jgcvbfqvTXvrXlvzXtr3lvz3jRrYJbiUoKRkDRlGKVD+VA5VA+1Q3ooDvdorjBafWBy46oCZjEuK2AS47qC0eoDsxlXFjBtcWkBsxbXFoy0DzxPzRCYnLi8gFmI6wub9v4BQ9gbCIxh7yA2Fsfq2By743CcjnJw7yQ2qoswLOxnN7VD/dA4NA+JEe43GNVD7VA/NA7NQ0clHRVsYTdpsOmSdGF3HI7TUQ5i2homx+yowaYL3IUabAW9YdrqgjXhygRxOM6DmIq6xUi4KUFsjt0Rk6MCp6Mc3FNxY3LMjsWxOjbH7ui9Ve+tem97pjUgvgaXtOl/i8/COx0jg3d6csyOxbE6NsfuiJHBfX06ysGB53YB8dwSEM8Nnhx4bgWI5waDcLtiWzHcINyw2IiLFBW6uEphqGIVXeA6RUUXuFBR89evb554tevXTx+fn/Vm18Ndr5+/PP399uPzh09PP334/P79m6d/v33/GR/65++3H9B+evtx/evq6vnDH6tdgn++e/+s9PWNf/t6/avr2H/atxfKEWjfryC6FtwKa0cTUhAqrLPwyBjqVa6j0GtIwcew3pcRBezkTKHHFOaxYr3aIwpZd52mMEZIQY5CKaEx1HIUaige1tF9oUKbLaLQdVm4FdbhUkhBc7ApjBJRGPr+2wqrlh9S0F2sKcgVUZj5WLEqjqExeDysgmtoDM0VYlbIPJ5cqSKk4HMzlqPaVRlRbW1EQwo5uUIkHhoqvFthrZxDCiei2lrwhRTk+CGHZlbL/SiUEomHVqochRFTOBHVago9i9qYo1rLKaLQyjgKMSv6yZMLQzE58nkW66AvoNCvizOrrzpURAHb0a1QrkiGWamaVvQaG0M92b7Xke8qzJAVOFvZCimUYfo1hyu0uwp9hJ7mYIbpWUKexE7pnsJ1PLlqSaGIyu3EZEs3rShXKMMMObl6HYfeVYjlB/E3zjoZiyjMfrLcDK2K25wnR0nsfSGeJyW0x3nhh9DuYL1m5nnj1JAV9axpl1joaWKza+/uUFQ3z9Xr7R9aifVxVoN9hnZJ3VfFPZSra5m+QwlFdS1nz7vEYmPo865Cba4Q2qHUJr5Ti+0WTzzUHNstopbPPW/Iiqt79SC2W7zOWm6JRcYw89kdrE2SP800v1uhcmpKfjU76NHhawKrlMuX3ira+sJ81VMeJcY3xrAKqoyHVVG9QhI45t8Sq1wdksgnrle+yq9KlG8UlDwklkIPjaKcXLkwhyTq2TrndsVGUU9YLK+kkEQ/W99VJx0xiZKPRG0xicEpthaI5b5E8KGOeh7qjD3UcqoZ+THr/pBEPYaUFpOo15mp9WE98kOjkDOK+np0fmuJK6fA1SWN15Ke7ij+f3mz5EwzykoXkepz9gr4OhK4qzCvmMJJWFlqSOHUr1fmum4ryE0rggqlXkehlbsKPYcUzk6+lNFDCsMVJN9UWEciN62IKaxj4nwWFPm6rTBiCukohNaXay3kY+jXbYWYFc2tGDErki/uRgspnFrAOpy/bivE/CDHD5Lu+kFCddskxa0I7cNfKoyYgvuh3fZDi/lhuBXzuq0Q88NwP8htP0jED/k6OWqVCq/bCiOmcFb5V7nph6UQ80PL/2vvF1WI+aG5H0Jnri/8EMq0+RJXkHlTIV3tphUpdCKSk+/YUijLvVQYMYXzNGPnGTkNH8O8bivErBhuhcSsKP40Yzkqe4bJobPGlwozpnD8kGMZ5sEPuYSiOp86Xc6htf1LBYkpuCdHv+uHUNU1Z/EyxlXuKoR2i0vBixhp3PRDSaGYLF5sLLXeVQidiCwF92Sbd/0QOp1aZa2HmlS7qxDasS4F96Tc9oOE/FBT86pYvasQqiY9WlFLyJP1VFHyOuu6qxBaRy2FEw819uatMr34Pe4qpNjTPBWtHLujs/zQXCH0NNupw+RW512F0F5vKbgne77rh9AJ2SqRnnnRQue+LxQkNC/aqarlfpWbfuhXKCb7uQW4jlWu2wojpnD5eU6964caikk/xV8HO+m2wowpuCdj781HP4RufeVx+alWyrcVJKaQ/WTtrh9Gjvmh+hhiK7EXCvOuFbGV2Dh3lfKQclNhhuq0S6G4Qig/zHP7Lceq7i8UaoopuB9i780xsyuEnubsZxUUq7q/UAjd8lkK7skpd/0Qun+f5TrrqNgtwBcKucQUjidjtwAf/SCxtb3/FkGWNu4qhH5PaSm4J2PvzUc/hO7PZZlnHSWxvZ4rlCtUI10K58z9Cr43jx+WQuis2X/rbKHcVaihs+YruyfbbT/Eztyv7mOI/Qbgo0JsJfZoRWgltrIrZ9bChwt033+HTzJz1JTHe1IvFXBj5fvyfQqNYlxnFCNyp0b8PGrl7RYaw/k9gikP66AfGkM9Y3g4l/shhewK6a5CiY3h1BflquXus3jYq/2IwnnnrKcZs+K8c4LxUPq5x1j6fPVaaFZvvRpTZ5Py+HuIq/T8vWMY/dwUm9erdym/qeD3m6IK5zfXggr9XJjrj1cHv9sL/fziW58z9H0ml3G97P+X9dPb3999fPG/lXxVpY/v3v72/tl+/PPzh98f/vXTf/7mv/B/O/n741+/P//x+eOzKvl/ebL++Hm2+matxH9585TWT2mtZ9+seutYPxf9eUVISln/VT+svx3Xy9Qf8en1XlifTtcvX3Ww/wU=", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "17": { "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap index cbc3f08883f..899f7940feb 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_0.snap @@ -157,8 +157,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "H4sIAAAAAAAA/+1daZAsWVXO6sqqXt7rrur33rxtXAZwFzWzsqoyy7UH3pvHG1xGcWdUspZUVHBAEQSXZHEQGEUYcAFZHEREFEFGYVDUHyOGoRFjTASIASGhoTEGYYQ/+OcPNc+8PN2nTp28mfU6b3Uf7BtRXdV5T5773bPce/Pmvec2nBvpoezTyH+7+fd6/g3X95z5hLR43Ttc8mvk5dnC2FCAcU0BxqYCjK4CjC0FGNsKMK4rwLihAOOmAoxbCjCeUoDxtAKM2wow7ijA2FGAsasA464CjGcUYDyrAOM5BRhvUYDxvAKMFxRgvKgA4yUFGC8rwHirAoyfpwDj5yvA+AUKMH6hAoy3KcD4BAUYn6gA45MUYPwiBRi/WAHGL1GA8UsVYPwyBRi/XAHGr1CA8SsVYHyyAoxfpQDjVyvA+DUKMHoKMPoKMPYUYAwUYOwrwDhQgHGoAGOoAGOkAONIAcavVYDx6xRg/HoFGL9BAcZvVIDxm2rEuIq1kHsKZHq7AoxPUYDxqQowXlGA8aoCjHcowHhNAcanKcB4XQHGOxVgfLoCjN+sAOO3KMD4rQowfpsCjHcpwPjtCjB+hwKMz1CA8TsVYPwuBRi/WwHG71GA8XsVYPw+BRi/XwHGZyrAeLcCjD+gAOMPKsD4QwowPksBxlgBxrECjBMFGKcKMM4UYEwUYPxhBRh/RAHGZyvA+KMKMP6YAow/rgDjcxRgfK4CjD+hAOM9CjA+TwHG5yvA+JMKMP6UAowvUIDxpxVgfKECjC9SgPFnFGB8sQKML1GA8WcVYPw5BRh/XgHGX6gRI2DbB2oJb6pApi9VgPFlCjC+XAHGVyjA+IsKMN6rAOMrFWD8JQUYX6UA46sVYHyNAoz3KcD4ywow/ooCjK9VgPFXFWB8nQKMr1eA8X4FGN+gAOMbFWD8NQUYf10Bxt9QgPE3FWB8kwKMb1aA8bcUYHyLAoxvVYDxbQowvl0Bxt9WgPEBBRjfoQDj7yjA+E4FGH9XAcZ3KcD4ewowvlsBxt9XgPE9CjD+gQKMf6gA43sVYPyjGjECtjVnPtWN930KZPp+ZTL9YwUy/YAymT6oQKZ/okymf6pAph+sWaaIEWX7IefGObP7/ziMCA4GhYM34WBLODgSDmaEgw/hYEE4uA8OxoOD5+BgNzg4DQ4m62YfOFgLDq6Cg6Hg4CU42AgODoKDeeDgGzhYBg5ugYNR4OARONgDDs6Agyluyz5PyD5PzD5wMAAE3ofA9hA4HgKzQ+BzCCwOgbshMDYEnobAzhA4GQITgzYgsC4EroXAsBB4FQKbQuBQCMwJgS8hsCQEboTAiBB4EAL7QeA8DEx3e/Z5SvaBYGAQbAuCWUGwKAjGBMGOIJgQBOuBYDgQbAaCuUCwFAhGclf2gWAaEKwCgkFAsAUIZgDBAmAzPmx2h83ksFkbNkPDZmPYzAubZWEz6rOyT5x9xtkHNgPCZjvYzAabxWAzFmx2gs1EsFkHNsPAZhPYzAGbJWAzwj3ZBxbTw2J1WAwOi61hMTMsFobFuLDYFRaTwmJNWAwJiw1hMR8sloPFaGn2eWn2eVn2gQVAsMAGFrDAAhFYgAELHGABAbyghxfg8IIZXuDCC1J4AQkv+OAFGrygghdA8IIFXmDACwKYgIcJbphAhglamACFCUaYwIMJMpiAenv2gQkUmKCACQB4wIYHWHhAhAcweMCBBwgYoMMAGAaYMICDARIMQKBTh04TOiJo6KHxhMYJHB4cCpPoBM6BE38qP3V5k9FDfo0H5vqbrNw6+Ue+N9h05lPN+IPNnOeGFf7jCPlv2sHv4aHaT08P+NO6YLmIw4qevP7Ybj373jarm0PqgmVv2Snbb7DynJy/w+SJ5W85Nm3qxsHhtDzEw+WDPr+NNOkBngbLc9PFemBei+ShfqGchNBx20IcqBsb7U/kRSd25+iyO57npov1WNbuqG1xu2takEXkTSzbXXCEdhd8Ttpdk+W56WI9lrU7KhNud64FWUReYtnuvN7R2Z0XfC7ancvy3HSxHsvaHbUtbnctC7LI7G56Yne67K7F8tx0sR7L2h21LW53bQuyyOwuObE7XXbXZnluuliPZe2O2ha3u3ULssjmHfwTu9Nld+ssz00X67Gs3VHb2iB0zyO/X0xo6LMIrUNDqIPV5xP/YF7LxjjUy+338TqmB/xNz3Z8/E114BJ5Jkw+VuYNiHxsyB/kc7YAP/6GtJ46+6nJ5EllhDLboPQsb5Pkuel8OVv5/y4ph/JCHC1Gf0/+fyf/bpN78P6uUH6blT+HW7hGZcR5NYVrSA/9wrPz3/AuB335qekBvzrngpD/FSv8/X3+V63w93rI/w47/PffBVyzwj8eIf+n2eG//67huh359JH/nTl/pzpvv4w52D+0nw+S9z60f1uirNKE/SPtr/nY5ZRjRUdx1bELlr/lWB1L7Y9dTjE8XD683z9tRz6jBuNP8ZwW5IO63BbykNdO/n+L8KL0p0kdKT39jffTa6/Ov7sCz02GYdtZrA+9RvuEV7C6Ud00Cr6RL7+2xjBS2aB+O86ijXF/sKPvGwsjqCywj+dlbpH6cFlTObbYtfvzb2hbPuzO108ar28ZZNeoKDvuK9uWZbcjyG7bILuq9v3mGmW3VlF2++MlAasN2XUE2e0YZNchefibyg6vvcOpT3bNirJzmew6lmXXFWTXMciuS/LwN5UdXntPjbJzK8quxWTXtSy7XUF2XYPsdkke/qayw2sfqFF2rYqyazPZ7VqW3RlBdrsG2Z0hefibyg6v/ZlTn+zaAh7TuHPZ/nxTqFudsu46i3o+w8o+y/DVVLbP5xZp2SDXh8l1Ok6g4zs674bP0y1G/xb3gOff5Nc6QtlbBeU5JeXxsU1boOf4Kf3f599A+5Ecq6QXvF9ax0Ll9girxwYpV5rr43JD+nuJ3B7Nr6HcpH6el+eQ8taE8ric2wI9x0/p/zH/LpPbKtb4ZCko08snHVlORXq5ks7XG+mfSfTyz/m1DqmPw2Rgd+1gzzP5i7T2wOQvlL7IX/4t/67LXx5juJqkXEkvV9N5XEh/hejlM/k1k16Qr0t4cznQ8kz+Qvm7zjw+pP+v/LtMbm4FfOvkGs7TdQxYTDayLtS1I9zP9UnvQ/1Yfo6t/E4Ky99iWGvG41eV6xqTnTQvIs1v0LrRPFqONL8h8XIZBoqZ68/Ss3RYVX9Y/pZj1Z58k1xPC3JF2e0IWLtCHp+f2hHK2RHKOeFVHy/uc5gvfWM5/JrJr3i7aPIrS/Mslee7sfxV+ZWkP5NfdQSsXSGP20lHKKcjlGOb19ljiuukjjdXR97eY770jeXwa6Y2Cn2Bj5sg7eXfXhTMwpHvT6Ng4I3CYW+UeN4wHAR+MvEHkziZhqM4Go1ns8k4GI28IBmOBmFvMgyGST8exHyekvL24zAZzJI4noZJkDHrDeKRHyWBN5lE0zAIgmQyicdhlj0ZeYnfn84ifzyZDHpRMhoFg6k0jzeH/ZCJz3XN8R704zgaxmEwGUdx0B/0BrPBeDybDmf9YBz7/iiaRUMvGSTBaOD1hlES+tOkPxj54+msf+M9N/A+J/DueaPpJBknvezPIExGydDrZ9LsT0M/ngyTOInCXlZ8Mgn7Xjjx+rPxsOfHw14UTuKJ3xui3dxCePO+4Dy5fhRjLCx/i2G11RecZ3i4fHhfcEHA2hXyaB9G82g5F4RyJF6dGnl1a+S1WyOvcxbqaGq//CDwPS/znGSaBINw1Bv7WdOUeVMSDqP+NMn8aBrO/H4c9EazMGtlotksa90m4TDJnHCYlM0fXGnM1wd1WHX+AOn/p3nA81p+Az4H0+fH/bVUhjp7h0s909pF7Odckldn+wHzE3+VPyzycdnjciPl8rbZ1M8i/TmBnvLAdTVdZ9FeeX9p6bl+IMm/Q8qG5KZWyhblP/cuKl1Onlz+twj0VMYo066z2C9ssjz6HIRldhgtHfPw+QWHyK03TaLxqO/NBtHIm/VnfhCGM28QhEESz4aj2J+Gg342tgkGs6zTj7zxcDgc9cN+Ng7qTaaTqeX3sUPJJui+aUhuaqXsWLIJqnduEyYdQ+I2YeqbqUy7zuLYhbeH0lqy3mwyjaKpPxgNw/FkEIyjKBuH9Wbe1B9Gw6Gf9QGT8TCOJ71pkESDWS8bR4WzWTLuTfxRNgC2PS8l6fYcqRckN7VStqhbqj+u26rjKFP/LulP6t95XABL+xwiSf63kLIhuamVspf2LUn+Jt8qkz9vU6XxlfTsiGWanlFRb5bG9v0GKw/rSK/R8reEeth41qja/ll+FhuZbGDXgOeiHTxDxHNJwCPNqwLGtrNoQ1Re1F4p7kuEP14rGq/Qsvn7LPrsg/d2nEU7OsXy6JiGv/PDutBnBIrrWnqQT+nvzY0a2oyPkzbj8bqkB2XQ8Q4kl+TVuI73yPsOlFmVZ1ZpLpjK/A6GFe9vO/I4la43pvSvIzr6iCvzpHqnuLjekf4NFfW+mj5L1nudzwimPo7KTBoPcn9vCrwkf+dY2wI95ddi9G8z6P0cuUd6x8/1jvQPVNQ7yvIo9L7K5wCUmaR3l+XRNfB8zqnMJq6m8/TIu6pNIP17BZuQ1lzg/WVzTe9vyPVYdq3KY2Su6cH8BhtrVVoEe1Pgz9eqIP1DFeXG1xQUye3Pa5LbPxC5/eUxlNvDS8qNy4OutaWYefuE9H+bl2czrgckuv7VYWVJe2QbNZa9Lcij4divt59NQTVYeY4jP9/s74l1FvVr4/mmxfBw+fDnCRtxNzL57K89bAt42oJ8+NpsrjvartO2QVoHv+w+m0/kCjO1/w2W5wgYsGwnx/JoY75utF1pFHw7zqIdUb7SnhS+78SKjfkH71wt+ZRX1ld8mvUVqO+ivgL3+bYY/TtJX/GvrJ204w9xad3+ndVtq6Ru11ndkP75pG7/wfpBbheQTLZpt+/o3XQb2rSC5/i2oVKb0xTw7DoHbR/VmbQX5jZyrajOtAw+90JtqcXuo2W77LfURtU3Jggi3jZs5WWZcFWR8dV0vv7S3iypT2oV1L9lp/77NnNKqL+pb6X1d51Fuyna090uoKftF6X/39yxpWdxaQ889XW0844BX5PRcjqqgzar017+v3eo1ItMOijCRfMcR9ZZFR1I+6C5DjbyjGV1AAn7nY4BX1PAy59xpBhVNepgYW821UERLl5/SWc7jJ7ORUr0yI/PG+4adCDNh1I/wPfwHQO+JqPldFQHfK5nL//fO1TyI5MOinDRPMeRdVZFB6cEeXEdXD6EDvC9d8eAT5qPonRUB9y39/L/vUMlf2GfPdVBES5ef0lnfD2cpIN1QSZcB08y6EBap0t1gPOtHQO+JqPldFQH66xOe/n/3uFSZNJBES6a5ziyzqroQNqPwnXw5EPoAOe1OwZ8TUbL6VzHbHemuC77scUK6LndIX0g1NnyWobRzcqU1sckU76ni9sRtbtNRruC+sfcTqvWn9r5rqH+nYL6d0rqz8fCdJ2SZFNV/E6yWe53txts0NJ6pnFVHfC21aSDItmU6YDex8fCUttXpOsiHUi+wXVw5+rbgclx9QM+Fl6VHzxj9X4wPa5+wMfCq/KDu1fvB7Pj6gd8LLwqP5it3g+S4+oHVcbCNvzguTc5FoZ0Jb3x3THgawp4+Vhs1Xb3gpXbne8fV7vjY2FL9e8hnjNL1p+unTtjqP9uQf13S+rPx8KS33UKyqGY2gX03O+Q/uUGG7Szb8MPquqAz/WYdFAkmzId0Pv4WJi2O5LOquhA8g2ug/tW3w70j6sf8LHwqvzgjav3g8Fx9QM+Fl6VH7x19X4wPK5+wMfCq/KDd63eD8Lj6gd8LLwqP3jf6v0gOmo/cByznVa1a7qfgNJ/aPUyHd2sTGl9TDKta6zt2ql/XLX+Lqv/tqH+riA3Xn9p3l1aN9NgeY5TzQbpWmSJHvnxtcgfNdignbVe/lhquyQdYPlV3n20CmRTpoOitVE0z3FknXEd4P1tx6xjvgbxEYMOLPnBROrDq/hBW6i/5Ad8nQ2XUZEfmNbkV9EZ3t92zGu9+FrJT6zeD6YcM5WlyQ+ktVXNEtmU6YDex8fa0lqkIl0XtUWuwJ+3Rf+yej+YcZlQWZr8QJKz5Afc9riMivyAj7UlP1grKKeoLeJrfhxnsS36jEEH9P4adZBU1QFf82fSQZFsynRA7+Nj7TI/qKIDkx8g/WcN886mtbkN5yB+c5W1uZJ9cxmV2V3TkfFVtTuk/2+hztvOotwbBd9YL36Nr8+mc/R7+bd3uOR3DXLZdhb11mCYbKwZX2ZNPe0P7PV3B2vqJT+n8lljslsXsHaFPB5LbV0oR4q3fMLrePE6+/+gjie8Tnid8DrhdcLrhNdx4GV7LLpN8GLCfYRQ5h1NuU7SnleKs8Xo724e8Lye/+4I968xeUn7ZhwmC8c52FNJ6RsGXpsCr1YB7zJcu4fERevvCrzWDLjwXkmP+HtTuK/G54fK57rgtS2h3jaeZ5oMD5cPf55xBazSGYmmdwJN4dqagRfmwbyStEeG656f20dp+bwIj68L3/wcKfob57Zo3BRKw88SQ/pxLizI/ydX5knbi/UKPGeE58cZT2luXHpORXrpfYa0jlHaJ8bfZ1DsdB8iv4b6kc7UchiGtRLeHBP35XVGu874Snspi/6X5CLNo/D3AVJfR30N+xQpxgLeS/sbU4xAvJ+vS4REz43n9i3FEaM8rqUH+ZT+hQZblGJ0SbEYkb4sRhePw0xjb+G9/FwFrOde/u0dMh1dTFK/8tzYcYhJKunZbkxS3wOdS7HVXUE2HAdfc7JLsEs+eyWdp5fiELYN/BFHu4Ce+iOlfyXxNz7nLJ21Cjxf1ZTrJsUhonXj66xfS8ap9zGe0vvAqm0cff/J48hI66urxD8tiq3J17Ug/f2CXE3tkqkdK4stys9CpjZ5geWZ4k9eIHXhbTbt91uM/k1Cmy3FfqRtKiQ3nceyl1/3DpEgFpkU+5HKsJXO1/siyWsK9FwfUkxgGs8XZdZl9FQ3UtyqC6wcyVapX3Af2BIwUH/tCHRl/Twvk8vCFC+V+qU0xqBx4/l9kPbyb++QaVuoB+9jqU8fxfsnLH/LWdSRjT5W0pukZ7tjkN5cH8v3wDuCbqTxW4PdL/Wx8I3PP2gPtH+k/duDFfq3tsCX928fJv3bBxlP6f1f1f6NvlP/dIX+bUe4l9tBUbxY3r8h/V8Y+jdp/GZqQ8rG6YjZNE6X+r5mQTlV+zek/+uK/dsqYloX9W9Uhrx/M40fIHF9mPpDqX+jfR+Pc051cJ6VI9kq9QvuA9L4l/prRyhzmfi23M+oTSwb3/ZjBv9oldSb60OKvcPnxYrqv8Py6H1FMW6of1B58Wd2pP9URf+gcXAhuSSvvj5Fjv09F+80na+3qc2EtOyYB2UmPTvyuU5THKeyOVVTH4H30pjSNvyDxlyr4h9I/58G/zDZOySuj7I+z+QffA6oyhxYVf9A+s9W9I+jPAtjleemcf8wxc2nOuDjvbr8g8eql+xJepdYtT3g9kf3JJxj91E5UbqiMQst2xF4cD67jPY8qRO/93QBX6z/nekiH/z/Avu/CDP9vyXgvcDykPYUW5dr6RwgMZ47liXpk++HoDKTbPRqeuNbag+Qr932QD5HcZXzJXzMSOdLuB9J75eks3EkeSJG7edSXjTIgMpIGp/z84FN+yQ7pHzpebpKO2g6M6ns7BzTvtLzFcqmtoJ2gfQXlsRa9kzEz9ui+C465WVTrFcZ1ktLYr0s0FOf4nPCFN9llkfriOOTI/QtcexC5cN9yyQLSFx2twr0lwkN961bSd6uQT6XjlA+HYN8pLFOxyAf0/l8UlsunU1uKrtqW76ivvHIz7zkcy3SGYKmMy9N/WaDXDONlfFeeoZ4lWfJ00KZpmfJbVKORI/8Woz+eq4f6VlSWr8irRdCeunZk4/piurP51pMcSOkuRYqr6K5lrtIXU3PknjtuM21SHZommvpCvR0vI0y6zJ6qptVzrU8lv9GG6BrwIr8o+zZwGTLlP9pxl+am6H0PNYI0scGf9owYG441fyJyrrK+jGqK763j9a5U6HsDXKNy7csnt2ytsnbAyr7LsszzTvReCS8TYLE2wqkf07FtuIo551MYxOTfCFVmQek7QHWvcvoJd+R+i4qc/48IfnatsCf+9qLKvRdVfsIpH9JRb2vZgwl653Kkuvd1AdDquKH1J9MfcQGy6O+x/v9DaGcqn0E3gv28cn89zJ9BC3TtK5YGkNJfQS3mdcsOYaia6UPO4ai+FYxhnr9yRiq8hjK5B98DFWXfzyS/5b6eFMcwqZAz31FaqcpfdGY6AGDf0j2TuttY4xjc9zw7pNxw9LjBsk/+HjU1JZD4v4htdtgtw/nv23KPYw8D20YdY52xJNL8in9Q7nOqM/it3sInEkY+0kQJ/Egnk77k5i/o4FE9/rUXX4cBtGk15+E40EQB8OVl98fxOEkDn1/1PdnfX9QVv7+/E16kE/9GNJ6/j/gagr0yK/F6B/OdQx2+VHWVrSE8oDuYwa6RsH34zyEa246f20zXaRvpov0+3HQ0kWMmHeK5NE2BtLp/H8qL8oLcbQY/aN53VEnG+QevL8rlL/Byp/DLVyjbRzn1RSuIT3o5++Y39K61zi3ur82ts3402scG9qODb+aDIbjSeZc3syHf3ur9uteFA1HvbHXD6eTZNoPysr/P2HlSu0dRgEA", + "debug_symbols": "tZ3drhw3roXfZV/7ovRHUnmVIAicxBkYMJzAkxzgIPC7jxYlktvBdMdmYW5cn+3dixRbrKIolf3Xyy/vfvrzXz++//jrb/9++e77v15++vT+w4f3//rxw28/v/3j/W8f15/+9XLhl1Lby3flzbr2cx3nSufK5yrnOve1XedazrWe69FrR68dvXb02tFrR68dvX70+tHrR68fvX70+tHrR68fvX70+tEbR28cvXH0xtEbR28cvXH0xtEbR28cPTp6dPTo6NHRo6NHR4+OHh09Onp09Pjo8dHjo8dHj48eHz0+enz0+Ojx0ZOjJ0dPjp4cPTl6cvTk6MnRk6MnS6+u67zOtZxrPdf1uYbr+rn+5qVe6+cGruVc67m2c+3nuuzQupb184zr+nnBtZ5rO9d+ruNcl525rhXjuQAYUAF0g2FABmwgB3SaVgA+1QD4FEagM1OBDcRgHtDZiWHo9FSoBs0AyhiaTlEFMmADMZgHdJ4qFINqsJQrhoy5umEYkAEbiME8gBm7oRhUA1MmUyZTJlMmUyZTJlNmU2ZTZlPG9K0IOObvhmFABmwgBvMAZvGGYlANTFlMWUxZTFlMWUxZTHma8jTlacrTlKcpT1OepjxNeZoyEqCuidSQARuKQTVoBt1gGJABG4iBKRdTLqZcTLmYcjHlYsrFlIspF1MuplxNGUlUOwA/PAD4YQLMA7jVbygG1aAZdINhQAZsYMrNlLspd1PuptxNuZsy0qoyAMoCYAMxmAeQVhuKQTVoBt1gGJjyMOVhysOUyZTJlMmUyZTJlMmUyZTJlMmUyZTZlNmU2ZQ1rSagGwwDMmADMZgHNK0UikE1WMrtAnQD3L4QcH1EKLCBGMwDSKtWAMWgGjSDbjAMyGAptwoQg7mhI602QLkBqkEzgHIHDAMyYAMxmAeQVhugPADVoBl0AygTgAzYAMoMmAeQVhuKQTVoBt1gGEBZAGwgBvMAcnADdCZgfapfgPWpXgBiMA8gvzYUg2W9I6rInY4YInc6ooHcUUDubCgG1WBZ7wgLcmfDMCADKCM+yJ0N8wByZ0MxqAbNoBsMAzIwZTJlMmU2ZTZlNmU2ZTZl5EVH5DHVO6KKid0RVUzsgahiYm8oBtWgGXSDYUAGy9WBOGNib4DyCvjQiqkDigGUB6AZQJkAUGYAGUBZAGIwD2Bib4DyBFSDpUwXYClTAQyDpUwVwAZiMA9gYhOcx8TesJQJzmNiE3zGxN4AZTiPib2BDcQAyhgOJvYGKMN5PFwIPmOqb1jKDOfxcNlABmywlBnDweRXwORnOI/Jz/AZD5cNS5nhPNJhwzAgAyhjOEiQDVCG80gQhs9IkA1QhvNIkA3dYBhAGcNBgmxYygLnkSACn5EgG4pBNUCBjOEgQTYMg6UsGBcSROA8EkTgMxJEAQmyAcoYBRJE4DwSROAhEmTDMCADKMNnPFw2zAN4uEyMAg+XCVfxcJlwDA+XDd1gGCzlCZ/xcNkgBij5MQrk4ITPyMEJn5GDG5pBN4AyhoMc3MAGUMYokINz+UzIwXJdoOJUnZoTavqrgIYTOeG5eFUQHoxXA+HJeC3vqVxOxak6qY0B6k7DSW0QSG0wSG0IaBrVy6k4qQ2MUpdKm3SthBHtxRK836slJXYSJ9jAiol0pb+pOMEGllGk632skUhXVlgJkS6tNpGT2sCIdHWFBQ7p8qrAZ11fbSpO1UltYBy6xto0nGADiw/SZRaKc9J1VoWnutBS0pXWpuIEGyiESfsCm7oTbKA6Ju0OoDwm7Q+gHiXtEGyaRtol2KQ2MErtFGxqTmoDY9N+ASox0o4BKjDSnsEmcZpG2jlA9UTaO9hUnWADdRNpBwFlEmkPARUPaRdhEzuJk9rAKLWbsKk4qQ2MTXsKKF1IuwqoS0irxk3kxE5qA6PUylFpXk6wgVqGkN8FhQohwQ91p+Gka3aMcrKTOOmyfY2cNc9RubDmOeoT1jzf1JzUBoHUBoPUhoDYSZymkeY5igfWPN9UnbQ9cIFgYxQQbKAoYM3zTewkTrCBmoE1zzcVJ+1AYGya56gbWPMchQNrnm8iJ3ZSGxil5rmS5vkmtYGxaZ6jgGDNc1QQrHm+aTiRk64VMErN803TSPMcFQVrnqOSYM1zlBKseb6pOw0ntYFRap5vEie1gbFpnqOkYM1z1BSseb6pOXUntYFRap5v0pYNRqR5joqCNc+VNM83FSft28BTzfNN3Wk4aVcInmqebxKnaaR5vqk4Vafm1J2Gk9tgt8Fug92GuA1xG+I2xG2I2xC3IW5D3Ia4DXEb021MtzHdxnQb021MtzHdxnQb021MsyHX5VScqlNz6k7DiZzYSZzcRnEbxW0Ut1HcRnEbxW0Ut1HcRnEbxW1Ut1HdRnUb1W1Ut1HdRnUb1W1Ut1HdRnMbzW00t9HcRnMbmsmoc0WzFtWsaNaiihXNWpSxolmLYlU0a1GbimYtilPRrEV1Kpq1KEZFsxbVqGjWbipO1ak5dafhRE7sJEY7V+G95qooqTLGobm6qTsNJ3JiJ3FS7xEDzdVNxQk2UBiL5ioqY9FcRf0rmqsod0VzFfWu7FyF8s5VpWmEvOwKKofwaVpuGk7kBDnUxqJpuWkaaVqiGBZNy03VqTl1p+FETuykbWIMVzujKJCntkY3FafqpD3nCjrL76mNTtTRUzudm5pTd9KPdhA5sZM4TSPteG4qTvWYRWJt6AbDgAzYwJxFSikgoza03ViY2g5FJT+1H7qJnNRTAYnTNNKm6KbiVJ2aU3dSG3BAG6Go86f2PVHJT21zomqf2ufcRE7spJ9FdLXXqaTNzk3FqTo1p+40zK62PDexkzhNI217bnKftfG5qTnRbl3NvX+AL3BvIChNo72FoKRyCPjeRFBqTt1pOJETO8lulE2kjgIyZ0MxqAbNoBsMAzKYu4O3VpjqKimWwBrYAtVdVhyBFMiBEjgddTfhYNm9w0XVqTl1p+FETuwkTtOoqvOi2AJ7IJzH2mshBcJ5rLkWwnksuhbCeay61tIazleNhO5CVB2H7kMcbIE9UEOlwdb0q+qD5t9BCZyOmoIHS2ANbIE9cASGtR7WeljrYW2EtRHWRljTHYuqo9BkPjgCKZADJXA6akofLIE1MKxRWKOwpond9OvWzD4ogdNRk/tgCayBLbAHjsCwxmGNwxqHNQlrEtYkrElYk7AmYU3CmoQ1CWsS1vRpqdNXdxCx/F7YA0cgBars/pgETsOy9xM3lsAa2ALPbvai4URO7CRO00jr2U3FqToN3XdfoK7vP1PXu6IETse9rbhRXR+KNbAF9sARSIEcKIHTUe8JB8NaC2t6T0DHouhxFMMRSIEcKIHTUe8JaHoUPaNiWANboFoTxRFIgdrVUxKnaaS18KbiVJ2aU3caTqLnLIoeXKn6nNGzK4YlsAbCdb2B6zkWwxFIgRwogdOR9wmPokdbNlSDZtANhgEZsIEcQCrr/NNERv+n6LEWwx44AtVjTRJN5IMSOB31bMDBElgDmx52WdANhgEZsIEY7CMyRc/IbMBz9/PnNy92EOvHPz69e4dzWK9OZn3/18vvbz+9+/jHy3cf//zw4c3L/7398Kf+0L9/f/tRr3+8/bT+dkX73cdf1nUJ/vr+wzvQ5zfx6evxR9eWt5xPL5wuML5eYWJJtRVWHZZSmKaw9ngzPqyN4MsVqKcUwod1a8koaBPwKFBOQXwUq3DNKFS0Lo8Cc0phukJrKR96c4Wemg9rc7mZwtonyigQlnVbYW1lpBRwQzwK3DIKjLXtVlgN0pQCGqRHYV4ZBak+itV2eaSAhcUjidVhslCuxlJ1iSJfL9EtEGvx/dAHeSyw7veWGOvOHl/nuld8ITEfS6z1tkWirso3JaG7H1tiPbdSErW7RCv1kQSWQg9vlhf57XYVSSkvWivuRaspie63iTqunBfdp8WKSklJkN9y69ory0m06hJ95CTYbld17cDcl3gYzqf3irhvyyuFb7lXjFDI3W2m+B1vPdJTCvEMzdUS4/Lb1Vhr5JSCV0Tj4pxCLeFD5s4/dPN/K6zlRErBnx1j1cgphemRrKln6KjkCq1lZtRofboC5xR8To5eUt9FH5abY9SSURiNXSE3CvKKaGFqTnL172JtjCYU6LosL2g12TIK2nTcCu3K3KNWUWajoJ7zoXtdR53rIwXszj+uRkr1auRxQfP1EpyUKC7xeEo8lxjhBV33JZIDGTEQTg6kRH3IIycxfSBrt+q+RDIW02Mxy+1YzJKLxWwxkH7dl+CkRMRi3I/FSMaCYyBy3ZdIxoIjFvN+LGYqFqtr5bXylbvxfSnBSQlfN1ztbiyWRDIWo/639WRaIhmLEbF43KX46ljkbr9rxzkkptyVWLXv3YGUx9XFUy9KLAZL7sb3pQQnJfxLLbkb3yq0wgu57kskB8IxkJkcSIsvNXnXqnHLqY/r96+XkKSEx6ImbzmvYrG2onJe+Fqmvm7mpSVmUiLCyXQ7FpybndXXEmsbt92WKFdSooUE341FK7nZ2aK12Xq/LTFKUiLCOeR2LEZudjb21maTcVti1qREhHPej8XMxaIX92LtLd2WaOXuQHrLhbMPdgmi2xK5WmtJ+LzoycdynxKNd74tUZJfqu+W1pF8pvYxQiL3pQ7v5dTR5bZEboW4JCKcVG/HgnJTa/je8cJ5W2LmcmSwh5OudjcWaxc3JUHef1/bO9d9CU5KXLGz1G/HoudmJ1Hsb3G5LyFJiQhn8pn6OhaSm518xS5bqfclZlKixl7f7VhwTcaihxfJcu0LCbk9kGS5xuJFI892V0Jyvd8l0UIid7+Q6rFINvS/kOglKRGxSD5TWWpI5L5UIS+Ukg39LySkJiUinDJvx2Lmpta8vNaahW5L1JaU8HDOdt2NxUyuBOJ8QJ2Db0tQT0pEOJPP1NexyG1D1ilea83kCjEk2pXrui4JPz96ZZ+pHoslkZqdLc5/Lpy3JTrlJGqEc9yPxUjGgsKLXLn2hUSyXHs9EEnt9b/eqX+soG3qhwPRV4m2F/XxLafg9NUjjXXnt2xf+OrwoXyDxqx295T5+pTZ3zXG1z6NStIPvtwPrimNGftv67HyZCxPv5c4dV4fN0L+ScMPQtbHuwv/oOHfbWuPy/mv9iOt0brffNrjHsI/aHi+tMbJfGm+fl8eldt+PNV4Ok/Fc26+Kuq/cZ52n6evdqu/UaOGRrmv0bJ+eHN9Xr3dz9tX/Yhv0/DiaeV+dixePT27fzx7MhTf6aWSOuNJl8+vpTDuKjzevC+4vzzUmP6GAM1Xez9/j+Z8cjT+K4/nPz2V5xu9VB9vVjxV8A5oWuHyb7Red31oV+obbb54picbWE/PWPoBsCG13lV43AOoF92eVfXi/+WsGjNOMD9ZtT5TEH/RYeFMKXhfZ8zc+ePXo0i9FbYM+8ndmXq/bnR/l2n01Fth62N+or33VBzi5O7aq+GUgh9qGfVxdj1/bYVje1hyr6208Wpv9+GrGvWZRiN/b6WRPHwNqNYn0RBvAb9+V2Ml65cK5dnqyA9Cv1omfpOCH4wnkaSC3bT5euzD01gy+fpMrpL7Pjjq77yGv2fwTOP51OpxkGPk3gLq14zd9pnzIo6T9Cv1IlHs9nTizENsfcxfJCJJvQjb/JXi3iTlQyO5qyDxGmvqAdabv+zXW+oVnN79pcXec6/z9ngla5RMUdOr73j1WlKjiIdHr7lXii8/c7YmdcqHeGuy/72j9cP63duf33/64j9F+QytT+/f/vTh3fntr39+/PnV3/7x/7/b39h/qvL7p99+fvfLn5/eQSn+Z5X1y/cF/3hPWU+wH968NPx+PQBKqT/gX/zQv17P+PXLxB8U/YP1kFm/tB8+w8H/AA==", "file_map": { "17": { "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index b2ffb7f621a..2c44be4db69 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/brillig_cow_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -157,8 +157,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "H4sIAAAAAAAA/+1daZAsWVXO6sqqXl53V/WbN28blwHcRc2srKrMcu2B9+bxBpdR3BmVrCUVFRxQBMElWRwERhEGXEAWBxERRZBRGBT1x4hhaMQYEwFiQEhoaIxBGOEP/vlDzTMvT/epUydvZk3nre6DfSOqqzrvyXO/e5Z7b96899yGcyM9mH0a+W83/17Pv+H6vjOfkBave0dLfo28PFsYGwowrinA2FSA0VWAsaUAY1sBxnUFGDcUYNxUgHFLAcYzCjBuK8C4owDjrgKMHQUYuwow7inAeFYBxpsUYDynAOPNCjCeV4DxggKMFxVgvKQA42UFGG9RgPHzFGD8fAUYv0ABxi9UgPFWBRifoADjExVgfJICjF+kAOMXK8D4JQowfqkCjF+mAOOXK8D4FQowfqUCjE9WgPGrFGD8agUYv0YBRk8BRl8Bxp4CjIECjH0FGAcKMA4VYAwVYIwUYBwpwPi1CjB+nQKMX68A4zcowPiNCjB+U40YV7EWcl+BTG9TgPEpCjA+VQHGKwowXlWA8XYFGK8pwPg0BRivK8B4hwKMT1eA8ZsVYPwWBRi/VQHGb1OA8U4FGL9dAcbvUIDxGQowfqcCjN+lAON3K8D4PQowfq8CjN+nAOP3K8D4TAUY71KA8QcUYPxBBRh/SAHGZynAGCvAOFaAcaIA41QBxpkCjIkCjD+sAOOPKMD4bAUYf1QBxh9TgPHHFWB8jgKMz1WA8ScUYLxbAcbnKcD4fAUYf1IBxp9SgPEFCjD+tAKML1SA8UUKMP6MAowvVoDxJQow/qwCjD+nAOPPK8D4CzViBGwHQC3hTRXI9KUKML5MAcaXK8D4CgUYf1EBxnsUYHylAoy/pADjqxRgfLUCjK9RgPFeBRh/WQHGX1GA8bUKMP6qAoyvU4Dx9Qow3qcA4xsUYHyjAoy/pgDjryvA+BsKMP6mAoxvUoDxzQow/pYCjG9RgPGtCjC+TQHGtyvA+NsKMN6vAOM7FGD8HQUY36kA4+8qwPguBRh/TwHGdyvA+PsKML5HAcY/UIDxDxVgfK8CjH9UI0bAtubMp7rxvk+BTN+vTKZ/rECmH1Am0wcUyPRPlMn0TxXI9IM1yxQxomw/5Nw4Z/bgH4cRwcGgcPAmHGwJB0fCwYxw8CEcLAgH98HBeHDwHBzsBgenwcFk3ewDB2vBwVVwMBQcvAQHG8HBQXAwDxx8AwfLwMEtcDAKHDwCB3vAwRlwMMWt2ecJ2eeJ2QcOBoDA+xDYHgLHQ2B2CHwOgcUhcDcExobA0xDYGQInQ2Bi0AYE1oXAtRAYFgKvQmBTCBwKgTkh8CUEloTAjRAYEQIPQmA/CJyHgeluyz5PyT4QDAyCbUEwKwgWBcGYINgRBBOCYD0QDAeCzUAwFwiWAsFI7sw+EEwDglVAMAgItgDBDCBYAGzGh83usJkcNmvDZmjYbAybeWGzLGxGfVb2ibPPOPvAZkDYbAeb2WCzGGzGgs1OsJkINuvAZhjYbAKbOWCzBGxGuDv7wGJ6WKwOi8FhsTUsZobFwrAYFxa7wmJSWKwJiyFhsSEs5oPFcrAYLc0+L80+L8s+sAAIFtjAAhZYIAILMGCBAywggBf08AIcXjDDC1x4QQovIOEFH7xAgxdU8AIIXrDACwx4QQAT8DDBDRPIMEELE6AwwQgTeDBBBhNQb88+MIECExQwAQAP2PAACw+I8AAGDzjwAAEDdBgAwwATBnAwQIIBCHTq0GlCRwQNPTSe0DiBw4NDYRKdwDl04k/lpy5vMnrIr/HAXH+TlVsn/8j3BpvOfKoZf7CZ89ywwn8cIf9NO/g9PFT76ekhf1oXLBdxWNGT1x/brWff22F1c0hdsOwtO2X7DVaek/N3mDyx/C3Hpk3dODiclod4uHzQ53eQJj3E02B5brpYD8xrkTzUL5STEDpuW4gDdWOj/Ym86NTuHF12x/PcdLEey9odtS1ud00Lsoi8iWW7C47R7oLPSbtrsjw3XazHsnZHZcLtzrUgi8hLLNud1zs+u/OCz0W7c1memy7WY1m7o7bF7a5lQRaZ3U1P7U6X3bVYnpsu1mNZu6O2xe2ubUEWmd0lp3any+7aLM9NF+uxrN1R2+J2t25BFtm8g39qd7rsbp3lueliPZa1O2pbG4TueeT3iwkNfRahdWgIdbD6fOIfzmvZGId6uf0+Vsf0kL/p2Y6Pv6kOXCLPhMnHyrwBkY8N+YN8birAj78hrafOQWoyeVIZocw2KD3L2yR5bjpfzlb+v0vKobwQR4vR353/38m/2+QevL8rlN9m5c/hFq5RGXFeTeEa0kO/8Oz8N7zLQV9+anrIr865IOR/xQp//4D/VSv8vR7yv90O/4N3Ades8I9HyP9pdvgfvGu4bkc+feR/R87fqc7bL2MO9g/t5wPkvQ/t35YoqzRh/0j7az52OeNY0VFcdeyC5W85VsdSB2OXMwwPlw/v97ftyGfUYPwpnm1BPqjLHSEPee3m/7cIL0q/TepI6elvvJ9ee3X+3RV4bjIMO85ifeg12ie8gtWN6qZR8I18+bU1hpHKBvXbcRZtjPuDHX3fWBhBZYF9PC9zi9SHy5rKscWu3Zd/Q9vyYXe+ftJ4fcsgu0ZF2XFf2bEsu11BdjsG2VW17zfXKLu1irI7GC8JWG3IriPIbtcguw7Jw99UdnjtHU59smtWlJ3LZNexLLuuILuOQXZdkoe/qezw2ntqlJ1bUXYtJruuZdntCbLrGmS3R/LwN5UdXvtAjbJrVZRdm8luz7Lszgqy2zPI7izJw99Udnjtz5z6ZNcW8JjGncv255tC3eqUdddZ1PNZVvZNDF9NZft8bpGWDXJ9iFyn4wQ6vqPzbvg83WL0b3EPef5Nfq0jlL1VUJ5TUh4f27QFeo6f0v99/g20H8mxSnrB+6V1LFRuD7N6bJBypbk+Ljekv4fI7ZH8GspN6ud5eQ4pb00oj8u5LdBz/JT+H/PvMrmtYo1PloIyvXzSkeVUpJcr6Xy9kf6ZRC//nF/rkPo4TAZ21w72PJO/SGsPTP5C6Yv85d/y77r85VGGq0nKlfRyNZ3HhfRXiF4+k18z6QX5uoQ3lwMtz+QvlL/rzOND+v/Kv8vk5lbAt06u4Txdx4DFZCPrQl07wv1cn/Q+1I/l59jK76Sw/C2GtWY8flW5rjHZSfMi0vwGrRvNo+VI8xsSL5dhoJi5/iw9S4dV9YflbzlW7ck3yXVbkCvKblfA2hXy+PzUrlDOrlDOKa/6eHGfw3zpG8vh10x+xdtFk19ZmmepPN+N5a/KryT9mfyqI2DtCnncTjpCOR2hHNu8bjqhuE7r+PjqyNt7zJe+sRx+zdRGoS/wcROk/fzbi4JZOPL9aRQMvFE47I0SzxuGg8BPJv5gEifTcBRHo/FsNhkHo5EXJMPRIOxNhsEw6ceDmM9TUt5+HCaDWRLH0zAJMma9QTzyoyTwJpNoGgZBkEwm8TjMsicjL/H701nkjyeTQS9KRqNgMJXm8eawHzHxua453oN+HEfDOAwm4ygO+oPeYDYYj2fT4awfjGPfH0WzaOglgyQYDbzeMEpCf5r0ByN/PJ31b7znBt7nBN49bzSdJOOkl/0ZhMkoGXr9TJr9aejHk2ESJ1HYy4pPJmHfCydefzYe9vx42IvCSTzxe0O0m5sJb94XnCfXj2OMheVvMay2+oLzDA+XD+8LLghYu0Ie7cNoHi3nglCOxKtTI69ujbz2auR1zkIdTe2XHwS+52Wek0yTYBCOemM/a5oyb0rCYdSfJpkfTcOZ34+D3mgWZq1MNJtlrdskHCaZEw6TsvmDK435+qAOq84fIP3/NA95XstvwOdg+vx4sJbKUGfvaKlnWruI/ZxL8upsP2B+4q/yh0U+LntMbqRc3jab+lmkPyfQUx64rqbrLNor7y8tPdcPJPl3SNmQ3NRK2aL8595FpcvJk8v/ZoGeyhhl2nUW+4VNlkefg7DMDqOlYx7L8wtD01inN02i8ajvzQbRyJv1Z34QhjNvEIRBEs+Go9ifhoN+NnYKBrNsUBF54+FwOOqH/Wyc1ZtMJ1PJJui+aUhuaqVesWQTVO/cJkw6hsRtwtQ3U311ncWxC/ULrvc6/cKo29lkGkVTfzAahuPJIBhHUTbO6828qT+MhkM/62Mm42EcT3rTIIkGs142Tgtns2Tcm/ijbIAt6fYcqRckN7VSL1G3VH9ct1XHUab+neqP+7Q0HrK81iGS5H8zKRuSm1ope2nfkuRv8q0y+aNMTeMr6dkRyzQ9o6LeLI3t+w1WHtaRXqPlbwn1sPGsUbX9s/wsNjLZwJ4Bz0U7eIaI55KAR5pXBYxtZ9GGqLyovVLclwh/vFY0XqFl8/dZ9NkH7+04i3Z0huXRMQ1/54d1oc8IFNe19DCf0t+TGzW0GR8nbcZjdUkPy6DjHUguyatxHe+x9x0osyrPrNJcMJX57Qwr3t925HEqXW9M6V9HdPQRV+ZJ9U5xcb0j/Rsq6n01fZas9zqfEUx9HJWZNB7k/t4UeEn+zrG2BXrKr8Xo32bQ+zlyj/SOn+sd6e+vqHeU5XHofZXPASgzSe8uy6Nr4PmcU5lNXE3n6ZF3VZtA+vcKNiGtucD7y+aa3t+Q67HsWpVHyVzTA/kNNtaqtAj2psCfr1VB+gcryo2vKSiS25/XJLd/IHL7yxMot4eWlBuXB11rSzHz9gnp/zYvz2ZcD0h0/avDypL2yDZqLHtHkEfDsV9vP5siarDyHEd+vjnYE+ss6tfG802L4eHy4c8TNuJuZPI5WHvYFvC0Bfnwtdlcd7Rdp22DtA5+2X02n8gVZmr/GyzPETBg2U6O5ZHGfN1ou9Io+HacRTuifKU9KXzfiRUb8w/fuVryKa+sr/g06ytQ30V9Be7zbTH6d5K+4l9ZO2nHH+LSuv07q9tWSd2us7oh/fNJ3f6D9YPcLiCZbNNu39F73G1o0wqek9uGSm1OU8Cz5xy2fVRn0l6YW8m1ojrTMvjcC7WlFruPlu2y31IbVd+YIIh427CVl2XCVUXGV9P5+kt7s6Q+qVVQ/5ad+h/YzBmh/qa+ldbfdRbtpmhPd7uAnrZflP5/c8eWnsWlPfDU19HOOwZ8TUbL6agO2qxO+/n/3pFSLzLpoAgXzXMcWWdVdCDtg+Y62MgzltUBJOx3OgZ8TQEvf8aRYlTVqIOFvdlUB0W4eP0lne0yejoXKdEjPz5vuGfQgTQfSv0A38N3DPiajJbTUR3wuZ79/H/vSMmPTDoowkXzHEfWWRUdnBHkxXVw+Qg6wLm+jgFfk9FyOqoD7tv7+f/ekZJv9ANTzA66Jl7SWRUdSGujuA6edAQd4Jxqx4CvyWg5HdXBOqvTfv6/d7Rk9IMiXDTPcWSdVdGBFBOF6+DJR9ABvqPuGPBJ87J8/5HJ7jYNdT6ILVZAz+0O6QOhzpbXqYw4ZsepZte0zh12X5FsqEzL7I7PH1iqf8zttGr96dqSPUP9OwX175TUn4+FJb/bLSinyO+k/Ubc724z2KCldRDjqjrA8qvooEg2ZTqg9/GxMG13JJ1V0YHkG1wHd6y+HZicVD/gY+FV+cEzVu8H05PqB3wsvCo/uGv1fjA7qX7Ax8Kr8oPZ6v0gOal+wMfCq/KD5xrGwqZxG6Qr6Y3vjgFfU8DLx2KrtrsXrNzufP+k2h0fC1uqfw/xnF2y/nTt3FlD/fcK6r9XUv+id64Ooe8UlEMxtQvoud8h/csNNmhnbbkfVNUBf8Y16aBINmU6oPfxsTBtdySdVdGB5BtcB/euvh3on1Q/4GPhVfnBG1fvB4OT6gd8LLwqP3jr6v1geFL9oOidk+PY9YN3rd4PwpPqB3wsvCo/eN/q/SA6bj9wHLOdVrVrup+A0n9o9TIdPV6Z0vqYZFrXWNu1U/+4av1dVv9dQ/1dQW68/tK8u7RupsHyHKeaDdK1yBI98uNrkT9qsEE7a738sdR2STrA8qu8+2gVyKZMB0Vro2ie48g64zrA+9uOWcd8DeLDBh1Y8oOJ1IdX8YO2UH/JD/g6Gy6jIj8wrcmvojO8v+2Y13rxtZKfWL0fTDlmKkuTH0hrq5olsinTAb2Pj7WltUhFui5qi1yBP2+L/mX1fjDjMqGyNPmBJGfJD7jtcRkV+QEfa0t+sFZQTlFbxNf8OM5iW/QZgw7o/TXqIKmqA77mz6SDItmU6YDex8faZX5QRQcmP0D6zxrmnU1rcxvOYfzmKmtzJfvmMiqzu6Yj46tqd0j/30Kd+ZnsyEP6xnrxa3x9Np2j38+/vaMlv2uQCz/vluKzuWZ8mTX1tD+w198drqmX/JzKZ43Jbl3A2hXyeCy1daEcKd7yKa+Txeum/wd1POV1yuuU1ymvU16nvE4CL9tjUb7nFRLuI4Qyb2/KdZL2vFKcLUZ/V/OQ5/X8d0e4f43Ji47d6bpzKgvHOdxTSekbBl6bAq9WAe8yXHtHxEXr7wq81gy48F5Jj/h7U7ivxueHyue64LUtod42nmeaDA+XD3+ecQWs0hmJpncCTeHamoEX5sG8krRHhuuen9tHafm8CI+vC9/8HCn6G+e2aNwUSsPPEkP6cS4syP8nV+ZJ24v1CjxnhOfHGU9pblx6TkV66X2GtI5R2ifG32dQ7HQfIr+G+pHO1HIYhrUS3hwT9+V1RrvO+Ep7KYv+l+QizaPw9wFSX0d9DfsUKcYC3kv7G1OMQLyfr0uERM+N5/YtxRGjPK6lh/mU/oUGW5RidEmxGJG+LEYXj8NMY2/hvfxcBaznfv7tHTEdX0xSv/Lc2EmISSrp2W5MUt8DnUux1V1BNhwHX3OyR7BLPnslnaeX4hC2DfwRR7uAnvojpX8l8Tc+5yydtQo8X9WU6ybFIaJ14+usX0vGqfcyntL7wKptHH3/yePISOurq8Q/LYqtyde1IP19glxN7ZKpHSuLLcrPQqY2eYHlmeJPXiB14W027fdbjP5NQpstxX6kbSokN53Hsp9f946QIBaZFPuRyrCVztf7IslrCvRcH1JMYBrPF2XWZfRUN1LcqgusHMlWqV9wH9gSMFB/NcWoqFoml4UpXir1S2mMQePG8/sg7eff3hHTjlAP3sdSnz6O909Y/pazqCMbfaykN0nPdscgvbk+VloLx3Ujjd8a7H6pj4VvfP5Be6D9I+3fHqjQv7UFvrx/+zDp3z7IeErv/6r2b/Sd+qcr9G+mfcVlMYR5/4b0f2Ho36Txm6kNKRunI2bTOF3q+5oF5VTt35D+ryv2b6uIaV3Uv1EZ8v7NNH6AxPVh6g+l/o32fTzOOdXBeVaOZKvUL7gPSONf6q9HjW/L/YzaxLLxbT9m8I9WSb25PkxzMFIfS/HxNcz0vqK9DNQ/qLz4MzvSf6qif9A4uJBckldfnyLH/p6Ld5rO19vUZkJadsyDMpOeHflcpymOU9mcqqmPwHtpTGkb/kFjrlXxD6T/T4N/LDvnWNbnmfyDzwFVmQOr6h9I/9mK/oFlaz8ToezcNO4fprj5VAd8vFeXf/BY9ZI9Se8Sq7YH3P7onoRz7D4qJ0pXNGahZTsCD85nj9GeJ3Xi924X8MX635Eu8sH/L7D/izDT/1sC3gssD2nPsHW5ls4BEuO5Y1mSPmkcLy4zyUavpje+T9o5iqucL+FjRjpfwv1Ier8knY0jyRMxaj+X8qJBBlRG0vicnw8snUvJZV30PF2lHTSdmVR2do5pX+n5CmVTW0G7QPoLS2Iteybi521RfBed8rIp1qsM66UlsV4W6KlP8Tlhiu8yy6N1xPHJMfqWOHah8uG+ZZIFJC67WwT6y4SG+9YtJG/PIJ9LxyifjkE+0linY5CP6Xw+qS2XziY3lV21LV9R33jsZ17yuRbpDEHTmZemfrNBrpnGyngvPUO8yrPktlCm6Vlyh5Qj0SO/FqO/nutHepbcETBI64WQXnr25GO6ovrzuRZTPGFproXKq2iu5U5SV9OzJD17HZJL8o5zrsW0PggS10dXoKfjbZRZl9FT3axyruXR/DfaAF0DVuQfZc8GJlum/LcZf2luhtLzWMBIHxv8acOAueFU8ycq62XXj/G9fbTOnQplb5BrXL5l8eyWtU3eHlDZd1mead6JxiPhbRIk3lYg/XMqthXHOe9kGpuY5AupyjwgbQ/42ex03MJ9R+q7qMz584TkazsCf+5rL6rQd1XtI5D+JRX1vpoxlKx3Kkuud1MfDKmKH1J/MvURGyyP+h7v9zeEcqr2EXgv2Mcn89/L9BG0TNO6YmkMJfUR3GZes+QYiq6VPuoYiuJbxRjq9adjqMpjKJN/8DFUXf7xcP5b6uO5f0i2uS3wNbXTlL5oTHS/wT8ke6f1tjHGsTluePfpuGHpcYPkH3w8amrLIXH/kNptsNuH8t825R5Gnoc2jDpHO+LJJfmU/sFcZ9Rn8ds9As4kjP0kiJN4EE+n/UnM39FAont96i4/DoNo0utPwvEgiIPhysvvD+JwEoe+P+r7s74/KCv/YP4mPcynfgxpPf8fcDUFeuTXYvQP5ToGu/woaytaQnlA9zEDXaPg+zEewjU3nb+2mS7SN9NFeix7K13EiHlnSB5tYyBt5/9TeVFeiKPF6B/J64462SD34P1dofwNVv4cbuEabeM4r6ZwDelBP3/H/JbWvca51YO1sW3Gn17j2NB2bPjVZDAcTzLn8mY+/NtbtV/3omg46o29fjidJNN+UFb+/wGDQB57HUYBAA==", + "debug_symbols": "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", "file_map": { "17": { "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n // Here's we're taking advantage of truncating 128 bit limbs from the input field\n // and then subtracting them from the input such the field division is equivalent to integer division.\n let low = (x as u128) as Field;\n let high = (x - low) / TWO_POW_128;\n\n (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n if x == y {\n true\n } else {\n field_less_than(x, y)\n }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n let (alo, ahi) = a;\n let (blo, bhi) = b;\n // Safety: borrow is enforced to be boolean due to its type.\n // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n unsafe {\n let borrow = lte_hint(alo, blo);\n\n let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n let rhi = ahi - bhi - (borrow as Field);\n\n rlo.assert_max_bit_size::<128>();\n rhi.assert_max_bit_size::<128>();\n }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n if is_unconstrained() {\n compute_decomposition(x)\n } else {\n // Safety: decomposition is properly checked below\n unsafe {\n // Take hints of the decomposition\n let (xlo, xhi) = decompose_hint(x);\n\n // Range check the limbs\n xlo.assert_max_bit_size::<128>();\n xhi.assert_max_bit_size::<128>();\n\n // Check that the decomposition is correct\n assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n // Assert that the decomposition of P is greater than the decomposition of x\n assert_gt_limbs((PLO, PHI), (xlo, xhi));\n (xlo, xhi)\n }\n }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n if is_unconstrained() {\n assert(\n // Safety: already unconstrained\n unsafe { field_less_than(b, a) },\n );\n } else {\n // Decompose a and b\n let a_limbs = decompose(a);\n let b_limbs = decompose(b);\n\n // Assert that a_limbs is greater than b_limbs\n assert_gt_limbs(a_limbs, b_limbs)\n }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n if is_unconstrained() {\n // Safety: unsafe in unconstrained\n unsafe {\n field_less_than(b, a)\n }\n } else if a == b {\n false\n } else {\n // Safety: Take a hint of the comparison and verify it\n unsafe {\n if field_less_than(a, b) {\n assert_gt(b, a);\n false\n } else {\n assert_gt(a, b);\n true\n }\n }\n }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n gt(b, a)\n}\n\nmod tests {\n // TODO: Allow imports from \"super\"\n use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n #[test]\n fn check_decompose() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_decompose_unconstrained() {\n assert_eq(decompose(TWO_POW_128), (0, 1));\n assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n }\n\n #[test]\n unconstrained fn check_lte_hint() {\n assert(lte_hint(0, 1));\n assert(lte_hint(0, 0x100));\n assert(lte_hint(0x100, TWO_POW_128 - 1));\n assert(!lte_hint(0 - 1, 0));\n\n assert(lte_hint(0, 0));\n assert(lte_hint(0x100, 0x100));\n assert(lte_hint(0 - 1, 0 - 1));\n }\n\n #[test]\n fn check_assert_gt() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n unconstrained fn check_assert_gt_unconstrained() {\n assert_gt(1, 0);\n assert_gt(0x100, 0);\n assert_gt((0 - 1), (0 - 2));\n assert_gt(TWO_POW_128, 0);\n assert_gt(0 - 1, 0);\n }\n\n #[test]\n fn check_gt() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n unconstrained fn check_gt_unconstrained() {\n assert(gt(1, 0));\n assert(gt(0x100, 0));\n assert(gt((0 - 1), (0 - 2)));\n assert(gt(TWO_POW_128, 0));\n assert(!gt(0, 0));\n assert(!gt(0, 0x100));\n assert(gt(0 - 1, 0 - 2));\n assert(!gt(0 - 2, 0 - 1));\n }\n\n #[test]\n fn check_plo_phi() {\n assert_eq(PLO + PHI * TWO_POW_128, 0);\n let p_bytes = crate::field::modulus_le_bytes();\n let mut p_low: Field = 0;\n let mut p_high: Field = 0;\n\n let mut offset = 1;\n for i in 0..16 {\n p_low += (p_bytes[i] as Field) * offset;\n p_high += (p_bytes[i + 16] as Field) * offset;\n offset *= 256;\n }\n assert_eq(p_low, PLO);\n assert_eq(p_high, PHI);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 5367017248a..3751a7a25f8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -69,7 +69,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_0.snap index 5367017248a..3751a7a25f8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_0.snap @@ -69,7 +69,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "pZ3LjiTHkUX/pddcxL3+1q8MBgIltQQCBEVQpICBwH+fyoh7rKQFBSG1cie708IjK055uNtx6398+dPXP/zyl99/98Of//q3L7/7n398+cNP333//Xd/+f33f/3jtz9/99cfPv7vP3795gv/+fuff/r69eN/ffmnP//41I/f/vT1h5+//O6HX77//psvf//2+1/uv/S3H7/94W5//vanjz+9vvny9Yc/fbQfAf/83fdfX71fv/n89PXbHx1Xz4eHen18/OefX4PP7/XO56f4/PIbn5995vNz7Hc+f1Y+v653xr8aX/5q73x/++LzW+2dz5vx7zbe+PzRyedP+837P7/9eW2ur6N3rr+4/7PmG5/XJTOAS+9F6K0i/PYzpPbbIbwYg9d+awinhvBxF+9EUHGsj/5/O4b3IsinIrTzVoQxK8Js/3WEt34W2rsinHd+JcijmPB6L4I/I7S3vgcffq+qXW/9NNvnGJrf+ibbKDTbfOupbn39txHW5xjWbz6T3v/mN1Q9Dtdbn/+PfkP+2wCTKVbzvRG0YqK/9ygcfwZ468fQe32LffS3Inx+jf28hcT4nCmG3ovweRejv/ULbqp+TU+NtyKMzwjv/Yqcq+5irvfu4pOJdb3101ynHsl9vfU9bNf3sNtb8/7+5Gqvf32q//fjv77943c//cvb+pfePv7qN196f5rxNPPL7z5G0tfT7Kc5H3G++TKup9HT+Gk+onzc/OhPM55mPs16mv00527m9TR6Gj/NE2U+UeYTZT5R5keUj0d9PmOZ527W9TR6Gj9Ne5r+NONp5j3OtZ5mP81zR/uJsp8o+4mynyi735fdT5T9fC/7+V72M5b9jOU8Uc4T5TxRzhPlPGM5477eecZynrGcZyznGYuuJ8zHG1Nap21pnwF9vNXlv2falXanfUb18daTNvGUeEo89bSJp8TTM7qPN4e0GZ+vtEqbeE48J54Tz/N+oj5eGtLutOe5j3alVdrEa4nXEq8lXsv4Wu635X5b7rfnfnvutydeT7yeeD3x+vPDUM/99txvT7yReCPjG4k3Em8k3ki8kfGNjG9kfCPxZuLNjG8m3ky8mXjzeVY0M76Z8QUAhQAFAa2MLxAoFCgYKBxoZXwr41uJtxIvMCg0KDgoPGgn3s74dsa3M76d72/neQkWChcKGAoZCho6Gd/J+E7GdzK+84zP4cPhw+HD4cNXT/uMz9dMu9LutIkXPhw+HD6s5/ei1dOOtPP+nq2VdqdNPCeeEy98OHw4fDh82DPtSrvTJl5LvJZ44cPhw+HDLffbcr8t9xs+HD7cH94cPhw+HD4cPhw+nKnAmQucycDhw+HDI/HCh8OHX3y8xjEyvpHxjYwvfDh8OHw4fDh8OHw4fHhmfDPjmxlf+HD4cPhw5giHD4cPr4xvZXyZKJyZwuHD4cPhw+HD4cPhw+HDmTGcKcOZM5xJw5k1HD4cPhw+HD58Mr7MHc7k4cweDh8OHy18tPDRXnzo1ba0Pe24n4N2zbQr7c7nEi98tPDRwkfL/NEyf7TMHy3zR9NKm3jho4WPFj5a+Gjho/m53+aRdqZdaRMvfLTw0cJHCx8tfLTw0TJ/tMwfLfNHCx8tfLTMHy18tPDRwkfrGV/P+DJ/tMwfLXy08NHCRwsfLXy08NEyf7TMHy3zR8v80cJHCx8tfLTw0cJHCx8tfLTMHy3zR8v80eZOm3jho4WPFj5a+GiZP1rmj5b5o2X+aOGjhY8WPlr4aOGjhY8WPlr4aJk/WuaPlvmjZf5o4aOFjxY+WvhoJ8/zGWln2owvfLTw0cNHDx8980fP/NEzf/S8X/W8X/W8X/Xw0cNHDx89fPTw0V98jFfb0460iRc+evjo4aOHjx4+evjo4aNn/uiZP3rmj575o4ePHj56+Ojho7fnhb23jK9lfOGjh48ePnr46OGjh48ePnr46OGjZ/7omT86SwnWEiwmwkcPHz3riZ4FRR8ZX/jo4aOHjx4+evjo4aOHjx4+evjo4aOHj575o2f+6Jk/euaPHj76et53+8r4VsYXPnr46OGjr+f562ul3WkTL3z08NHDRw8fPXz08NEzf/TNWizjy/zRw0cPHz189PDR837VM3/0zB8980c/LO6eeCN8jPAxwscIHyN8jPAxwscIHyN8jPAxwscIHyN8jMwfI3yM8DE00yZe+BjhY4SPET5G+BjhY4SPET5G+BjhY4SPET5G+BjhY2T+GOFjhI+R96sRPkb4GOFjhI8RPkb4GOFjhI8RPkb4GOFjhI8RPkb4GOFjZP4YLLjDx8j71QgfI3yM8DHG8/yNFx+v9sXH3SZe+BjhY4SPET5G+BjhY4SPET5G5o+R+WNk/hjhY4SPET5G5o+R96uRpfjIWnyEjxE+RvgY4WOEjxE+RvgY4WOEjxE+RvgY4WOEjxE+RvgYWX+M8DHCx8jyfISPGT5m+JjhY4aPGT5m+JjhY4aPGT5m+JjhY4aPGT5m+Jh5v5rhY4aPmfX5DB8zfMzwMcPHDB8zfMzwMcPHDB8zfMzwMcPHDB8zfMzwMfN+NcPHDB8z648ZPmb4mOFj9uf5my8+7tZpEy98zPAxw8cMHzN8zPAxw8cMHzPvVzPvVzPzxwwfM3zM8DEzf8zxPH9zXmmVNvHCxwwfM3zM8DHDx2SDKnzM8DHDxwwfM3zM8DHDxwwfM+9XM3zM8DF3xhc+ZviY4WOGjxk+ZviY4WOGjxk+ZviY4WOGjxk+ZviY4WNmfT7DxwwfM/tXK3ys8LHCxwofK3ys8LHCxwofK3ys8LHEFl/ihY8VPlb4WFl/rPCxwsfK/tUKHyt8LLNn+Dx/yy1tT5t44WOFjxU+VvhY4WOFj9XYhMz4sv5Yeb9amT9W+FjhY4WPlflj9ef5W91pW9rECx8rfKzwscLHCh8rfKzwscLHCh9rsE2aeOFjhY8VPlber1b4WOFjzYwvfKzwsSb7rokXPlb4WOzgsoXLHi6buOziso3LPm74WOFjZf2xwscKH2tnfOFjhY8VPlb4WOFjhY8VPlb4WOFjhY8VPlb4WOFjhY8VPlbWH+uw1cxe85U2u83hY4ePnfX5vkbamTZ7zuFjh48tNq8TL3zs8LHDxw4fO+uPnfernfljh48dPrbZDU88P8/fzvp8Z32+w8cOHzt87PCxw8cOH7uxvZ7xhY8dPnb42OFjh48dPnb42Hm/2uFjh4+d9fkOHzt87PCxw8cOHzt87PCxw8cOHzt87PCxw8cOHzt87PCxs/7Y4WOHjz0zvvCxJxmFxAsfO3zs8LHDxw4fO3zs8LHDxw4fe5GiSLzwsbP+2OFjh4+9Mz7yHeFjk/HYef72SrvTJl742OFjh48dPnb42OFjh48dPvYhiUIWJWmU8HHCxwkfJ/PHyf7uyf7uyf7uCR8nfByRlkm88HHCxwkfJ3yc8HHCxwkfJ3yc8HFMnifx8n51wscJHyf7Vyd8nPBxwscJHyd8nEbiKPHCxwkfJ3yc8HHCxwkfJ3yc8HGy/jjh44SPk/2rEz5O+Djh44SPEz5O+Djh44SPM0htZXzh44SPEz5O+Djh42T9ccLHCR9nZnzh44SPEz7OfJ6/M5/1zFlX2sQLHyd8nPBxwscJHyd8nPBxwsfJ+uPk/epk/jjh44SPEz5O5o+zyeYlnZf9q0NakLwgiUEyg6QGw8cJHyd8nPBxwsdHfpAEYWUIK0VYOcJA8tEhSxhMPjqLzqZDZFXqkcgkCy+yhRfpwot84UXC8BIZSJGCFJFNZFdWk8jkDS8Sh1fI+egwZjNmE9lEbkRuRG6VMCUyKcSLHOJFEvEii3iRRrzII14kEi8yiRepxKtXLrZnYJ0xk068OpE7kckoXuN5ZD86omM6RCateJFXvEgsXmQWL1KLF7nFi+TiRXbxIr14kV+8SDBeszLIRJ5EJsl4TbLS2Qb76IgOkck0XqQaL3KN16rkNJFJN17kGy8SjhcZx4uU40XO8SLpeG0ibyLvynvzPJN5vA5jJvd4kXy8yD5epB8v8o8XCciLDOR1KqVeOXWS6jBYafrK0wsGK1NfqXrBoGDwztbfnc90PZErYV8Z+0rZV86+kvYwKBgUDAoG5TIBiAyDlbyv7L1gUDB4J/CfDpFhUDB4J/F1dxqdTofIMFiZ/ErlVy6/kvmVza90fuXzK6FfGX11IsOgYLCy+pXWV/adpWysSdlZU6X2K7dfyf3K7ld6v/L7leCvDH+l+CvHX0l+zbIuiAyDleivTL9gUDCoxZhhsNL9le+vhH9l/CvlXzn/SvpX1r/S/pX3r8S/YFAwKBjUJjIMCgbv/P/TITIMlgJQDkBJAGUBlAaAByBEAGECCBVAuABCBpBh0DBofBmEABkGbyXg6RAZBg2DaAHCC9AtBjwdIsMgboCQA4QdIJc+U/5MCTRl0Jgxm8jMg1gCQhMQnoAQBeTsZMvZqhOugAyDhkF0AeELyDCIMSCUAeEMCGlAWANCGxDegBAHhDkg1AHhDsgwaBhEH5Bh0DBoGEQhEA6BkAiERSA0AuERCJFAmARCJRAugZAJhE0gdAIZBg2Dt1HwdIgMg4ZBwyBagfAKhFggzAKhFgi3QMgFwi4QeoHwC4RgIAwDGQYNg7dk8HSIDIOGQR+e57PobDqJjGwgbAM1GGww2GCwwWCDwQaDSAfCOhDagfAOhHggzAOhHqhlb1wtm39q2GvoB8I/EAKCMBCEgiAcBDUYbDDYYLDBICKCMBGEiiBcBLVPmY3IMNhgsDXGXEZbKW0wiJQgrAShJQgvQQ0GGww2GGwwiJwg7AShJwg/QQgKajDYYLANxgyDWApCUxCeghAVhKkgVAXhKghZQQ0GGww2GGwwiLEglAXhLKjBYIPBthgzDCIuCHNBLalZ3e7C3dkXHSLDIP6CEBiEwaAGgw0GGww2GERjEB6DEBmEyaAGgw0GG/NgOzzP2U5UwxdFaBBGg1AahNMgpAZhNQitQXgNQmwQZoNQG4TbIOQGdRjsMNh5F+0w2GGwo5DiOAjJQVgOQnMQnoMQHYTpIFQH4ToI2UHYDkJ3EL6DOgx2GOysBzsMdhjsjTHDYC+vtMTSMktLLf10S4lcdikM4j8IAUIYEEKBUIfBDoOd9WCHwQ6DfTBmGESFEC6EepK9um2Ip2M6RIZBjAihRAgnQkgRwopQh8EOg531IGaEUCOEG6EOgx0GO/NgXzzP2aBUzw6lUCSEIyEkCWFJCE1CeBJClBCmhFAlhCshZAlhSwhdQh0GOwx23kU7DHYYHNnUF9aE0CaENyHECWFOCHVCuBNCnhD2hNAnhD8hBAphUGjA4IDBwXpwwOCAwYHHjUghTAqhUgiXQsgUwqYQOoXwKYRQIYwKoVQIp0JIFRowOGBwsB4cMDhg8FYrng6RYRC7QiPpY42cY9DISQZhWAjFQjgWQrLQKMu7NG8YHCV6l+n9qXoTuWTvsr1L94bBwTw4khHQyJanRvY8hXQhrAuhXQjvQogXwrwQ6oVwL4R8IewLoV8I/0IIGBowOGBw8C46YHDA4NiMGQYRMYSJIVQM4WIIGUPYGELHED6GEDKEkSGUDOFkaMDggMHBenDA4ITB28x4OomMmyHkDGFnCD1D+BlC0BCGhlA0hKMhJA1haQhNQxMGJwxO1oMTBicMTg5TYGsIXUP4GppJSOs2Np7OpENkGMTaENqG8DaEuCHMDU0YnDA4WQ9ibwh9Q/gbmjA4YXAyD87kGDTZF53si6JxCI9DiBzC5BAqh3A5hMwhbA6hcwifQwgdwugQSodmnbmoQxd16gIGJwzOyZhhELVDuB2adfgCBtE7hN8hBA9heAjFQzgeQvIQlocmDE4YnKwHJwxOGLxdj6dDZBhE9xC+hxA+hPEhlA/hfAjpQ1gfQvsQ3ocQPzRhcMLgZD24YHDB4K1/PJ3G3+l0Bp08z7cD8nQ2HSLDIB6IEEGECSJUEOGCaMHggsHFehAfRAghwgjRgsEFg4t5cJGbWOyLLvZFEUOEGSLUEOGGCDlE2CFCDxF+iBBEhCEiFBHhiAhJRAsGFwwu3kUXDC4YXOQmcEWELCJsEaGLCF9ECCPCGBHKiHBGhDQirBGhjQhvRAsGFwwu1oMLBhcMLk4/oY8If0QIJFp1AqqOQMHgqkNQdQqqjkHVOajPg1BErqNQMLhgcLEeXDC4YPAWSp4OkWEQp0Rr8zzvrDRvreTpEBkGMUuEWiLcEiGXCLtECwYXDG7WgxgmQjERjok2DG4Y3MyDm9zEZl90sy+KaiJcEyGbCNtE6CbCNxHCiTBOhHIinBMhnQjrRGgn2jC4YXDzLrphcMPgJjeBfSL0E+GfCAFFGChCQREOipBQhIUiNBThoQgRRZgo2jC4YXCzHtwwuGFwc94QIUUYKUJJEU6KkFKElSK0FOGlCDFFmClCTRFuipBTtGFww+BmPbhhcMPg5ggijoqQVISlop00vG5P5emYDpFhEFdFyCrCVhG6inadR6wDiXUisY4k1pnEOpQIgxsGNwxu5sFNbmKzL7rZF0VeEfaK0FeEvyIEFmGwCIVFOCxCYhEWi9BYhMciRBYdGDwweHgXPTB4YPCQm8BnEUKLMFqE0iKcFiG1CKtFaC3CaxFiizBbhNoi3BYdGDwweFgPHhg8MHgbLncHBnFchOQiLBehuQjPRYguwnQRqotwXYTsImwXobvowOCBwcN68MDggcHDoV+sF6G9CO9Fhxz9bb48nU6HyDCI/SL0F+G/CAFGGDA6MHhg8LAexIIRGozwYHRg8MDgYR485CYO+6KHfVF0GOHDCCFGGDFCiRFOjJBihBUjtBjhxQgxRpgxQo3RgcEDg4d30QODBwYPuYlTJ4TriHCdEa5DwnVK+POY8BPZVx0UrpPCdVS4zgrXYeEw6CsM+gqDvrIe9BUGfYVB357M0yGyiCwii8gisogsInN2GE/GeDLGkzGejPFkfHGC+OII8cUZ4isM+jJjboyZc8R4MsaT8ZUcvW9P5ulMOkTmODGejPFkjCdjPBnjyfjiUPHFqeKLY8V4MsaTMZ6ML44WX5wtvjhcfCU34YvjxRfni/FkjCdjPBnjyRhPxngyxpMxnozxZIwnYzwZ48kYT8YXp40vjhtfnDe+wqCvxZg5cownYzwZ48kYT8Z4MsaTMZ6M8WSMJ2M8GePJGE/GeDK+OIB8cQL54gjydXieD2M+jPkQ+RD5EPkQmaPIeDLGkzGejPFkjCdjPBnjyRhPxtS0MEUtrDq1D4OCwduTeTpEhkE8GSs5et+ezNPZdIgMg3gyxpMxnozxZIwnY8GgYFAc5MeTMZ6M8WRMsQtT7cKUu7A4zy8O9IsT/XgyxpMxnozxZIwnYzwZ48kYT8Z4MsaTMZ6M8WSMJ2PBIAUwTAUMCwYFg+KQP56M8WSMJ2M8GePJGE/GeDLGkzGejPFkjCdjPBnjyZiSGBYMUhTDgkHBoDj3jydjPBnjyRhPxngyxpMxnozxZIwnYzwZ48kYT8Z4MhYMUibD1MmwYFAwKEoB4MkYT8Z4MtbheT7PStO3J/N0ErlKZlTNjCqagSdjPBnjydgwWJUzqnRG1c6o4hl4MjYMGgbNPOjkJuzsi9rZF/VnEY3PKhpErjoaVUijKmlUKY2qpVHFNGCwymlUPY0qqFEVNaqkhhuRYbCqargxZhjEk3FV1qjSGlVbo4prVHWNKq9R9TWqwEZV2KgSG1Vjo4psVJUNDyLDYBXaqEobVWqjam1UsY2qtlHlNqreRhXcqIobVXKjam5U0Y2qulFlN6ruRhXeqMobVXqjam9U8Q08GVf5jaq/4c3zvEXHdIgMg1WFo8pwVB2OKsRRlTiqFEfV4qhiHFWNA0/GeDI2DBoGqySHk5twy76oW/ZFjSdjPBnjyRhPxngyxpMxnozxZIwnYzwZ48kYT8Z4MqZGhynSYap0uMFgg8FmxgyDeDLGkzGejPFkjCdjPBnjybhVRZsqaVM1bT6L2hC5ytrAIIU73KqyDQzenszdgUE8GePJGE/GeDLGkzGejPFkjCdjPBnjyRhPxngyppKHKeVhanm4wWCDwduTeTpEhkE8Gbfk6H17Mk+n0yEyDOLJGE/GeDLGkzGejCnuYap7mPIexpMxnozxZEyJD1PjwxT5cNs8z9kXdcu+qPFkjCdjPBnjyRhPxngyxpMxnozxZIwnYzwZ48kYT8ZU/TBlP0zdD3cY7DDYk5swnozxZIwnYzwZ48kYT8Z4MsaTMZ6M8WSMJ2M8GePJmEIgphKIKQXiDoMdBrsZMwziyRhPxngyxpMxnozxZIwnYzwZ48kYT8Z4MsaTMbVBTHEQUx3EHQY7DN6ezNMhcpWY+qwxlee5p96gb0/m6RC5Ck3BIJ6M8WSMJ2M8GVMuxNQLMQVDjCdjPBnjyZiiIaZqiCkb4p7chHv2Rd2zL2o8GePJGE/GeDLGkzGejPFkjCdjPBnjyRhPxngyxpMxdURMIRFTScQdBjsM9s2YYRBPxngyvj2ZuyAYDOLJGE/GeDLGkzGejPFkjCdjPBlTWsTUFjHFRYwn4wGDtyfzdDqdwd+ZdBadjBlPxoP14GA9OFgPDhFZRKaW22A9OFgPUm7E1BsxnozxZIwnYzwZ48kYT8Z4MsaTMZ6M8WSMJ2M8GY/GmBtjbowZBilAYiqQ+PZk7m+Dd1E8GePJmDIkpg6JKURiPBnjyRhPxngyHlXtrcq9Vb23wZjZkxmfJd+IDIN4Mr49mXvMMDgmP8HJT3ASGQbxZDxgcCQ34ZH6Vh4pcOWRE4IeyU14JDfh25O5r/5i8Ol0OowZBvFkjCdjPBlTrMRUKzHlSownYzwZ48kYT8Z4Mh6bMSc34XH4NmAQT8a3J3MPFQYHteEoXmKql5jyJaZ+ifFkjCfjCYMTBvFkPKmiOCmjOKmjOCmkeHsy69V5MbjvjuiYzutNRnevV29U74Xhfb0Xh/PuvJ6P5w8/wvt1v7ct4/tKLxRfddl9+zLpter16n1cot1RXjymt+pPd/UOvbsc6dMTn2h1jVbXaHWNF5jpzerVNV5sJsqh96IzvbqPXtfodY1e1+h1jV7XeEGaKHWNXtcYdR+jrjHqGqOuMeoao64x6hqj7mPUNUZdY9Z9zLrGrGvMusasa8y6xqxrzLrGrJ/HrGususaqn8eL3tbu3sc12v2JF7/pjeq9OLvu3qrei+EnyguI+7m6KX56qp6r16rXqzeqN6v3usY9qvut9unVNU5d49Q1Tl3jnlbvT9xMP73XNV51qP/+7U/fffuH77/+7fnHVf78yw9//Kd/a+Xn//uRP+FfY/nxp7/+8euffvnp66vS8/1nv/7vr/8P", "file_map": { "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 5367017248a..3751a7a25f8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -69,7 +69,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+2dB5QV1bauq3cnskiUpE0QARW6aHJSggKCChIVBYkSFBQkJwElS1SSJCWjIEkJKgoSJKoIEpQkoKAEJSgowuvJYZ+z0Xa9O6r/f7GWu2qMPc55Pe+tN9dc30pfFXUjnP9cw1I7zuBU//nvEYm/yOv/KVfcX/4WkcTfAkn8LTKJv0Vd/1vk9XtHOf/7/zNw/e+hfwv+70Un/lL85W8xSfwtNom/pUjibymT+FuqJP6WOom/pUnib2mT+Fu6JP52SxJ/S5/E325N4m8ZkvhbxiT+limJv2VO4m9Zkvhb1iT+dlsSf8uWxN+yJ/G3HEn8LWcSf8uVxN9uT+JvdyTxt7gk/pY7ib/lSeJveZP4W74k/nZnEn/Ln8Tf7kribwWS+FvB638LZf2vV/Bv91//z4T4EsWKtSxZtKWb4DaNL1q6Wani8cWKNytRyi3lFi9VvEXRUgkJLUsVK1WydLPSJeNLu8USWrqtipdOaBX/nyv0XvHJvELzLcRMuFAS941P3uXeDc6R0e67QwoManeSucYn73KjrueKrsFbsWa3O9hHAXC77wHmiKxh6OQlOcY5N16RhPoiGUX1z72Ae7Vs1apVyxb/ySuUzdALzeu9DmfyL8xMuDDhvkUc7uQfn7zrWruLhBQYdN94RwFXcusQj8szIeAkfaHrgO63eAtydB0OT2Ez+xd1zN6VyI6kiIMf4AnAdkc6fz/m//Xoz6iN9F0CoTYzyTvV5ObnXm83eoy6wByLAfNC9kcgpG6hFypXFus2LEbFCDk6jAFU3LEGKFpnIWvAyrGEYwlQJYGNthWokhbkWMqxBKjSuESL2gpUaQtyLIPOMQAGSToeuNd35V5lksgzPnmXGwlsc1lwpzDOdEUd/KQxJ5Yzu0WC8ywHrCXQiLtzSHZd2ht3/b4MlsoSWJpLYikKnGf5fz9L7lwSl+Wdvz/1Qa8/yCezFYB9zRiLwSen6LUR2R/3OXrGdXzyrhscb3zyLhfoeN2ywL64H3Cvm/Hk8X4HOx8Fr4rMhCsS7lsJCAOr3ZVCCgy6L21TXMnBb2QqO/6El5x7ISe8KmQGEZsVBoMPONyNS3LzE/YYD5SQD2ofBOaFfsCH3jQHHLy0KeXgN6YBYJurOuavT1UIY+8dS6RNNWAtkQftd0iHY2lvnHPjhZYX1Q2t6VwL+qe6w5VqVR38WF+gSarFJ++ygqXk9sVCS+bdh4D9CuTPXUga1w8Rx7UIxPsc/Dxew9CxZ6qEdkIuk8/RwAeJbhUgb4s1zV3xybvcqsA21wTmtRiwjtwM8QqswQ3i9WFmwg8T7vsIECxWux8JKTDovrSD7SMOfrP7qBN+k1QthzNJxSfzchyOLGVwUxtYQ7kHWnrJAwWgyHZFDj9IqONjDpYftOSU9qIlZwlCf0cA21zHMX8tqEVg8X1LDtt1gbVEHuTeJx22pb1xzo0X+nBcz9CazrWgf+r9H/onPnmXsTVdAJR9yy2Zf+o7RjLpLifxXd/hSvw6Dn4tW2HJm7EN/v0suStIXDZwuBK6hoOfOxo6nLk3PnmXu9AXx8m6F9JPrLKkL5AepQ6wfo8D81plqYQG1uAGCf0EM+EnCPdtBASL1e5GIQUG3ZcmHho5+M3ak44/4SWnfk85nAkvPpmX43CENoPBxsAayj3QglMe1CD5E4H/GKGOTXA5xlv6lVY3NN+nmQk/TQDtaeC9mjrcxRdxz6YOfqFs6mAnUXQfy4KLXDRk8mxC6J9mDmdjgH5KhuS8uYNdiGz5t+wtHO7GIz551zUjJPYG/WbD+yTTltz+WEOyENFgblri+qKoDU9Z4pN3uWtizR5nMpe2dPDzSytcjjdYaLlv3PX7MmrRjFCLtZYwgF6nnwHmuJb0VOMZh/80GbivclsC+6e1Y+ScSWO8tYMf220cDpdtHP5TYPQ5pzWwrm0d83lqS+CpHYmnds7f5zn009ZngfVdbugeTOdTpbaAvgk+DQvN9zlmwnJz1EYimPxzwBzbA4Fn1bC9g5tYgjVs75g/oSLbHeyjDuR2I2QWo93PA/uG0d+sf0/+gmM256wP4iEWi2ANOxpeQxkzHQnsdHI4my+5b9z1+9pSi3WWvB78IrCWQMngriMJixeJLMmDhqYEltZb8npw538/S+56Epednb8fMP/68CE+eRf0FVKklOsIZLALMK8VFki5Lg5+vunqcBjvGsI4ev8WFEqo+8mD7WcJte0GrK1OmdIFUIOkZEp3ZsLdHbxM6Q7MsQcQLFYNezh4mdLDMX9iRbY72Ec9ye1GyBRGu3sB+8Zx8IuHbGaQwkcWog6EOvZ2zB43rH8f2cfwdrOkFGLRDdawr+E1lLmnL4Gdl4DtDt3Myn3jrt/XllpssURK9QPWEikStpAO//2c//9bNMmtaX9Da7regv7p7/DGujzEYUjDrZb8u1xTWdoKfDt5myXz7gDHyLHobiON6wEOV0ghZaQIqW4Ofp542bFjnmB9/yA+edcNIjy5ffGFJR/h7Qts8yvAvL6w9PsHwBrc8P2DgcyEBxLuOwgIFqvdg0IKDLov7UA9yMEvGIOd8JukhjicSSo+mZfjcCQwg5uhwBrKPRiyDSjoXZHevQl1HOaYPe+wZOgQYA2HG15DGYPDCey86mA3GsGDlNw37vp9banFV5YcykcAa4mULV+RDuUjHL4MHWloTddb0D8jHf4/hRoF7J9tFtR0lMObP0UcvUzoo9HAHE2VhY6C8fjkXe5wYF+MAeZlq0QB1uAGiTKWmfBYwn1fA4LFavdrIQUG3Ze2EX/NwW8+X3fCb5Ia53AmqfhkXo7DkSgMbsYDayj3QB/SRQ4iZZlIo2GEOk7A5Wjrhx+LhuY7kZnwRDxoRScCIZvkcBdMxD0nOfDFregkBzuJoicTWSSRi4ZMnhMI/fOGw1nMA+A8kZxPdrALEePU+wKhhlOAOa4nb2Lik3ddq+FownjZRzqhx4LznAqsJfJjjTa8MhefvAtp2tx9ho8zmZenEsbZNFyON9hKuW/c9fsy5pwWhFrst+R12KnANk93zJxz9lswHqcTGHzT4YzHN4njUWrxBqEWByxhAL1/fAuY4wHS06i3HO783ofA0yFNHwCPT97lAs+K7nRg/WY4Zu4DD1kwT8wg8DzT4YztmQ7/7YpZwPoa+vQeeqbQ+ZR0BqCfk/qOx2xmwnJz1EIcTH42MMc5wMHDquEcB/8djzmO+ZMzst3BPppLbjdC9DLaPQ/YN07IhX41ab7jb2a85Md6dRux6AT79m3H/DnnbcLYewfY7tANodw3zrnxQkutt4F1WADMK9yk1gIClwsdDpcLHa7UYtTiO0v+ScG7wFoCJZT7HUlovUtkSf5d+iQCS0cs+ejvon8/S+4REpeLHN73J4JiCnU/eeFjFoHzxY4ezuOTd0G/P4GUwAuAfbEEcK+b8er/Egc7PoPXUmbCSwn3XQaEgdXuZSEFBt2XtmFe5uAnvPccf8JLzr2QE977ZAYRIo/B4HJgf8g90JsX4QUpG2UjNJdQxxWO2XMYS+i9D6zhSsNrKGNwJYGdVQ520xI8VMh945wbL/TasBJYhw+AeYWb0PuAwOWHDofLDx2u0GPU4rglQu8jYC2REuY4SZx85PDfYlltaE2PWNA/qx3eWBcRtZjQ3x8b2t+mikxHMfbik3cZe/b8AMjbJ4B73QzZ9omDnTOC1xpmwmsI910LhIHV7rUhBQbdl7aZXevgN3CfOv6El5x7ISe8dWQGEbKNweB6YH/IPdAyR4Q0UIS6IhdXEOq4wTF7DmPJtnXAGm40vIYyBjcS2PnMwW5aggcduW+cc+OFXhs2AuuwCZhXuMm2TQQuNzscLjc7XNnGqMUpS2TbFmAtkaLgFEnmbHH4sm2roTU9YkH/bHW4su1jQn9vC4P+Pu7LtmTdaxOQt+2Ae90M2bbdwc4ZwetzZsKfE+77BRAGVru/CCkw6L60zewXDn4D96XjT3jJuRdywttBZhAh2xgMfuWYLdtESANFqCtycQOhjjtxOdr6gdyE0Hx3MRPehQctYRcQsq8d7uKLuOfXDnyhTPjawU6i6MlEFlzgRO/K5LmT0D+7Hc7GIADOE8n5Hge7EDFO9vMJNdwLzPGI4VZYariNMF4ukMxBDDjPfcBaIj+QGwYG0L1g+NiQuXQfYWx8g8vxBosq941zbrzQB899wDp8C8wrnJ7kCZffErjc73C43O9w7f4UQi1+s8R8fwts8wHHzPXrNwvG4wECgwcdzng8SByPUovdhFpcDFMGLlnyRsEhYC2Bfe1eIj2xPuT8fa8VDa7pYcfM+ThczhP/NFbik3e5QJfkHgDy9h3gXjfjCfN3DnaMB68jzISPEO57FAgDq91HQwoMui9tQT/q4Bf0Y44/SSWnft+TuUEIeAY3PwD7gzFeWP904HtgDY875s85xwnsnHCwC2RwEyz3jXNuvNCC4ziwDj8C8wo34fgjgcufHA6XP2ng8kdgHU4C8wo38XaSwOUph8PlKYcr3hi1+MMSAXUaWEukgPqDJKBOE1mSFz8OE/rojKF9dCkMxdFJYL/+DLjXzRBHPzvYsRm8fmEm/AvhvmeBMLDafTakwKD70jYlZx38QnzO8Sep5NTvPJkbhDhicHMB2B9yD7TgEV6QcksE6/eEOv7qmD3vsATceWANfzO8hjIGfyOwc9HBbjSChwC5b5xz44UWHb8B63AJmFe4CbhLBC5/dzhc/q6By0vAOvwBzCvcBNwfBC4vOxwuLztcAceoxVVLBNyfwFoi5c5VkoD70+EKuDOEPrpiaB/9EYYC7g9gv14F3OtmCLirDnZs/i1RRsJyU/R9IyLMFnDS7oiQCoPuS9uURETgF+JAhD9JJad+kRFcbhACjsFNFK7dFAEnYhkoR10Rjr8S+ic6wux5hyXgIoFrQ4zhNZQxGEMYg7ER2I1G8BAg941zbrzQoiMG2P8pgHNRuAm4FAQuU5K4TKmByxRALlMBuQw3AZeKwGVqEpepI7gCjlGLyBR2CLg0wDGElDvI+oWylCaCK+CuEPooraF9dDUMBVwq4PqVDnCvmyHg0oHn+eB1SwQx4VsIAi694QJO2p3eIgGXnrAQ3xqGAg45SWWwQMAxuMlouIATsQyUo64Ix2hCHTMB+bH0g7rFQvPNHEFMWG4OBq1YZiBkWcgLJuKeWfAbhWJZDDeocnJJyzCopFMw+qM5WYGMIz/oaeiJ2kX3K5pnGW9ZCTzfRjJct2kwr1mBc282/4mAp/yEy2wELrOTuMyugctsQC5z+E8EPOUnXOYgcJmTxGVOssXd6xCe2pH2QujxmAM4HnMZaq5TWrB/yUUYj7eTxuPtSawTAXDuyLPjHWC5809jMbl5xv37n85BzxI6n4LkAj69Cc03dwQx4dwRuIEZTD43ENI8hj9RkRrmAU7MwRrmMVwQZQG3O9hHeQ1/usBqdz7Dny7IUzPgkx9XnqZkItTxTsPHDev13lzAeTK/BXNPfgI7d5E2w3dpkCb5gf1fwJd5nvITLgsQuCxI4rKgBi4LALks5Ms8T/kJl4UIXN5N4vJuDVwWAnJ5jy+1POUnXN5D4PJeEpf3hnCJ3r8FBR/qfiK04gi1LQysrU45cw9JzhSJICZchCBnigAhizdczkgN4wlyJt6CA1I8YfC7FsgZRruLGi5nZOEAijNXZNSdhDomhKmcuQc4TxazYO4pRmCnOGlTV1zDYaMYsP9L+HLGU37CZQkClyVJXJbUwGUJIJelfDnjKT/hshSBy9IkLktr4LIUkMsyvpzxlJ9wWYbAZVkSl2XJcgYp+UTOFCbUtpylcqYMSc6UjyAmXJ4gZ8oDIatguJyRGlYgyJkKFhyQKhAG/30WyBlGu+83XM7IwgEUZ67IqARCHSuGqZwpA5wnK1kw91QisFOZtKmrrOGwUQnY/1V8OeMpP+GyCoHLB0hcPqCByypALh/05Yyn/ITLBwlcViVxWVUDlw8CuazmyxlP+QmX1QhcVidxWZ0sZ5CST+RMOUJtH7JUzlQjyZkaEcSEaxDkTA0gZDUNlzNSw5oEOVPTggNSTcLgf9gCOcNo9yOGyxlZOIDizBUZVZFQx0dv0uKBmJtAeRcPzbdWBDHhWhFw0IrXAkJWm7x4IO5ZOwI+ORevbcHiwdiV32b4aUR2zA8R2p1N0wdSkpvnY8CxjfxYHJAbN5vhDMrc8BiBwTqkE3EdDabmMeA6Udc3257yEy7rErisR+KyngYu6wK5rO+bbU/5CZf1CVw2IHHZQAOX9YFcNvTNtqf8hMuGBC4fJ3H5eAT/Q2fI894TYCETvND/J24aAfM0dR+s0+I3JFn8JyOICT9JsPhPAsF6ynCLLzV8imDxnzJcxNQGtzvYR40Nt/isdjcx3OKLdAM+YXHlqcWjhDo+bfi4Yb1i2RA4Tza1YO5pSmCnGWkD20zDwaopsP+b+yLKU37CZXMCly1IXLbQwGVzIJctfRHlKT/hsiWBy1YkLltp4LIlkMtnfBHlKT/h8hkCl61JXLaO4L1iGZRyqPuJhGpEqG0bYG11yplnSHKmbQQx4bYEOdMWCFk7w+WM1LAdQc60s+CA1I4w+J+1QM4w2v2c4XJGFg6gOHNFRj1NqGP7MJUzzwDnyQ4WzD0dCOw8T9rUPa/hsNEB2P8v+HLGU37C5QsELjuSuOyogcsXgFx28uWMp/yEy04ELl8kcfmiBi47Abns7MsZT/kJl50JXHYhcdmFLGeQkk/kTBtCbbtaKmc6k+RMtwhiwt0IcqYbELLuhssZqWF3gpzpbsEBqTth8PewQM4w2t3TcDkjCwdQnLkio9oT6tgrTOVMZ+A82duCuac3gZ0+pE1dHw2Hjd7A/u/ryxlP+QmXfQlcvkTi8iUNXPYFctnPlzOe8hMu+xG47E/isr8GLvsBuRzgyxlP+QmXAwhcvkzi8mWynEFKPpEzXQm1fcVSOTOAJGcGRhATHkiQMwOBkA0yXM5IDQcR5MwgCw5IgwiDf7AFcobR7iGGyxlZOIDizBUZ1YtQx6E3afFAzE2gvEuE5jssgpjwsAg4aCWGASEbTl48EPccHgGfnEsMt2DxYOzKCxh+GpEd8yuEdhe05ONkrwLHNvLjZEBu3IKGMyhzw6sEBkeQTsQjNJiaV4HrxEjfbHvKT7gcSeByFInLURq4HAnkcrRvtj3lJ1yOJnA5hsTlGA1cjgZyOdY3257yEy7HErh8jcTlaxH8j5Mhz3uvg4VM8EJ/nGwcME9T98E6Lf5YksUfH0FMeDzB4o8HgjXBcIsvNZxAsPgTDBcxw8HtDvbRRMMtPqvdkwy3+CLdgE9YXHlqMZRQxzcMHzesVyzHAufJyRbMPZMJ7EwhbWCnaDhYTQb2/1RfRHnKT7icSuByGonLaRq4nArkcrovojzlJ1xOJ3D5JonLNzVwOR3I5Vu+iPKUn3D5FoHLGSQuZ0TwXrEMSjnU/URCjSPUdiawtjrlzFskOTMrgpjwLIKcmQWEbLbhckZqOJsgZ2ZbcECaTRj8cyyQM4x2zzVczsjCARRnrsioNwh1nBemcuYt4Dw534K5Zz6BnbdJm7q3NRw25gP7/x1fznjKT7h8h8DlAhKXCzRw+Q6Qy4W+nPGUn3C5kMDluyQu39XA5UIgl4t8OeMpP+FyEYHLxSQuF5PlDFLyiZyZSajtEkvlzCKSnFkaQUx4KUHOLAVCtsxwOSM1XEaQM8ssOCAtIwz+9yyQM4x2v2+4nJGFAyjOXJFR8wh1XB6mcmYRcJ5cYcHcs4LAzkrSpm6lhsPGCmD/r/LljKf8hMtVBC4/IHH5gQYuVwG5/NCXM57yEy4/JHD5EYnLjzRw+SGQy9W+nPGUn3C5msDlxyQuPybLGaTkEzmzhFDbTyyVM6tJcmZNBDHhNQQ5swa5uTNczkgN1xLkzFoLDkhrCYP/UwvkDKPd6wyXM7JwAMWZKzJqOaGO62/S4oGYm0B5lwzNd0MEMeENEXDQSm4AQraRvHgg7rkxAj45l9xoweLB2JWXMvw0IjvmTwjtLm3Jx8k+A45t5MfJgNy4pQ1nUOaGzwgMbiKdiDdpMDWfAdeJzb7Z9pSfcLmZwOUWEpdbNHC5GcjlVt9se8pPuNxK4HIbicttGrjcCuRyu2+2PeUnXG4ncPk5icvPI/gfJ0Oe974AC5nghf442ZfAPE3dB+u0+NtJFn9HBDHhHQSLvwMI1leGW3yp4VcEi/+V4SJmI7jdwT7aabjFZ7V7l+EWX6Qb8AmLK08t1hPq+LXh44b1iuV24Dy524K5ZzeBnT2kDeweDQer3cD+3+uLKE/5CZd7CVzuI3G5TwOXe4FcfuOLKE/5CZffELj8lsTltxq4/AbI5X5fRHnKT7jcT+DyAInLAxG8VyyDUg51P5FQXxJqexBYW51yZj9JzhyKICZ8iCBnDgEhO2y4nJEaHibImcMWHJAOEwb/dxbIGUa7jxguZ2ThAIozV2TU14Q6Hg1TObMfOE8es2DuOUZg53vSpu57DYeNY8D+/8GXM57yEy5/IHB5nMTlcQ1c/gDk8oQvZzzlJ1yeIHD5I4nLHzVweQLI5U++nPGUn3D5E4HLkyQuT5LlDFLyiZw5SKjtKUvlzE8kOXM6gpjwaYKcOQ2E7IzhckZqeIYgZ85YcEA6Qxj8P1sgZxjt/sVwOSMLB1CcuSKjjhLqeDZM5cxPwHnynAVzzzkCO+dJm7rzGg4b54D9f8GXM57yEy4vELj8lcTlrxq4vADk8jdfznjKT7j8jcDlRRKXFzVw+RuQy0u+nPGUn3B5icDl7yQufyfLGaTkEzlzilDbPyyVM5dIcuZyBDHhywQ5cxkI2Z+Gyxmp4Z8EOfOnBQekPwmD/4oFcobR7quGyxlZOIDizBUZdZZQR2k4ih9LP05WKjTfiAAxYbk5GLRSEbgOdAMB7uKBuKfkCJ6cSwUC5i8ejF15NcNPI7Jj/oPQ7uqWfJwsEji2kR8nA3LjVjecQZkbIgN4BqOAc07oiVjuG+fceKFNTSRwnYgGMh5OZlu4jCZwGUPiMkYDl9FALmOBXIaT2RYuYwlcpiBxmUIDl7FALlMCuQwnsy1cpiRwmYrEZaoA/+NkyPNeaiCXoW1Gf5wsDTBPU/fBOi1+SgBDSVn8tAFiwmkDeIufFghWOrKIiU/eda2G6QJ4i5/OcBETALc72Ee3kNuNWCgY7U4PXjTAcvXa0yrgExZXnlo4hDreavi4Yb1imRI4T2awYO7JQGAnI2kDm1HDwSoDsP8z+SLKU37CZSYCl5lJXGbWwGUmIJdZfBHlKT/hMguBy6wkLrNq4DILkMvbfBHlKT/h8jYCl9lIXGYL8F6xDEo51P1EQqUh1DY7sLY65cxtJDmTI0BMOAdBzuQAQpbTcDkjNcxJkDM5LTgg5SQM/lwWyBlGu283XM7IwgEUZ67IqFsJdbwjTOXMbcB5Ms6CuSeOwE5u0qYut4bDRhyw//P4csZTfsJlHgKXeUlc5tXAZR4gl/l8OeMpP+EyH4HLO0lc3qmBy3xALvP7csZTfsJlfgKXd5G4vIssZ5CST+RMdkJtC1gqZ/KT5EzBADHhggQ5UxAIWSHD5YzUsBBBzhSy4IBUiDD477ZAzjDafY/hckYWDqA4c0VG3UGo471hKmfyA+fJwhbMPYUJ7BQhbeqKaDhsFAb2f7wvZzzlJ1zGE7h0SVy6GriMB3JZ1JcznvITLosSuEwgcZmggcuiQC6L+XLGU37CZTECl8VJXBYnyxmk5BM5U4BQ2xKWypliJDlTMkBMuCRBzpQEQlbKcDkjNSxFkDOlLDgglSIM/tIWyBlGu8sYLmdk4QCKM1dk1L2EOpa9SYsHYm4C5V06NN9yAWLC5QJw0EqXA0JWnrx4IO5ZPgCfnEuXt2DxYOzKGxp+GpEdcwlCux+35ONkFYBjG/lxMiA37uOGMyhzQwUCg/eRTsT3aTA1FYDrxP1AxsPJbF9bswhcViRxWVEDl/cDuawE5DKczLZwWYnAZWUSl5U1cFkJyGUVIJfhZLaFyyoELh8gcflAgP9xMuR570GwkAle6I+TVQXmaeo+WKfFrwJgKCmLXy1ATLhaAG/xqwHBqk4WMfHJu67VsHoAb/GrGy5iyoPbHeyjh8jtRiwUjHbXAC8aAXB/i3QDPmFx5alFWUIdaxo+blivWFYBzpMPWzD3PExg5xHSBvYRDQerh4H9/6gvojzlJ1w+SuCyFonLWhq4fBTIZW1fRHnKT7isTeDyMRKXj2ngsjaQyzq+iPKUn3BZh8BlXRKXdQO8VyyDUg51P5FQVQm1rQesrU45U4ckZ+oHiAnXJ8iZ+kDIGhguZ6SGDQhypoEFB6QGhMHf0AI5w2j344bLGVk4gOLMFRlVk1DHJ8JUztQBzpONLJh7GhHYeZK0qXtSw2GjEbD/n/LljKf8hMunCFw2JnHZWAOXTwG5bOLLGU/5CZdNCFw+TeLyaQ1cNgFy2dSXM57yEy6bErhsRuKyGVnOICWfyJl6hNo2t1TONCXJmRYBYsItCHKmBRCylobLGalhS4KcaWnBAaklYfC3skDOMNr9jOFyRhYOoDhzRUY9Qahj6zCVM02B82QbC+aeNgR22pI2dW01HDbaAPu/nS9nPOUnXLYjcPksictnNXDZDsjlc76c8ZSfcPkcgcv2JC7ba+DyOSCXHXw54yk/4bIDgcvnSVw+T5YzSMkncqY5obYvWCpnOpDkTMcAMeGOBDnTEQhZJ8PljNSwE0HOdLLggNSJMPhftEDOMNrd2XA5IwsHUJy5IqNaE+rY5SYtHoi5CZR309B8uwaICXcNwEFr2hUIWTfy4oG4Z7cAfHJu2s2CxYOxK29t+GlEdswvENrdxpKPk3UHjm3kx8mA3LhtDGdQ5obuBAZ7kE7EPTSYmu7AdaInkPFwMtvCZU8Cl71IXPbSwGVPIJe9gVyGk9kWLnsTuOxD4rKPBi57A7nsC+QynMy2cNmXwOVLJC5fCvA/ToY87/UDC5nghf44WX9gnqbug3Va/L4AhpKy+AMCxIQHBPAWfwAQrJfJIiY+ede1Gr4cwFv8lw0XMd3A7Q720SvkdiMWCka7B4IXjQC4v0W6AZ+wuPLUoguhjoMMHzesVyz7AufJwRbMPYMJ7AwhbWCHaDhYDQb2/1BfRHnKT7gcSuByGInLYRq4HArkcrgvojzlJ1wOJ3D5KonLVzVwORzI5QhfRHnKT7gcQeByJInLkQHeK5ZBKYe6n0io/oTajgLWVqecGUGSM6MDxIRHE+TMaCBkYwyXM1LDMQQ5M8aCA9IYwuAfa4GcYbT7NcPljCwcQHHmiowaRKjj62EqZ0YA58lxFsw94wjsjCdt6sZrOGyMA/b/BF/OeMpPuJxA4HIiicuJGricAORyki9nPOUnXE4icPkGics3NHA5CcjlZF/OeMpPuJxM4HIKicspZDmDlHwiZ0YRajvVUjkzmSRnpgWICU8jyJlpQMimGy5npIbTCXJmugUHpOmEwf+mBXKG0e63DJczsnAAxZkrMup1Qh1nhKmcmQycJ2daMPfMJLAzi7Spm6XhsDET2P+zfTnjKT/hcjaByzkkLudo4HI2kMu5vpzxlJ9wOZfA5TwSl/M0cDkXyOV8X854yk+4nE/g8m0Sl2+T5QxS8omcmUqo7TuWypn5JDmzIEBMeAFBziwAQrbQcDkjNVxIkDMLLTggLSQM/nctkDOMdi8yXM7IwgEUZ67IqBmEOi6+SYsHYm4C5d0sNN8lAWLCSwJw0JotAUK2lLx4IO65NACfnJsttWDxYOzKuxl+GpEd8zuEdne35ONky5ALCPAUC+TG7W44gzI3LCMw+B7pRPyeBlOzDLhOvA9kPJzMtnD5PoHL5SQul2vg8n0glyuAXIaT2RYuVxC4XEnicqUGLlcAuVwF5DKczLZwuYrA5QckLj8I8D9OhjzvfQgWMsEL/XGyj4B5mroP1mnxVwEYSsrirw4QE14dwFv81UCwPiaLmPjkXddq+HEAb/E/NlzELAW3O9hHn5DbjVgoGO1eA140AuD+FukGfMLiylOLxYQ6rjV83LBesVwFnCc/tWDu+ZTAzjrSBnadhoPVp8D+X++LKE/5CZfrCVxuIHG5QQOX64FcbvRFlKf8hMuNBC4/I3H5mQYuNwK53OSLKE/5CZebCFxuJnG5OcB7xTIo5VD3Ewn1EaG2W4C11SlnNpHkzNYAMeGtBDmzFQjZNsPljNRwG0HObLPggLSNMPi3WyBnGO3+3HA5IwsHUJy5IqPWEur4RZjKmU3AefJLC+aeLwns7CBt6nZoOGx8Cez/r3w54yk/4fIrApc7SVzu1MDlV0Aud/lyxlN+wuUuApdfk7j8WgOXu4Bc7vbljKf8hMvdBC73kLjcQ5YzSMkncmYLobZ7LZUzu0lyZl+AmPA+gpzZB4TsG8PljNTwG4Kc+caCA9I3hMH/rQVyhtHu/YbLGVk4gOLMFRn1BaGOB8JUzuwGzpMHLZh7DhLYOUTa1B3ScNg4COz/w76c8ZSfcHmYwOV3JC6/08DlYSCXR3w54yk/4fIIgcujJC6PauDyCJDLY76c8ZSfcHmMwOX3JC6/J8sZpOQTObOXUNsfLJUzx0hy5niAmPBxgpw5DoTshOFyRmp4giBnTlhwQDpBGPw/WiBnGO3+yXA5IwsHUJy5IqMOEOp48iYtHoi5CZR389B8TwWICZ8KwEFrfgoI2Wny4oG45+kAfHJuftqCxYOxKx9s+GlEdsw/ENo9xJKPk50Bjm3kx8mA3LhDDGdQ5oYzBAZ/Jp2If9Zgas4A14lfgIyHk9kWLn8hcHmWxOVZDVz+AuTyHJDLcDLbwuU5ApfnSVye18DlOSCXF4BchpPZFi4vELj8lcTlrwH+x8mQ573fwEImeKE/TnYRmKep+2CdFv8CgKGkLP6lADHhSwG8xb8EBOt3soiJT951rYa/B/AW/3fDRcxpcLuDffQHud2IhYLR7svgRSMA7m+RbsAnLK48tThJqOOfho8b1iuWF4Dz5BUL5p4rBHaukjawVzUcrK4g18lIX0R5yU+4lNqhuYyI5HAp941zuFyGspTcOgSAXIabiAoQuIwkcRmpgcsAkMsoIJfhJqKiCFxGk7iMjuS9YhmUcqj7iYS6SNgjxQBrq1PORAHGe1JyJjaSmLDcHC1nYoGTVQrgJMqqYYpIvJxJEWn+xJqCMLGmJLcbIWcY7U4FHDNyD8bhHyjOXJFRfxIWj9SGjxuWnIkCzpNpLJh70hDGYFrSpi6thsNGGmD/p/PljKf8hMt0BC5vIXF5iwYu0wG5TO/LGU/5CZfpCVzeSuLyVg1cpgdymcGXM57yEy4zELjMSOIyI1nOICWfyJkYQm0zWSpnMpDkTOZIYsKZCXImMxCyLIbLGalhFoKcyWLBASkLYfBntUDOMNp9m+FyRhYOoDhzRUalJtQxW5jKmQzAeTK7BXNPdgI7OUibuhwaDhvZgf2f05cznvITLnMSuMxF4jKXBi5zArm83ZcznvITLm8ncHkHics7NHB5O5DLOF/OeMpPuIwjcJmbxGVuspxBSj6RM5kItc1jqZyJI8mZvJHEhPMS5ExeIGT5DJczUsN8BDmTz4IDUj7C4L/TAjnDaHd+w+WMLBxAceaKjMpGqONdN2nxQMxNoLxbhOZbIJKYcIFIOGgtCgAhK0hePBD3LBgJn5xbFLRg8WDsyicYfhqRHXMeQrsnWvJxskLAsY38OBmQG3ei4QzK3FCIwODdpBPx3RpMTSHgOnGPb7Y95Sdc3kPg8l4Sl/dq4PIeIJeFfbPtKT/hsjCByyIkLoto4LIwkMt432x7yk+4jCdw6ZK4dCP5HydDnveKgoVM8IoEtzkBmKep+2CdFj+eZPGLRRITLkaw+MWAYBU33OJLDYsTLH5xw0VMQXC7g31UwnCLz2p3ScMtvkg34BMWV55a3EWoY6kwfcUyHjhPlrZg7ilNYKcMaQNbRsPBqjSw/8v6IspTfsJlWQKX5UhcltPAZVkgl+V9EeUpP+GyPIHLCiQuK2jgsjyQy/t8EeUpP+HyPgKX95O4vJ/4imVQyqHuJxIqgVDbipa+YnkfSc5UiiQmXIkgZyoBIatsuJyRGlYmyJnKFhyQKhMGfxUL5Ayj3Q8YLmdk4QCKM1dkVClCHR8MUzlzH3CerGrB3FOVwE410qaumobDRlVg/1f35Yyn/ITL6gQuHyJx+ZAGLqsDuazhyxlP+QmXNQhc1iRxWVMDlzWAXD7syxlP+QmXDxO4fITE5SNkOYOUfCJnKhJq+6ilcuZhkpypFUlMuBZBztQCQlbbcDkjNaxNkDO1LTgg1SYM/scskDOMdtcxXM7IwgEUZ67IqAcJdawbpnLmYeA8Wc+CuacegZ36pE1dfQ2HjXrA/m/gyxlP+QmXDQhcNiRx2VADlw2AXD7uyxlP+QmXjxO4fILE5RMauHwcyGUjX854yk+4bETg8kkSl0+S5QxS8omceZRQ26cslTONSHKmcSQx4cYEOdMYCFkTw+WM1LAJQc40seCA1IQw+J+2QM4w2t3UcDkjCwdQnLkio+oS6tjsJi0eiLkJlHfL0HybRxITbh4JB61lcyBkLciLB+KeLSLhk3PLFhYsHoxd+VzDTyOyY36K0O55lnycrCVwbCM/Tgbkxp1nOIMyN7QkMNiKdCJupcHUtASuE8/4ZttTfsLlMwQuW5O4bK2By2eAXLbxzban/ITLNgQu25K4bKuByzZALtv5ZttTfsJlOwKXz5K4fDaS/3Ey5HnvObCQCV6R4Da3B+Zp6j5Yp8VvR7L4HSKJCXcgWPwOQLCeN9ziSw2fJ1j85w0XMS3A7Q720QuGW3xWuzsabvFFugGfsLjy1KIZoY6dwvQVy3bAefJFC+aeFwnsdCZtYDtrOFi9COz/Lr6I8pSfcNmFwGVXEpddNXDZBchlN19EecpPuOxG4LI7icvuGrjsBuSyhy+iPOUnXPYgcNmTxGVP4iuWQSmHup9IqPaE2vay9BXLHiQ50zuSmHBvgpzpDYSsj+FyRmrYhyBn+lhwQOpDGPx9LZAzjHa/ZLickYUDKM5ckVGdCHXsF6ZypgdwnuxvwdzTn8DOANKmboCGw0Z/YP+/7MsZT/kJly8TuHyFxOUrGrh8GcjlQF/OeMpPuBxI4HIQictBGrgcCORysC9nPOUnXA4mcDmExOUQspxBSj6RM70ItR1qqZwZTJIzwyKJCQ8jyJlhQMiGGy5npIbDCXJmuAUHpOGEwf+qBXKG0e4RhssZWTiA4swVGdWPUMeRYSpnBgPnyVEWzD2jCOyMJm3qRms4bIwC9v8YX854yk+4HEPgciyJy7EauBwD5PI1X854yk+4fI3A5eskLl/XwOVrQC7H+XLGU37C5TgCl+NJXI4nyxmk5BM5M5RQ2wmWyplxJDkzMZKY8ESCnJkIhGyS4XJGajiJIGcmWXBAmkQY/G9YIGcY7Z5suJyRhQMozlyRUSMJdZxykxYPxNwEyrtVaL5TI4kJT42Eg9ZqKhCyaeTFA3HPaZHwybnVNAsWD8aufIXhpxHZMU8gtHulJR8nmw4c28iPkwG5cVcazqDMDdMJDL5JOhG/qcHUTAeuE2/5ZttTfsLlWwQuZ5C4nKGBy7eAXM70zban/ITLmQQuZ5G4nKWBy5lALmf7ZttTfsLlbAKXc0hczonkf5wMed6bCxYywSsS3OZ5wDxN3QfrtPizSRZ/fiQx4fkEiz8fCNbbhlt8qeHbBIv/tuEiZhq43cE+esdwi89q9wLDLb5IN+ATFleeWkwh1HFhmL5iORs4T75rwdzzLoGdRaQN7CINB6t3gf2/2BdRnvITLhcTuFxC4nKJBi4XA7lc6osoT/kJl0sJXC4jcblMA5dLgVy+54soT/kJl+8RuHyfxOX7xFcsg1IOdT+RUPMItV1u6SuW75HkzIpIYsIrCHJmBRCylYbLGanhSoKcWWnBAWklYfCvskDOMNr9geFyRhYOoDhzRUYtJNTxwzCVM+8B58mPLJh7PiKws5q0qVut4bDxEbD/P/bljKf8hMuPCVx+QuLyEw1cfgzkco0vZzzlJ1yuIXC5lsTlWg1crgFy+akvZzzlJ1x+SuByHYnLdWQ5g5R8ImeWE2q73lI58ylJzmyIJCa8gSBnNgAh22i4nJEabiTImY0WHJA2Egb/ZxbIGUa7NxkuZ2ThAIozV2TUh4Q6bg5TOfMpcJ7cYsHcs4XAzlbSpm6rhsPGFmD/b/PljKf8hMttBC63k7jcroHLbUAuP/fljKf8hMvPCVx+QeLyCw1cfg7k8ktfznjKT7j8ksDlDhKXO8hyBin5RM6sJ9T2K0vlzJckObMzkpjwToKc2QmEbJfhckZquIsgZ3ZZcEDaRRj8X1sgZxjt3m24nJGFAyjOXJFRmwl13HOTFg/E3ITJ240PzXdvJDHhvZFo0Nz4vUDI9pEXD8Q990WiJ2c3fp8FiwdjV/6Z4acR2TF/xTD7lnyc7Bvg2EZ+nAzIjbvJcAZlbviGwOC3pBPxtxpMzTfAdWK/b7Y95Sdc7idweYDE5QENXO4HcnnQN9ue8hMuDxK4PETi8pAGLg8CuTzsm21P+QmXhwlcfkfi8rtI/sfJkOe9I2AhE7wiwW0+CszT1H2wTot/mGTxj0USEz5GsPjHgGB9b7jFlxp+T7D43xsuYvaB2x3sox8Mt/isdh833OKLdAM+YXHlqcUeQh1PhOkrloeB8+SPFsw9PxLY+Ym0gf1Jw8HqR2D/n/RFlKf8hMuTBC5Pkbg8pYHLk0AuT/siylN+wuVpApdnSFye0cDlaSCXP/siylN+wuXPBC5/IXH5C/EVy6CUQ91PJNRRQm3PWvqK5c8kOXMukpjwOYKcOQeE7LzhckZqeJ4gZ85bcEA6Txj8FyyQM4x2/2q4nJGFAyjOXJFRJwh1/C1M5czPwHnyogVzz0UCO5dIm7pLGg4bF4H9/7svZzzlJ1z+TuDyDxKXf2jg8ncgl5d9OeMpP+HyMoHLP0lc/qmBy8tALq/4csZTfsLlFQKXV0lcXiXLGaTkEzlzllBbGYio2uqUM1dIciYiipiw3BwtZyJwHegGosyWM1JDyREtZwJR5k+syHYH+yiS3G6EnGG0Owo4ZuQejMM/UJy5IqN+Iywe0YaPG5acuQLcbMZYMPfEEMZgLLDdoZs6uW+cc+OFPmzEANfJFMC5KNzkTAoClylJXKbUwGUKIJepgFyGm5xJReAyNYnL1Bq4TAXkMg2Qy3CTM2kIXKYlcZk2iitnroDljEOobTpL5UwawHhPSs7cEkVM+BaCnLkFOFmlN1zOSA3TE+RMegsOSOkJg/9WC+QMo90ZDJczsnAAxZkrMiqaUMeMN2nxQMxNmLzdGxaPTFHEhDNFwT9O5mYCQpaZvHgg7pk5Cv5xshvaHZ/MK6l2xyfvou3K9xh+GpEdczpCu/da8nGyLMCxjfw4GZAbd6/hDMrckIXAYFbSiTirBlOTBbhO3OabbU/5CZe3EbjMRuIymwYubwNymd03257yEy6zE7jMQeIyhwYuswO5zOmbbU/5CZc5CVzmInGZK4r/cTLkee92sJAJXpHgNt8BzNPUfbBOi5+TZPHjoogJxxEsfhwQrNyGW3ypYW6Cxc9tuIjJDG53sI/yGG7xWe3Oa7jFF+kGfMLiylOLjIQ65gvTVyxzAufJOy2Ye+4ksJOftIHNr+FgdSew/+/yRZSn/ITLuwhcFiBxWUADl3cBuSzoiyhP+QmXBQlcFiJxWUgDlwWBXN7tiyhP+QmXdxO4vIfE5T3EVyyDUg51P5FQdxBqe6+lr1jeTZIzhaOICRcmyJnCQMiKGC5npIZFCHKmiAUHpCKEwR9vgZxhtNs1XM7IwgEUZ67IqHyEOhYNUzlzN3CeTLBg7kkgsFOMtKkrpuGwkQDs/+K+nPGUn3BZnMBlCRKXJTRwWRzIZUlfznjKT7gsSeCyFInLUhq4LAnksrQvZzzlJ1yWJnBZhsRlGbKcQUo+kTP3Empb1lI5U5okZ8pFERMuR5Az5YCQlTdczkgNyxPkTHkLDkjlCYO/ggVyhtHu+wyXM7JwAMWZK5aiKKGO94epnCkNnCcrWjD3VCSwU4m0qauk4bBREdj/lX054yk/4bIygcsqJC6raOCyMpDLB3w54yk/4fIBApcPkrh8UAOXDwC5rOrLGU/5CZdVCVxWI3FZjSxnkJJP5ExZQm2rWypnqpLkzENRxIQfIsiZh4CQ1TBczkgNaxDkTA0LDkg1CIO/pgVyhtHuhw2XM7JwAMWZe01GEer4yE1aPBBzEyZvt2hovo9GERN+NAr+cbKijwIhq0VePBD3rBUF/zhZ0VoWLB6MXflxw08jsmOuTmj3CUs+TlYbOLaRHycDcuOeMJxBmRtqExh8jHQifkyDqakNXCfq+GbbU37CZR0Cl3VJXNbVwGUdIJf1fLPtKT/hsh6By/okLutr4LIekMsGvtn2lJ9w2YDAZUMSlw2j+B8nQ573HgcLmeCF/jjZE8A8Td0H67T4DUgWv1EUMeFGBIvfCAjWk4ZbfKnhkwSL/6ThIqYWuN3BPnrKcIvPandjwy2+SDfgExZXnlo8QqhjkzB9xbIBcJ582oK552kCO01JG9imGg5WTwP7v5kvojzlJ1w2I3DZnMRlcw1cNgNy2cIXUZ7yEy5bELhsSeKypQYuWwC5bOWLKE/5CZetCFw+Q+LyGeIrlkEph7qfSKgnCLVtbekrlq1IcqZNFDHhNgQ50wYIWVvD5YzUsC1BzrS14IDUljD421kgZxjtftZwOSMLB1CcuSKjmhDq+FyYyplWwHmyvQVzT3sCOx1Im7oOGg4b7YH9/7wvZzzlJ1w+T+DyBRKXL2jg8nkglx19OeMpP+GyI4HLTiQuO2ngsiOQyxd9OeMpP+HyRQKXnUlcdibLGaTkEznTmlDbLpbKmRdJcqZrFDHhrgQ50xUIWTfD5YzUsBtBznSz4IDUjTD4u1sgZxjt7mG4nJGFAyjOXJFRzxHq2DNM5cyLwHmylwVzTy8CO71Jm7reGg4bvYD938eXM57yEy77ELjsS+KyrwYu+wC5fMmXM57yEy5fInDZj8RlPw1cvgTksr8vZzzlJ1z2J3A5gMTlALKcQUo+kTNdCLV92VI5058kZ16JIib8CkHOvAKEbKDhckZqOJAgZwZacEAaSBj8gyyQM4x2DzZczsjCARRnrsionoQ6DrlJiwdibsLk7SaE5js0ipjw0Cj4x8kShgIhG0ZePBD3HBYF/zhZwjALFg/Grvyi4acR2TG/TGj3JUs+TjYcOLaRHycDcuNeMpxBmRuGExh8lXQiflWDqRkOXCdG+GbbU37C5QgClyNJXI7UwOUIIJejfLPtKT/hchSBy9EkLkdr4HIUkMsxvtn2lJ9wOYbA5VgSl2Oj+B8nQ573XgMLmeCF/jjZ68jxY+g+WKfFH0Oy+OOiiAmPI1j8cUCwxhtu8aWG4wkWf7zhImYYuN3BPppguMVntXui4RZfpBvwCYsrTy2GEOo4KUxfsRwDnCffsGDueYPAzmTSBnayhoPVG8D+n+KLKE/5CZdTCFxOJXE5VQOXU4BcTvNFlKf8hMtpBC6nk7icroHLaUAu3/RFlKf8hMs3CVy+ReLyLeIrlkEph7qfSKjXCbWdYekrlm+S5MzMKGLCMwlyZiYQslmGyxmp4SyCnJllwQFpFmHwz7ZAzjDaPcdwOSMLB1CcuSKjJhHqODdM5cybwHlyngVzzzwCO/NJm7r5Gg4b84D9/7YvZzzlJ1y+TeDyHRKX72jg8m0glwt8OeMpP+FyAYHLhSQuF2rgcgGQy3d9OeMpP+HyXQKXi0hcLiLLGaTkEzkzg1DbxZbKmXdJcmZJFDHhJQQ5swQI2VLD5YzUcClBziy14IC0lDD4l1kgZxjtfs9wOSMLB1CcuSKj5hLq+H6Yypl3gfPkcgvmnuUEdlaQNnUrNBw2lgP7f6UvZzzlJ1yuJHC5isTlKg1crgRy+YEvZzzlJ1x+QODyQxKXH2rg8gMglx/5csZTfsLlRwQuV5O4XE2WM0jJJ3JmMaG2H1sqZz4iyZlPoogJf0KQM58AIVtjuJyRGq4hyJk1FhyQ1hAG/1oL5Ayj3Z8aLmdk4QCKM1dk1PuEOq67SYsHYm7C5O0WC813fRQx4fVR8I+TFVsPhGwDefFA3HNDFPzjZMU2WLB4MHblKVKa3W7ZMX9MaHdKcLuDVxQ4z43AsY38OBmQGzel4QzK3LCRwOBnpBPxZxpMzUbgOrHJN9ue8hMuNxG43EzicrMGLjcBudzim21P+QmXWwhcbiVxuVUDl1uAXG7zzban/ITLbQQut5O43B7F/zgZ8rz3OVjIBC/0x8m+AOZp6j5Yp8XfRrL4X0YRE/6SYPG/BIK1w3CLLzXcQbD4OwwXMRvA7Q720VeGW3xWu3cabvFFugGfsLjy1GIdoY67wvQVy23AefJrC+aerwns7CZtYHdrOFh9Dez/Pb6I8pSfcLmHwOVeEpd7NXC5B8jlPl9EecpPuNxH4PIbEpffaOByH5DLb30R5Sk/4fJbApf7SVzuJ75iGZRyqPuJhPqCUNsDlr5i+S1JzhyMIiZ8kCBnDgIhO2S4nJEaHiLImUMWHJAOEQb/YQvkDKPd3xkuZ2ThAIozV2TULkIdj4SpnPkWOE8etWDuOUpg5xhpU3dMw2HjKLD/v/fljKf8hMvvCVz+QOLyBw1cfg/k8rgvZzzlJ1weJ3B5gsTlCQ1cHgdy+aMvZzzlJ1z+SODyJxKXP5HlDFLyiZw5QKjtSUvlzI8kOXMqipjwKYKcOQWE7LThckZqeJogZ05bcEA6TRj8ZyyQM4x2/2y4nJGFAyjOXJFRRwh1/CVM5cyPwHnyrAVzz1kCO+dIm7pzGg4bZ4H9f96XM57yEy7PE7i8QOLyggYuzwO5/NWXM57yEy5/JXD5G4nL3zRw+SuQy4u+nPGUn3B5kcDlJRKXl8hyBin5RM6cJNT2d0vlzEWSnPkjipjwHwQ58wcQssuGyxmp4WWCnLlswQHpMmHw/2mBnGG0+4rhckYWDqA4c0VG/UKo49WbtHgg5iZM3m7xG/KNJiYsN8eC5haXe2LulbiKRnMXD8g9o+EfJyseEW3+4sHYld9m+IehZMf8O6Hd2Sz5OFkAOLaRHycDcuNmM5xBmRsC0XgGI4FzTuiJWO4b59x4oU1NALhORAEZDyezLVxGEbiMJnEZrYHLKCCXMUAuw8lsC5cxBC5jSVzGauAyBshlCiCX4WS2hcsUBC5TkrhMGc3/OBnyvJcKyGVom9EfJ0sNzNPUfbBOi58CwFBSFj9NNDHhNNF4i58GCFZasoiJT951rYZpo/EWP63hIiYC3O5gH6UjtxuxUDDafQt40UBbfJFuwCcsrjy1uEoQWukNHzesVyxTAOfJWy2Ye24ljMEMpA1sBg0Hq1uB/Z/RF1Ge8hMuMxK4zETiMpMGLjMCuczsiyhP+QmXmQlcZiFxmUUDl5mBXGb1RZSn/ITLrAQubyNxeVs07xXLoJRD3U8kVGpCbbMBa6tTzmQlyZns0cSEsxPkTHYgZDkMlzNSwxwEOZPDggNSDsLgz2mBnGG0O5fhckYWDqA4c0VGpSfU8fYwlTNZgfPkHRbMPXcQ2IkjberiNBw27gD2f25fznjKT7jMTeAyD4nLPBq4zA3kMq8vZzzlJ1zmJXCZj8RlPg1c5gVyeacvZzzlJ1zeSeAyP4nL/GQ5g5R8ImeyEWp7l6Vy5k6SnCkQTUy4AEHOFABCVtBwOSM1LEiQMwUtOCAVJAz+QhbIGUa77zZczsjCARRnrsio2wl1vCdM5cydwHnyXgvmnnsJ7BQmbeoKazhs3Avs/yK+nPGUn3BZhMBlPInLeA1cFgFy6fpyxlN+wqVL4LIoicuiGrh0gVwm+HLGU37CZQKBy2IkLouR5QxS8omcuYtQ2+KWypkEkpwpEU1MuARBzpQAQlbScDkjNSxJkDMlLTgglSQM/lIWyBlGu0sbLmdk4QCKM1dk1D2EOpa5SYsHYm7C5O2WCM23bDQx4bLR8I+TlSgLhKwcefFA3LNcNPzjZCXKWbB4MHblBQz/MJTsmIsT2l3Qko+TlQeObeTHyYDcuAUNZ1DmhvIEBiuQTsQVNJia8sB14j7fbHvKT7i8j8Dl/SQu79fA5X1ALiv6ZttTfsJlRQKXlUhcVtLAZUUgl5V9s+0pP+GyMoHLKiQuq0TzP06GPO89ABYywQv9cbIHgXmaug/WafErkyx+1WhiwlUJFr8qEKxqhlt8qWE1gsWvZriIKQdud7CPqhtu8Vntfshwiy/SDfiExZWnFmUIdawRpq9YVgbOkzUtmHtqEth5mLSBfVjDwaomsP8f8UWUp/yEy0cIXD5K4vJRDVw+AuSyli+iPOUnXNYicFmbxGVtDVzWAnL5mC+iPOUnXD5G4LIOics6xFcsg1IOdT+RUA8SalvX0lcsHyPJmXrRxITrEeRMPSBk9Q2XM1LD+gQ5U9+CA1J9wuBvYIGcYbS7oeFyRhYOoDhzRUbVINTx8TCVM48B58knLJh7niCw04i0qWuk4bDxBLD/n/TljKf8hMsnCVw+ReLyKQ1cPgnksrEvZzzlJ1w2JnDZhMRlEw1cNgZy+bQvZzzlJ1w+TeCyKYnLpmQ5g5R8ImfqEmrbzFI58zRJzjSPJibcnCBnmgMha2G4nJEatiDImRYWHJBaEAZ/SwvkDKPdrQyXM7JwAMWZKzLqcUIdnwlTOfM0cJ5sbcHc05rAThvSpq6NhsNGa2D/t/XljKf8hMu2BC7bkbhsp4HLtkAun/XljKf8hMtnCVw+R+LyOQ1cPgvksr0vZzzlJ1y2J3DZgcRlB7KcQUo+kTPNCLV93lI5054kZ16IJib8AkHOvACErKPhckZq2JEgZzpacEDqSBj8nSyQM4x2v2i4nJGFAyjOXJFRzxDq2PkmLR6IuQmTt1syNN8u0cSEu0TDP05WsgsQsq7kxQNxz67R8I+TlexqweLB2JWXMvzDULJjfp7Q7tKWfJysG3BsIz9OBuTGLW04gzI3dCMw2J10Iu6uwdR0A64TPXyz7Sk/4bIHgcueJC57auCyB5DLXr7Z9pSfcNmLwGVvEpe9NXDZC8hlH99se8pPuOxD4LIvicu+0fyPkyHPey+BhUzwQn+crB8wT1P3wTotfh+Sxe8fTUy4P8Hi9weCNcBwiy81HECw+AMMFzFdwe0O9tHLhlt8VrtfMdzii3QDPmFx5alFZ0IdB4bpK5Z9gPPkIAvmnkEEdgaTNrCDNRysBgH7f4gvojzlJ1wOIXA5lMTlUA1cDgFyOcwXUZ7yEy6HEbgcTuJyuAYuhwG5fNUXUZ7yEy5fJXA5gsTlCOIrlkEph7qfSKh+hNqOtPQVy1dJcmZUNDHhUQQ5MwoI2WjD5YzUcDRBzoy24IA0mjD4x1ggZxjtHmu4nJGFAyjOXJFRAwl1fC1M5cyrwHnydQvmntcJ7IwjberGaThsvA7s//G+nPGUn3A5nsDlBBKXEzRwOR7I5URfznjKT7icSOByEonLSRq4nAjk8g1fznjKT7h8g8DlZBKXk8lyBin5RM6MJNR2iqVy5g2SnJkaTUx4KkHOTAVCNs1wOSM1nEaQM9MsOCBNIwz+6RbIGUa73zRczsjCARRnrsio1wh1fCtM5cwbwHlyhgVzzwwCOzNJm7qZGg4bM4D9P8uXM57yEy5nEbicTeJytgYuZwG5nOPLGU/5CZdzCFzOJXE5VwOXc4BczvPljKf8hMt5BC7nk7icT5YzSMkncmYKobZvWypn5pHkzDvRxITfIciZd4CQLTBczkgNFxDkzAILDkgLCIN/oQVyhtHudw2XM7JwAMWZKzLqLUIdF92kxQMxN2HydkuF5rs4mpjw4mj4x8lKLQZCtoS8eCDuuSQa/nGyUkssWDwYu/Jqhn8YSnbMbxPaXd2Sj5MtBY5t5MfJgNy41Q1nUOaGpQQGl5FOxMs0mJqlwHXiPd9se8pPuHyPwOX7JC7f18Dle0Aul/tm21N+wuVyApcrSFyu0MDlciCXK32z7Sk/4XIlgctVJC5XRfM/ToY8730AFjLBC/1xsg+BeZq6D9Zp8VeSLP5H0cSEPyJY/I+AYK023OJLDVcTLP5qw0XMEnC7g330seEWn9XuTwy3+CLdgE9YXHlqsYhQxzVh+orlSuA8udaCuWctgZ1PSRvYTzUcrNYC+3+dL6I85SdcriNwuZ7E5XoNXK4DcrnBF1Ge8hMuNxC43EjicqMGLjcAufzMF1Ge8hMuPyNwuYnE5SbiK5ZBKYe6n0ioDwm13WzpK5afkeTMlmhiwlsIcmYLELKthssZqeFWgpzZasEBaSth8G+zQM4w2r3dcDkjCwdQnLkio9YQ6vh5mMqZz4Dz5BcWzD1fENj5krSp+1LDYeMLYP/v8OWMp/yEyx0ELr8icfmVBi53ALnc6csZT/kJlzsJXO4icblLA5c7gVx+7csZT/kJl18TuNxN4nI3Wc4gJZ/Imc2E2u6xVM58TZIze6OJCe8lyJm9QMj2GS5npIb7CHJmnwUHpH2Ewf+NBXKG0e5vDZczsnAAxZkrMupzQh33h6mc+Ro4Tx6wYO45QGDnIGlTd1DDYeMAsP8P+XLGU37C5SECl4dJXB7WwOUhIJff+XLGU37C5XcELo+QuDyigcvvgFwe9eWMp/yEy6MELo+RuDxGljNIySdyZg+htt9bKmeOkuTMD9HEhH8gyJkfgJAdN1zOSA2PE+TMcQsOSMcJg/+EBXKG0e4fDZczsnAAxZkrMmo/oY4/3aTFAzE3YfJ2S4fmezKamPDJaPjHyUqfBEJ2irx4IO55Khr+cbLSpyxYPBi78oaGfxhKdszfE9r9uCUfJzsNHNvIj5MBuXEfN5xBmRtOExg8QzoRn9Fgak4D14mffbPtKT/h8mcCl7+QuPxFA5c/A7k865ttT/kJl2cJXJ4jcXlOA5dngVye9822p/yEy/MELi+QuLwQzf84GfK89ytYyAQv9MfJfgPmaeo+WKfFP0+y+BejiQlfJFj8i0CwLhlu8aWGlwgW/5LhIuYUuN3BPvrdcIvPavcfhlt8kW7AJyyuPLX4iVDHy2H6iuV54Dz5pwVzz58Edq6QNrBXNBys/gT2/1VfRHnKT7i8SuDSieFwKfeNc7hcXgVyGYGrQ9iJKKkdmssAicuABi5DWUpuHSKBXIabiIokcBlF4jIqhveKZVDKoe4nEuo3wloUDaytTjkTCRjvScmZmBhiwnJztJyJAU5WscBJlFXD2Bi8nImNMX9ijSVMrCnI7UbIGUa7UwLHjNyDcfgHijNXZNRlwuKRyvBxw5IzkcB5MrUFc09qwhhMQ9rUpdFw2EgN7P+0wLko3ORMWgKX6UhcptPAZVogl7f4csZTfsLlLQQu05O4TK+By1uAXN7qyxlP+QmXtxK4zEDiMgNZziAln8iZaEJtM1oqZ24lyZlMMcSEMxHkTCYgZJkNlzNSw8wEOZPZggNSZsLgz2KBnGG0O6vhckYWDqA4c0VGpSLU8bYwlTO3AufJbBbMPdkI7GQnbeqyazhsZAP2fw5fznjKT7jMQeAyJ4nLnBq4zAHkMpcvZzzlJ1zmInB5O4nL2zVwmQvI5R2+nPGUn3B5B4HLOBKXcWQ5g5R8ImcyEmqb21I5cwdJzuSJISachyBn8gAhy2u4nJEa5iXImbwWHJDyEgZ/PgvkDKPddxouZ2ThAIozV2TUbYQ65r9JiwdibsLk7TYNzfeuGGLCd8XAP07W9C4gZAXIiwfingVi4B8na1rAgsWDsStvbfiHoWTHnJvQ7jaWfJysIHBsIz9OBuTGbWM4gzI3FCQwWIh0Ii6kwdQUBK4Td/tm21N+wuXdBC7vIXF5jwYu7wZyea9vtj3lJ1zeS+CyMInLwhq4vBfIZRHfbHvKT7gsQuAynsRlfAz/42TI854LFjLBC/1xsqLAPE3dB+u0+EVIFj8hhphwAsHiJwDBKma4xZcaFiNY/GKGi5gC4HYH+6i44Raf1e4Shlt8kW7AJyyuPLXIT6hjyTB9xbIIcJ4sZcHcU4rATmnSBra0hoNVKWD/l/FFlKf8hMsyBC7Lkrgsq4HLMkAuy/kiylN+wmU5ApflSVyW18BlOSCXFXwR5Sk/4bICgcv7SFzeR3zFMijlUPcTCVWUUNv7LX3FsgJJzlSMISZckSBnKgIhq2S4nJEaViLImUoWHJAqEQZ/ZQvkDKPdVQyXM7JwAMWZKzKqJKGOD4SpnKkAnCcftGDueZDATlXSpq6qhsPGg8D+r+bLGU/5CZfVCFxWJ3FZXQOX1YBcPuTLGU/5CZcPEbisQeKyhgYuHwJyWdOXM57yEy5rErh8mMTlw2Q5g5R8194QItT2EUvlTE2SnHk0hpjwowQ58ygQslqGyxmpYS2CnKllwQGpFmHw17ZAzjDa/ZjhckYWDqA4c0VGPUCoY50wlTM1gfNkXQvmnroEduqRNnX1NBw26gL7v74vZzzlJ1zWJ3DZgMRlAw1c1gdy2dCXM57yEy4bErh8nMTl4xq4bAjk8glfznjKT7h8gsBlIxKXjchyBin5RM48Qqjtk5bKmSdIcuapGGLCTxHkzFNAyBobLmekho0JcqaxBQekxoTB38QCOcNo99OGyxlZOIDizBUZVYdQx6Y3afFAzE2YvN1mofk2iyEm3CwG/nGyZs2AkDUnLx6IezaPgX+crFlzCxYPxq68m+EfhpId85OEdne35ONkLYBjG/lxMiA3bnfDGZS5oQWBwZakE3FLDaamBXCdaOWbbU/5CZetCFw+Q+LyGQ1ctgJy2do3257yEy5bE7hsQ+KyjQYuWwO5bOubbU/5CZdtCVy2I3HZLob/cTLkee9ZsJAJXuiPkz0HzNPUfbBOi9+WZPHbxxATbk+w+O2BYHUw3OJLDTsQLH4Hw0VMc3C7g330vOEWn9XuFwy3+CLdgE9YXHlq0ZRQx45h+oplW+A82cmCuacTgZ0XSRvYFzUcrDoB+7+zL6I85SdcdiZw2YXEZRcNXHYGctnVF1Ge8hMuuzIempG47KaBy65ALrv7IspTfsJldwKXPUhc9iC+YhmUcqj7iYR6jlDbnpa+YtmdJGd6xRAT7kWQM72AkPU2XM5IDXsT5ExvCw5IvQmDv48FcobR7r6GyxlZOIDizBUZ1ZFQx5fCVM50B86T/SyYe/oR2OlP2tT113DY6Afs/wG+nPGUn3A5gMDlyyQuX9bA5QAgl6/4csZTfsLlKwQuB5K4HKiBy1eAXA7y5Yyn/ITLQQQuB5O4HEyWM0jJJ3KmJ6G2QyyVM4NIcmZoDDHhoQQ5MxQI2TDD5YzUcBhBzgyz4IA0jDD4h1sgZxjtftVwOSMLB1CcuSKjXiLUcUSYyplBwHlypAVzz0gCO6NIm7pRGg4bI4H9P9qXM57yEy5HE7gcQ+JyjAYuRwO5HOvLGU/5CZdjCVy+RuLyNQ1cjgVy+bovZzzlJ1y+TuByHInLcWQ5g5R8ImeGEGo73lI58zpJzkyIISY8gSBnJgAhm2i4nJEaTiTImYkWHJAmEgb/JAvkDKPdbxguZ2ThAIozV2TUCEIdJ9+kxQMxN2HydpuH5jslhpjwlBj4x8maTwFCNpW8eCDuOTUG/nGy5lMtWDwYu/LBhn8YSnbM4xmPMy35ONk04NhGfpwMyI07xHAGZW6YRmBwOulEPF2DqZkGXCfe9M22p/yEyzcJXL5F4vItDVy+CeRyhm+2PeUnXM4gcDmTxOVMDVzOAHI5yzfbnvITLmcRuJxN4nJ2DP/jZMjz3hywkAle6I+TzQXmaeo+WKfFn0Wy+PNiiAnPI1j8eUCw5htu8aWG8wkWf77hImYquN3BPnrbcIvPavc7hlt8kW7AJyyuPLWYTKjjgjB9xXIWcJ5caMHcs5DAzrukDey7Gg5WC4H9v8gXUZ7yEy4XEbhcTOJysQYuFwG5XOKLKE/5CZdLCFwuJXG5VAOXS4BcLvNFlKf8hMtlBC7fI3H5HvEVy6CUQ91PJNRcQm3ft/QVy2UkObM8hpjwcoKcWQ6EbIXhckZquIIgZ1ZYcEBaQRj8Ky2QM4x2rzJczsjCARRnrsioBYQ6fhCmcmYZcJ780IK550MCOx+RNnUfaThsfAjs/9W+nPGUn3C5msDlxyQuP9bA5Wogl5/4csZTfsLlJwQu15C4XKOBy0+AXK715Yyn/ITLtQQuPyVx+SlZziAln8iZ9wm1XWepnFlLkjPrY4gJryfImfVAyDYYLmekhhsIcmaDBQekDYTBv9ECOcNo92eGyxlZOIDizBUZ9QGhjpvCVM6sBc6Tmy2YezYT2NlC2tRt0XDY2Azs/62+nPGUn3C5lcDlNhKX2zRwuRXI5XZfznjKT7jcTuDycxKXn2vgcjuQyy98OeMpP+HyCwKXX5K4/JIsZ5CST+TMOkJtd1gqZ74gyZmvYogJf0WQM18BIdtpuJyRGu4kyJmdFhyQdhIG/y4L5Ayj3V8bLmdk4QCKM1dk1CZCHXffpMUDMTdh8nZbhOa7J4aY8J4Y+MfJWuwBQraXvHgg7rk3Bv5xshZ7LVg8GLvyCYZ/GEp2zDsI7Z5oycfJ9gHHNvLjZEBu3ImGMyhzwz4Cg9+QTsTfaDA1+4DrxLe+2faUn3D5LYHL/SQu92vg8lsglwd8s+0pP+HyAIHLgyQuD2rg8gCQy0O+2faUn3B5iMDlYRKXh2P4HydDnve+AwuZ4IX+ONkRYJ6m7oN1WvxDJIt/NIaY8FGCxT8KBOuY4RZfaniMYPGPGS5i9oLbHeyj7w23+Kx2/2C4xRfpBnzC4spTi92EOh4P01csDwHnyRMWzD0nCOz8SNrA/qjhYHUC2P8/+SLKU37C5U8ELk+SuDypgcufgFye8kWUp/yEy1MELk+TuDytgctTQC7P+CLKU37C5RkClz+TuPyZ+IplUMqh7icS6gihtr9Y+orlGZKcORtDTPgsQc6cBUJ2znA5IzU8R5Az5yw4IJ0jDP7zFsgZRrsvGC5nZOEAijNXZNRxQh1/NXzc1HGS/j/5mdx2/xamUuoMcH24aMGce5HAziXSZvaShkPWRWD//+5LKU/5CZe/E7j8g8TlHxq4/B3I5WVfSnnKT7i8TODyTxKXf2rg8jKQyyu+lPKUn3B5hcDlVRKXV8lSCik3RUr9QqitA5zrdEqpKyQpFRFLTFhujpZSEcAJJhBrtpSSGkqOaCkVsGDBR7Y72EeR5HYjpBSj3VHAMSP3YBz+gcLQFQn3K2HxiAbzE7wYHCHzZGwWroA3Cw5h3MSQ+jsGXE+gWDD1YEk7WCSXkWGpOYxEgxm5AjwwxgL7AvlPbJGyLrRfk7vf0nlQAPZNfGi+KWKJCaeIxd83peGbe2l3ytj/FRh0X1s/KNIyNN9UscSEU8XCPyjSMhVw5klNBhdxz9TwAeu2TG34qVR2mTGx+H9QmMbM1ZRSQ+njNISdelrwqhdUpnLfOOfGC63y0wDHezpDd1OmP/oULtMRuLyFxOUtGrhMB+Qy/b//hErjMj2By1tJXN6qgcv0QC4zWGAo4pN5sbjMQOAyI4nLjLH8D0Mg9+2ZwMaetRdG939mSx/PZgD0fVKPZ7PEEhPOQng8mwUIblbDDY7UMCvh8WxWCzYlWQmD/zbDH8+y2p3N8Mez8ugA+OjclcfR0YQ6Zgfzg65jVec/X+JF3U8W4d8Ij7lzGD7/sP4NQgbgepPTgjk8J2EM5iJt4HNpOFjmBPb/7b6I85SfcHk7gcs7SFzeoYHL24FcxvkizlN+wmUcgcvcJC5za+AyDshlHl/EecpPuMxD4DIvicu8sbx/gxCUkqj7iYTLTKhtPkslVx6S5LozlpjwnQTJdScQsvyGSy6pYX6C5MpvwYKfnzD477JAcjHaXcBwySULB1BAuiL1shPqWBDMT/BicITMk7FZyAPeLOQj9HchUn+j3y/PA1zH7jbzjTj//fLEvIF9c8P75ffEEhO+JxZ/33sN37hJu++N/V+BQfel5CqTZyHC5Fk4DCfPIrg2FwVOnkWBk2dRWyfPIqTJMz6WmHA8YfJ0DZ88pd0uYfK09B/ntArNt2gsMeGisfB/nNOqKHDblkAGF3HPBPiAdVslGH6ckxUUqFZc0RUFCTuSYqQdSQCcJ5Lz4oarn7LOf/5BG+p+spvNQWCnhOHKVNpdOBbPYkkzdQClhjLuShLYKUV6nldKw3PmksC5qLT/Xo6n/ITL0gQuy5C4LKOBy9JALsv67+V4yk+4LEvgshyJy3IauCwL5LK8/16Op/yEy/IELiuQuKwQwiVrX4iuxX2WvkdTnvQezf2xzIQJ79HcD5wQKhpuFKWGFQnv0VS0YIGuSBj8lQx/j4bV7spgmRK8GO1H9g9a+gQXaNT9RHLdR+jvKpY8wiwPnH8f8N//MPYR5gPgDWjwejCWmPCDhEeYVQ3fcEi7q8b+r8Cg+1JylcmzCmHyrBaGk2d1//0PYyfP6qTJ86FYYsIPESbPGoZPntLuGhZNntUIk2fNMJw8H8a1OQE4eSYAJ88EWyfPh0mT5yOxxIQfIUyejxo+eUq7HyVNngwNAHwn59pkXELTi4OMhaRmErknZ5JIvIqF5lyLNdiCyaNXwdqxuEIw2i0FrQ3stP/+3wz6Sz85RPCA97phZn+MBVvw5uj71jF8Zpd71CHN7P8EV3LrUAcszOH5Xa9pJJol3L0SkFzWNfyBlbS1Ln4VvPZ/3yLa+d/xJ/j/TnH9v8eE/PfYkP+eIuS/p7z+3+sl/g/UT/w1SPw1TPw9nvh7IvHXKPH3ZOLvqcRf48Rfk8Tf04m/pom/Zom/5om/Fom/lom/Vom/ZxJ/rRN/bRJ/bRN/7RJ/zyb+nkv8tU/8dUj8PZ/4eyHx1zHx1ynx92Ls//JH170eYQFP5WB3YZJf4H94UOpQ1fk7f/Eer//g16qFk8SVzHu7wf8SWo/O1/noEnu9OMFXTDpf79zQv3UhvnYiRayDe2uh6HWg3M7AybBLLKeDUW9qBPNEtrkreUGOT971X27QE1G3WL0TEaKfusVy/rlFcnMMLqqdY3GTmJPEhbp3aD91vz5B9vjrBNk9iQmyh2KCRHUw/P1TUgcnd+LuDpzEeoDBQ09ipMGbgFwIepInxEjweOl8vaaoPhIeywLzk/v1jMW+piljELlg97Rwwu51fcLu/dcJu1cSE3Zv4o5WYOlO2JlsSsk9kqPARt93i+HtDk44MaD7sgd0chfoXsDFpTewjcDx4QKYS3ICRJ/4kH3RB3ziC17ojWtPYJv7/nv5++8l90CvcZ1JG9euwL59ibxxRXMt/1YC+a57ZfBDc9ZGGL0el3U4c7eD6e8kN6/9rm9e+/9189ovic1rf+LmVYCpTOiU7YZPaDLwKhHa/Tm43cErFpwnYGD/d4PYDziJ9//3L9AucGy4n1uycUUyMoC0cUWbqZdj/7XM/PcKrZ+JxjrYF68A+QudV0ySHf+XTSviAPoS+BCKPJTJPIMcdzLXvBL7v3om877aN5oDr+c+6K8bzYFJbDQHER9rBcFB33eH4bYwCDj6vl8ZvsEODkR0u3ca3u7ghIFu9y7Sog2y2P89DAwELg6DgBM5cJ5wgWPPBfLs7rLkMIBkZLAlh4Ehsf9aZv57Mes3NJazZzBpHda1ge8L3sADzfu19QM5VmR+GGrxBn7Y9dyH/3UDPyyJDfxw8gaesZHdbcEGnnFw2WP4RjY4ENHt3mt4u4MTBrrd+yzZwA8DLg7DgRM5cJ5wgWPPBfLs7rNkA49k5FVLNvAjYv+1zPz3YtZvZCxnz2DaOgx+ReaaSHsFbLRfxm2I/3tp/KfpzYH/eviGf5o+KpaY8KhY/GZlNHBQsdo9mgCbE3KhFzdkTceAFzdw/xSV/mH8q7qxsdi+Ro8b6Zex+PGYgGDn+vvgrZJiOz5517VD3VCwXWEcEl+LtXJhcl8jLUyvxxITfp2wMI0ze2G61u5xpIUJPWjltDUSOGjlxDWCMGjHWzpox5MG7YRYYsITCIN2ouGDVto90bLdJLKmk8i7yeTuWEZfn1TBH00qOhrX7gTkwvRGrPkLxwjwwjGSsHBMtnThmExaOKbEEhOeQlg4phq+cEi7p1q2cCBrOs1sDeHKwiaTKXgCLIZcfKcbrjSkj6fjx3bxqeBJLjhBp3L+dwVfeom8Hpcv8MlzTRmy8mU9+cJeXMj/XurEX5rEX9rEX7rE3y2Jv/SJv1sTfxkSfxkTf5kSf5kTf1kSf1kTf7cl/rIl/rIn/nIk/nIm/nIl/m5P/N1x/f65E395En95E3/5En93Jv7yJ/7uSvwVSPwVDMn5WMiMHZwIMh+tmO2FzXMeCPkfcx5UxKorYg0UsccVsacUsXaK2HOK2POKWCdFbJAiNlQRe1URG6WITVLEpihi0xWxGYrYQkVssSK2VBFbroitU8Q2KmKbFLEtitgBRew7ReyYInZCETuniP2qiF1SxC4rYiki/jmWWhFLp4ilV8RyKmJ3KGJ5FLF8ilhJRayMIlZBEaukiD2siNVSxOooYvUVsWaKWEtFrLUi1k4R66qI9VDEeitiLylioxSxsYrYOEVskiI2SxGbq4i9rYgtVMRWKGIfKGKrFbE1itgWRWy7IvalIrZTETuiiH2viJ1QxE4qYr8pYr8rYn8qYsFNeVKxVIpYWkUsvSKWURHLpYjFKWJ5FbH8ilhxRayUIlZWEaugiFVXxGoqYo8qYo8pYk8qYk0UsWaKWEtFrIMi1lER66yIdVPEBiliQxWxVxWxUYrYG4rYVEXsTUVspiK2UBFbrIgtU8SWK2JrFLF1ithGRWyzIrZXEftWETuoiH2niJ1SxH5WxM4pYr8qYkFTnlQsUhGLUcRSKmIZFbEsilg2RSynIna3IlZYEXMVsWKK2H2KWCVF7AFFrJoi9pgiVk8Ra6iINVLEWipirRWxdopYe0WstyL2kiI2QBEbqIiNVsReU8TGK2KTFLGZitgcRWy+IrZAEVuuiK1SxD5SxD5RxD5XxHYoYrsUsT2K2BFF7HtF7IQidlIR+1URu6SIXVbErqrm1qh/jqVRxG5RxDIoYrkVsXyK2F2KWCFFrLgiVkoRK6uIVVDEqiliNRSxRxSx2opYI0WssSLWVBFroYh1UsS6KGLdFbFeitggRWyoIvaqIjZKEZukiE1RxKYrYjMUsQWK2CJFbKki9r4itl4R+0wR26KIbVfE9ipi3ypiBxWx7xSxk4rYGUXsrCJ2QRG7qogFov85Fq2IpVDEsipi2RWxXIpYnCJ2tyJWWBFzFbFiilgFRayiIlZFEauqiNVWxOoqYg0UsScUsTaK2LOKWAdFrKMi1lsRe0kRG6CIDVTERiliYxWxcYrYREVshiI2WxGbp4i9o4h9oIitVsTWKGLrFLHPFbEditguRWyPIvadInZMETuuiP2kiF1QxC4qYn8oYlcUsbQx/xxLr4hlVMSyKGK5FbF8ithdilghRayYIlZSESujiJVXxKoqYg8pYg8rYrUUsSaKWDNFrKUi1loR66SIdVHEuitivRSxgYrYEEVsuCI2UhGbqIhNVsSmKWJvKWKLFbFlithyRWyVIrZeEftMEduiiG1XxPYoYt8oYgcUscOK2E+K2GlF7BdF7LwiFhn7z7EYRSylIpZGEcuqiGVXxHIpYnGKWCFF7F5FLF4RS1DEyiti9ytilRWxBxWxeopYQ0WskSLWWBFro4g9q4h1UMQ6KmK9FLG+ilh/RewVRWykIjZGEXtdEZugiM1RxOYrYgsUsUWK2AeK2GpFbI0itk4R266IfamI7VTEditihxWxo4rYD4rYj4rYJUXssiJ2VRELpPjnWFpFLL0illERy6KIxSlieRWx/IpYQUUsQREroYiVVsTKKWI1FLFHFLHailhdRayJItZMEWupiLVWxDoqYp0VsW6KWE9F7BVFbLAiNkwRG6GITVHEpitiMxSx2YrYYkVsmSK2XBFbpYitU8Q2KmKbFbFtithuRWyfIrZfETukiJ1RxM4qYhcUsYuKWGTKf47FKGIpFbE0ilgWRSybIpZTEbtDESuoiN2jiBVRxIoqYhUVsSqKWFVF7CFFrJ4i1lARa6SINVbEWiti7RSx9orYC4pYT0WsjyLWTxF7WREbq4iNU8QmKmKTFbE5ith8RWyBIrZIEftAEVutiK1RxNYpYluvxwJO+nRPrGu3PjS2R/G/940idkARO6yInVLEflbEzilivypiVxRtvzXVP//vZVLEsipi2RWx3KmSziX47/dS/uU/M1//z+C3au+//v+OT97lBu+fiXP/+Fjn71fmkP+e6S/tDITE7gflELxf8B/VRzt/vwJ/iQX/Z1P8Jb8IfH7uX3OJTOL/r+CV8fp/Zgr5W+Z/yDVVyH2AfRpcbq/9G0LC/ZNkJvTfOqb+SyzYd1FJ/O9F/MP/O/CX/1T9z6r+IXzaJGLBewb7KjTfYDv+H46+Z6KdBgoA", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 795ccc6f220..b385d56ee82 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -80,8 +80,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZnNbhs5EITfRWcf+Nf8yasEQaA4ciBAkA3FXmBh+N23a9jFiQ8LBK2L65OsriGb3Rxq9H74efrx9uv7+fr0/Pvw5ev74cftfLmcf32/PD8eX8/PV333/RDwJ8Z4+BIfVJNpNi2mYlpNm2k3HVNTMDW/ZH7J/JL5JfNL5pfML5lfMr9sflk/l6D6flYt+n6BRlO9jkCzaTEV02qq16nQbjqmSjCNpsk0m6pfg4ppNW2m3XRMrcE0mibTbGp+1fyq+VXzq+rXoWNqC6bRNJlm02KqfgNaTZHXAOiEYdADAWuFJHcsDrLchVAJjdAJw2AEAnywOAOLjlUZmVAIQqiERugEOOtipRAIcK4AODdAJhSCEODcAY3QCcMgwnkAIiERMqEQhFAJjaDOKQDUOWkOExpggjqnBEiETCgEIVQCDDNgGKADJkRCImQCDAsAhsjY1i8bNEInDAP00IRISASOEP2TkHk00AQYIs9ooQnDAE00AYbIM9poQibAB6lD50xASyOH6JkJkZAImVAIQqgENczIPHpnwjBA12zXQttkzAt9MwGGyCE6Z0IlNEInDAP0zoRISIRMoHOnc6czuiljvdBNE4YBumlCJCRCJhQCnLFe6KYJcMYyoZsmjAkZ3TQBzg2QCJkAnw5oBIRr6jJaZkIkJEImFIIQKqEZoEFKAESChpcI0KiSABpVMqARdDpFp5zRBUUAmaAXLZgXin9CJTQCwjFBFP8G2w0EE8Qdo2Bg2y0C40GFC8aDCp8wDFDhE5JFobAFY8YdYoIQYIjBo8I3Z1T4hETAhzEvbPCC6WwFCW18A6PAJFB9G6D6JkRCImRCIeAKmDGqb0IjdAKckQxU34RISIRMKAQhwBnJQPVN6IQxoaD6JkRCImSC+tQAwF1Z01xQdDUBMqEQZMtT2SoM2ky76TwpFNTbptE0mRbTZhdFiU3A1fEvbL0TIiHZwFB9EwpBCJXQDLZDRwF0wjDYzhkCQHgFNAMUS20AIcC5AxqhE4YB6mhCJOASSC/2vAmFgNMHpow9b7soamx7BzXWMHjU2IREwBkGS4AamyAEHGOQKNTYhE4YBqixCZGQCNmGgRqbwLQMjnAwP6ixCWOCoMYmyEyvbBW1QSNsS/Dx8XDgKfj76+10wiH4j2OxHpZfjrfT9fXw5fp2uTwc/jle3rYP/X45Xjd9Pd70v5qq0/Wnqho+nS8n0MfDHh3+P7SEZsFayytc/j4evTfja3DEt8zBt1wc8T0wvod+X3zMnvjE/PXsyd/ALXSLH754nAAtvnnihfMfUu6MH574tuJbdcTHgDvzZhCDdJdDk+XgHEPtu0NyOYx9FqPd6RBD9DhoKpdDDPeOwenQ654Hl0NMY40hD5eDrDHoN+W7HTw1OXpbaQi+glr7QgzJtxT4Om0O0dUW+jV9pWGkux1cbZHiyqR+T/Y45LXDK7ockuxjaL5ZjLjGEFyrmWWtZq6u7SGXdq9D28fQXK2pXwSWw6h3OhTfNlnyqsni22BqXBttdR269EHiumXpodvjIHt3i+vgow8jVx6k+PKQ1xhqdnVWlT2TcreDb7OvbeWh+qq6juXQgucQpg9eV2+24spDk30Mvjy0vvao1l27fU9rLXp2dXff+6I3V3e3sW7d3bfTfnLwdLesc5hETzVI4UJI8ayDNBaT9OqKlxXvudtJZQLFtYZS1/xdh/G6jgzVdWKoheP37Ul18PotePJXJd51/bRu0/rM2ZP/tfy+Hl5b2fCsfhvreYDr4L2fml2H5v2r5Ljv8r7zUd0PN7674bqV+U4V+63wc/q+6avj4/n26VffDzjdzscfl5O9fHq7Pv7x39d/X/gf/mr8cnt+PP18u53gtP90rH++iv6OKDl+0we++mqEB/3upC/w9PZr0Wf8pQheRnxUz3BSwrcPjOw/", + "bytecode": "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", + "debug_symbols": "pZnNbhs5EITfRWcf+Nf8yasEQaA4ciBAkA3FXmBh+N2XNd3FiQ8LBK2L65OlriGb3Rxq9H74efrx9uv7+fr0/Pvw5ev74cftfLmcf32/PD8eX8/P1/nf90PAnxjj4Ut8mJpMs2kxFdNq2ky76VBNwdT8kvkl80vml8wvmV8yv2R+yfyy+eX5uQSd/89Ty/x/gUbTeR2BZtNiKqbVdF6nQrvpUJVgGk2TaTadfg0qptW0mXbToVqDaTRNptnU/Kr5VfOr5lenX4cO1RZMo2kyzabFdPoNaDVFXgOgE4ZBDwSsFZLcsTjIchdCJTRCJwyDEQjwweIMLDpWZWRCIQihEhqhE+A8FyuFQIBzBcC5ATKhEIQA5w5ohE4YBhHOAxAJiZAJhSCESmiE6ZwCYDqnmcOEBlCYzikBEiETCkEIlQDDDBgG6ACFSEiETIBhAcAQGdv6ZYNG6IRhgB5SiIRE4AjRPwmZRwMpwBB5RgspDAM0kQIMkWe0kUImwAepQ+cooKWRQ/SMQiQkQiYUghAqYRpmZB69ozAM0DXbtdA2GfNC3yjAEDlE5yhUQiN0wjBA7yhEQiJkAp07nTud0U0Z64VuUhgG6CaFSEiETCgEOGO90E0KcMYyoZsUhkJGNynAuQESIRPg0wGNgPCZuoyWUYiERMiEQhBCJTQDNEgJgEiY4SUCZlRJgBlVMqAR5nTKnHJGFxQBZMK8aMG8UPwKldAICMcEUfwbbDcQTBB3jIKBbbcIjAcVLhgPKlxhGKDCFZJFobAFY8YdQkEIMMTgUeGbMypcIRHwYcwLG7xgOltBQjEKjB3VpzAMUH0KkQA/TAvVp1AIQqiERugEOCMZqD6FSEiETCgEIcAZyUD1KXTCUCioPoVISIRMmD41AHBXnmkuKLqaAJlQCLLlqWwVBm2m3VRPCgX1tmk0TabFtNlFUWIKuDrewtarEAnJBobqUygEIVRCM9gOHQXQCcNgO2cIAOEV0AxQLLUBhADnDmiEThgGqCOFSMAlkF7seQqFgNMHpow9b7soamz7D2qsYfCoMYVEwBkGS4AaUxACjjFIFGpMoROGAWpMIRISIdswUGMKTMvgCAfzgxpTGAqCGlMQTa9sFbVBI2xL8PHxcOAp+Pvr7XTCIfiPY/E8LL8cb6fr6+HL9e1yeTj8c7y8bR/6/XK8bvp6vM13Z6pO159Tp+HT+XICfTzs0eH/Q0toFjxreYXL38ej9zS+Bkd8yxx8y8UR3wPje+j3xcfsiU/MX8+e/A3cQrf44YvHCdDimydeOP8h5c744YlvK75VR3wMuDNvBjFIdzk0WQ7OMdS+OySXw9hnMdqdDjFEj8NM5XKI4d4xOB163fPgcohprDHk4XKQNYb5TfluB09Njt5WGoKvoNa+EEPyLQW+TptDdLXF/Jq+0jDS3Q6utkhxZXJ+T/Y45LXDT3Q5JNnH0HyzGHGNIbhWM8tazVxd20Mu7V6Hto+huVpzfhFYDqPe6VB822TJqyaLb4OpcW201XXomg8S1y1rHro9DrJ3t7gOPvNh5MqDFF8e8hpDza7OqrJnUu528G32ta08VF9V17EcWvAcwuaD19Wbrbjy0GQfgy8Pra89qnXXbt/TWoueXd3d977ozdXdbaxbd/fttJ8cPN0t6xwm0VMNUrgQUjzrIJUTEFcOpbEYpVdXvKz45hr/mr/rMF7XkaG6Tgy1MH++PakOXr8Fz/yrxLuun9Ztej5z9uR/LZ+vh9dWNjzV18Z6HuA6eO+nZtehef8qOe67vO98VPfDje9uuG5lvlPFfiv8nL5v89Xx8Xz79KvvB5xu5+OPy8lePr1dH/949/XfF77DX41fbs+Pp59vtxOc9p+O55+vMn9HlBy/zQe+89UID/O703yBp7dfy3zGX4rgZcRH5xlOSvj2gZH9Bw==", "file_map": { "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap index 795ccc6f220..b385d56ee82 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap @@ -80,8 +80,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZnNbhs5EITfRWcf+Nf8yasEQaA4ciBAkA3FXmBh+N23a9jFiQ8LBK2L65OsriGb3Rxq9H74efrx9uv7+fr0/Pvw5ev74cftfLmcf32/PD8eX8/PV333/RDwJ8Z4+BIfVJNpNi2mYlpNm2k3HVNTMDW/ZH7J/JL5JfNL5pfML5lfMr9sflk/l6D6flYt+n6BRlO9jkCzaTEV02qq16nQbjqmSjCNpsk0m6pfg4ppNW2m3XRMrcE0mibTbGp+1fyq+VXzq+rXoWNqC6bRNJlm02KqfgNaTZHXAOiEYdADAWuFJHcsDrLchVAJjdAJw2AEAnywOAOLjlUZmVAIQqiERugEOOtipRAIcK4AODdAJhSCEODcAY3QCcMgwnkAIiERMqEQhFAJjaDOKQDUOWkOExpggjqnBEiETCgEIVQCDDNgGKADJkRCImQCDAsAhsjY1i8bNEInDAP00IRISASOEP2TkHk00AQYIs9ooQnDAE00AYbIM9poQibAB6lD50xASyOH6JkJkZAImVAIQqgENczIPHpnwjBA12zXQttkzAt9MwGGyCE6Z0IlNEInDAP0zoRISIRMoHOnc6czuiljvdBNE4YBumlCJCRCJhQCnLFe6KYJcMYyoZsmjAkZ3TQBzg2QCJkAnw5oBIRr6jJaZkIkJEImFIIQKqEZoEFKAESChpcI0KiSABpVMqARdDpFp5zRBUUAmaAXLZgXin9CJTQCwjFBFP8G2w0EE8Qdo2Bg2y0C40GFC8aDCp8wDFDhE5JFobAFY8YdYoIQYIjBo8I3Z1T4hETAhzEvbPCC6WwFCW18A6PAJFB9G6D6JkRCImRCIeAKmDGqb0IjdAKckQxU34RISIRMKAQhwBnJQPVN6IQxoaD6JkRCImSC+tQAwF1Z01xQdDUBMqEQZMtT2SoM2ky76TwpFNTbptE0mRbTZhdFiU3A1fEvbL0TIiHZwFB9EwpBCJXQDLZDRwF0wjDYzhkCQHgFNAMUS20AIcC5AxqhE4YB6mhCJOASSC/2vAmFgNMHpow9b7soamx7BzXWMHjU2IREwBkGS4AamyAEHGOQKNTYhE4YBqixCZGQCNmGgRqbwLQMjnAwP6ixCWOCoMYmyEyvbBW1QSNsS/Dx8XDgKfj76+10wiH4j2OxHpZfjrfT9fXw5fp2uTwc/jle3rYP/X45Xjd9Pd70v5qq0/Wnqho+nS8n0MfDHh3+P7SEZsFayytc/j4evTfja3DEt8zBt1wc8T0wvod+X3zMnvjE/PXsyd/ALXSLH754nAAtvnnihfMfUu6MH574tuJbdcTHgDvzZhCDdJdDk+XgHEPtu0NyOYx9FqPd6RBD9DhoKpdDDPeOwenQ654Hl0NMY40hD5eDrDHoN+W7HTw1OXpbaQi+glr7QgzJtxT4Om0O0dUW+jV9pWGkux1cbZHiyqR+T/Y45LXDK7ockuxjaL5ZjLjGEFyrmWWtZq6u7SGXdq9D28fQXK2pXwSWw6h3OhTfNlnyqsni22BqXBttdR269EHiumXpodvjIHt3i+vgow8jVx6k+PKQ1xhqdnVWlT2TcreDb7OvbeWh+qq6juXQgucQpg9eV2+24spDk30Mvjy0vvao1l27fU9rLXp2dXff+6I3V3e3sW7d3bfTfnLwdLesc5hETzVI4UJI8ayDNBaT9OqKlxXvudtJZQLFtYZS1/xdh/G6jgzVdWKoheP37Ul18PotePJXJd51/bRu0/rM2ZP/tfy+Hl5b2fCsfhvreYDr4L2fml2H5v2r5Ljv8r7zUd0PN7674bqV+U4V+63wc/q+6avj4/n26VffDzjdzscfl5O9fHq7Pv7x39d/X/gf/mr8cnt+PP18u53gtP90rH++iv6OKDl+0we++mqEB/3upC/w9PZr0Wf8pQheRnxUz3BSwrcPjOw/", + "bytecode": "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", + "debug_symbols": "pZnNbhs5EITfRWcf+Nf8yasEQaA4ciBAkA3FXmBh+N2XNd3FiQ8LBK2L65OlriGb3Rxq9H74efrx9uv7+fr0/Pvw5ev74cftfLmcf32/PD8eX8/P1/nf90PAnxjj4Ut8mJpMs2kxFdNq2ky76VBNwdT8kvkl80vml8wvmV8yv2R+yfyy+eX5uQSd/89Ty/x/gUbTeR2BZtNiKqbVdF6nQrvpUJVgGk2TaTadfg0qptW0mXbToVqDaTRNptnU/Kr5VfOr5lenX4cO1RZMo2kyzabFdPoNaDVFXgOgE4ZBDwSsFZLcsTjIchdCJTRCJwyDEQjwweIMLDpWZWRCIQihEhqhE+A8FyuFQIBzBcC5ATKhEIQA5w5ohE4YBhHOAxAJiZAJhSCESmiE6ZwCYDqnmcOEBlCYzikBEiETCkEIlQDDDBgG6ACFSEiETIBhAcAQGdv6ZYNG6IRhgB5SiIRE4AjRPwmZRwMpwBB5RgspDAM0kQIMkWe0kUImwAepQ+cooKWRQ/SMQiQkQiYUghAqYRpmZB69ozAM0DXbtdA2GfNC3yjAEDlE5yhUQiN0wjBA7yhEQiJkAp07nTud0U0Z64VuUhgG6CaFSEiETCgEOGO90E0KcMYyoZsUhkJGNynAuQESIRPg0wGNgPCZuoyWUYiERMiEQhBCJTQDNEgJgEiY4SUCZlRJgBlVMqAR5nTKnHJGFxQBZMK8aMG8UPwKldAICMcEUfwbbDcQTBB3jIKBbbcIjAcVLhgPKlxhGKDCFZJFobAFY8YdQkEIMMTgUeGbMypcIRHwYcwLG7xgOltBQjEKjB3VpzAMUH0KkQA/TAvVp1AIQqiERugEOCMZqD6FSEiETCgEIcAZyUD1KXTCUCioPoVISIRMmD41AHBXnmkuKLqaAJlQCLLlqWwVBm2m3VRPCgX1tmk0TabFtNlFUWIKuDrewtarEAnJBobqUygEIVRCM9gOHQXQCcNgO2cIAOEV0AxQLLUBhADnDmiEThgGqCOFSMAlkF7seQqFgNMHpow9b7soamz7D2qsYfCoMYVEwBkGS4AaUxACjjFIFGpMoROGAWpMIRISIdswUGMKTMvgCAfzgxpTGAqCGlMQTa9sFbVBI2xL8PHxcOAp+Pvr7XTCIfiPY/E8LL8cb6fr6+HL9e1yeTj8c7y8bR/6/XK8bvp6vM13Z6pO159Tp+HT+XICfTzs0eH/Q0toFjxreYXL38ej9zS+Bkd8yxx8y8UR3wPje+j3xcfsiU/MX8+e/A3cQrf44YvHCdDimydeOP8h5c744YlvK75VR3wMuDNvBjFIdzk0WQ7OMdS+OySXw9hnMdqdDjFEj8NM5XKI4d4xOB163fPgcohprDHk4XKQNYb5TfluB09Njt5WGoKvoNa+EEPyLQW+TptDdLXF/Jq+0jDS3Q6utkhxZXJ+T/Y45LXDT3Q5JNnH0HyzGHGNIbhWM8tazVxd20Mu7V6Hto+huVpzfhFYDqPe6VB822TJqyaLb4OpcW201XXomg8S1y1rHro9DrJ3t7gOPvNh5MqDFF8e8hpDza7OqrJnUu528G32ta08VF9V17EcWvAcwuaD19Wbrbjy0GQfgy8Pra89qnXXbt/TWoueXd3d977ozdXdbaxbd/fttJ8cPN0t6xwm0VMNUrgQUjzrIJUTEFcOpbEYpVdXvKz45hr/mr/rMF7XkaG6Tgy1MH++PakOXr8Fz/yrxLuun9Ztej5z9uR/LZ+vh9dWNjzV18Z6HuA6eO+nZtehef8qOe67vO98VPfDje9uuG5lvlPFfiv8nL5v89Xx8Xz79KvvB5xu5+OPy8lePr1dH/949/XfF77DX41fbs+Pp59vtxOc9p+O55+vMn9HlBy/zQe+89UID/O703yBp7dfy3zGX4rgZcRH5xlOSvj2gZH9Bw==", "file_map": { "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 7b57b86ee23..4c0d26d7113 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -80,8 +80,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 384e7845040..bd53f885283 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -71,7 +71,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1b207bQBAdO2mBUCDlfmnBQKFQClrHCThvrdT+RN9KCS996lf1R9qXfkc/pCzMqMvi+GXPWhkpI1mTzNqjs3M545WShB7k4u76xJ+Tu6vFun13ZZ7tWYXteYVtpsI2W2Gbq7B12NZmTCk9lYT1B9YmTHKEr9sHuamAG+o7lw9uLJZYd/3EdTmArrQiBqwwl/3+6Ko3yov8q+kNr8uB6Q+uL8u8zAfl4KZXFsWo7JdXw+vhlRnm/WKU3w6GvVv2tRTuq2BfphspkX7BheJcwuXCtDi/kmPbOLZRnzu4U2fdFRSGcXEyYZKTAowvkRiVst43whdXJests16RgAjrWUPmAZhk1lsmHJusREokmvWWCct6luWkYewrh33FsK8UHcZur5Tv8wWFY1ysTJioYL7VCBjvBd24QIp+tOnQhlgDBtAlQ+s3o8eCbuZ1wjazfV2RZl73Lisp3+MLCEM+Lk4mTFQ0MrIOG32FSQg2+Ro7uG2w3pSASNdaQ+YBQDOhG7DQV5gNwrHJZqREollvA5cLo/VQltDkY9yiKaM1dijbZr0jARFGs4bMAzDJjLZNOKbYiZRINKNtE5bRNB62NDDaqwgY7wXdkEDqfbTp0EJ/DQygS3LWb0Z6Dygaih+Zu0bHeUqwKdDYAWWX9Z4ERCrdGjIPAJo93ICFjvNdwrHHXqREosf5LmHHucYDSkqTjzGjKaM1dkDZZ30gARFGs4bMAzDJjLZPOKY4iJRINKPtE5bRNB5QNDDaYQSM94JuyCzSpkML/Q0wgC7JWb92z1oPKBqKH5m7Rsd5i/SN8yPWxxIQqXRryDwAaPZwAxY6zo8Ixx7HpGOcH9F0nLdo8jG+RWLUOnqmicKCjRYE5K9RYmE8iYCxEmgoRZ8CN621oE4VYHxHSgrqDAe0p7WgzhRgfE9KCuocB7TQWlDnCjBeUKSCSsFA54HFGWvOo/f8ArjnWKMIvecF4J5jsSV6z4vAPSMb2h6u2vT/V9+2B21N2hwtchwSb11E/tohPuQPb/7fQHzpVHxOqbv45df33+593Zq1VdZrfz9u/fjz87O7tlPzXFazdljj86TmufOaNVPjczDmORkAs6znWHecdeChuCf+5+P4NzP0VNwamPfWpPfaFc8lY76nnq6717e7toWKNfG5wtrFK/v4B5zzQy3KPQAA", - "debug_symbols": "pZRBboMwEEXv4jUL4xmDyVWqKnKIEyFZgByIVEW5eyf+gSaLShXd8ADz/ngw+KaO4TCf911/Gi5q93FTh9TF2J33cWj91A293L3dC7Vc7qcUgtxSL+NijT6FflK7fo6xUFcf5/zQZfR95uSTjOpChf4olMBTF8Pj7F782Pp3lWiRicpVt3/3a7v4dbPBZ01Pn/UmvzSLX7r/1d/kk2vW+est9blefFtu8u3qmy3+uv7M7/6nXPm2S29frKrVTl64y8cmH0sNlPIyBAYggAELVIBksMABkiItGA1ISiUwAAGcKxgLVABmYlzONE0GaQBzIcyFKBcizhXIAlWOJqQQGiJ0xOiIkcJIYXTE6IjREVc5muucyQ5ocrSVFFlbWwIGIEBSnEBS5POxFVADDmgyKg2UgKQ8/pKrT50/xPDcRE5z377sKdPXuIwsu86YhjYc5xQeq5nHZH2/AQ==", + "debug_symbols": "pZRBboMwEEXv4nUWtmcMJlepqogQp0KyADlQqYpy9w7+QJNFpYpu/LDN/zPjsXxXl3CePk5td+1v6vh2V+fUxth+nGLf1GPbd7J6fxzUOj2NKQRZUk/7ohrqFLpRHbspxoP6rOOUf7oNdZc51kl29UGF7iIUw2sbw/z1OPyo9e9SolVMZDa5+7u+dKu+rHboWdOiZ71Lb+yqN/5/8XfpyVdb/npPfCpXPe85f+ZN7/bp3aa3u/LXW/6v+neZ1U2bXm68KtVRGubzWOXRaMDIYQosQAADDigA8WCBB8RFSrAaEJdCYAECOEewDigAZGJ99rRVBmkAuRByIcqBiHMEckCRrQkuhIIIFTEqYrgwXBgVMSpiVMRFtuYye7IHqmztxMULDGABAsRF7p0TFyPn74qF5UK/sAILvdAstDMfc1dTW59jWB6j69Q1T2/T+DWsO+vrNaS+CZcphbmreU/6/A0=", "file_map": { "50": { "source": "// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,\n// the return data is computed as a linear combination of the calldata.\nfn main(\n mut x: [u32; 4],\n y: call_data(0) [u32; 3],\n z: call_data(1) [u32; 4],\n) -> return_data [u32; 4] {\n let mut result = [0; 4];\n for i in 0..3 {\n let idx = x[i];\n result[idx] = y[idx] + z[idx];\n }\n result[x[3]] = z[x[3]];\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_0.snap index 384e7845040..bd53f885283 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_0.snap @@ -71,7 +71,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1b207bQBAdO2mBUCDlfmnBQKFQClrHCThvrdT+RN9KCS996lf1R9qXfkc/pCzMqMvi+GXPWhkpI1mTzNqjs3M545WShB7k4u76xJ+Tu6vFun13ZZ7tWYXteYVtpsI2W2Gbq7B12NZmTCk9lYT1B9YmTHKEr9sHuamAG+o7lw9uLJZYd/3EdTmArrQiBqwwl/3+6Ko3yov8q+kNr8uB6Q+uL8u8zAfl4KZXFsWo7JdXw+vhlRnm/WKU3w6GvVv2tRTuq2BfphspkX7BheJcwuXCtDi/kmPbOLZRnzu4U2fdFRSGcXEyYZKTAowvkRiVst43whdXJests16RgAjrWUPmAZhk1lsmHJusREokmvWWCct6luWkYewrh33FsK8UHcZur5Tv8wWFY1ysTJioYL7VCBjvBd24QIp+tOnQhlgDBtAlQ+s3o8eCbuZ1wjazfV2RZl73Lisp3+MLCEM+Lk4mTFQ0MrIOG32FSQg2+Ro7uG2w3pSASNdaQ+YBQDOhG7DQV5gNwrHJZqREollvA5cLo/VQltDkY9yiKaM1dijbZr0jARFGs4bMAzDJjLZNOKbYiZRINKNtE5bRNB62NDDaqwgY7wXdkEDqfbTp0EJ/DQygS3LWb0Z6Dygaih+Zu0bHeUqwKdDYAWWX9Z4ERCrdGjIPAJo93ICFjvNdwrHHXqREosf5LmHHucYDSkqTjzGjKaM1dkDZZ30gARFGs4bMAzDJjLZPOKY4iJRINKPtE5bRNB5QNDDaYQSM94JuyCzSpkML/Q0wgC7JWb92z1oPKBqKH5m7Rsd5i/SN8yPWxxIQqXRryDwAaPZwAxY6zo8Ixx7HpGOcH9F0nLdo8jG+RWLUOnqmicKCjRYE5K9RYmE8iYCxEmgoRZ8CN621oE4VYHxHSgrqDAe0p7WgzhRgfE9KCuocB7TQWlDnCjBeUKSCSsFA54HFGWvOo/f8ArjnWKMIvecF4J5jsSV6z4vAPSMb2h6u2vT/V9+2B21N2hwtchwSb11E/tohPuQPb/7fQHzpVHxOqbv45df33+593Zq1VdZrfz9u/fjz87O7tlPzXFazdljj86TmufOaNVPjczDmORkAs6znWHecdeChuCf+5+P4NzP0VNwamPfWpPfaFc8lY76nnq6717e7toWKNfG5wtrFK/v4B5zzQy3KPQAA", - "debug_symbols": "pZRBboMwEEXv4jUL4xmDyVWqKnKIEyFZgByIVEW5eyf+gSaLShXd8ADz/ngw+KaO4TCf911/Gi5q93FTh9TF2J33cWj91A293L3dC7Vc7qcUgtxSL+NijT6FflK7fo6xUFcf5/zQZfR95uSTjOpChf4olMBTF8Pj7F782Pp3lWiRicpVt3/3a7v4dbPBZ01Pn/UmvzSLX7r/1d/kk2vW+est9blefFtu8u3qmy3+uv7M7/6nXPm2S29frKrVTl64y8cmH0sNlPIyBAYggAELVIBksMABkiItGA1ISiUwAAGcKxgLVABmYlzONE0GaQBzIcyFKBcizhXIAlWOJqQQGiJ0xOiIkcJIYXTE6IjREVc5muucyQ5ocrSVFFlbWwIGIEBSnEBS5POxFVADDmgyKg2UgKQ8/pKrT50/xPDcRE5z377sKdPXuIwsu86YhjYc5xQeq5nHZH2/AQ==", + "debug_symbols": "pZRBboMwEEXv4nUWtmcMJlepqogQp0KyADlQqYpy9w7+QJNFpYpu/LDN/zPjsXxXl3CePk5td+1v6vh2V+fUxth+nGLf1GPbd7J6fxzUOj2NKQRZUk/7ohrqFLpRHbspxoP6rOOUf7oNdZc51kl29UGF7iIUw2sbw/z1OPyo9e9SolVMZDa5+7u+dKu+rHboWdOiZ71Lb+yqN/5/8XfpyVdb/npPfCpXPe85f+ZN7/bp3aa3u/LXW/6v+neZ1U2bXm68KtVRGubzWOXRaMDIYQosQAADDigA8WCBB8RFSrAaEJdCYAECOEewDigAZGJ99rRVBmkAuRByIcqBiHMEckCRrQkuhIIIFTEqYrgwXBgVMSpiVMRFtuYye7IHqmztxMULDGABAsRF7p0TFyPn74qF5UK/sAILvdAstDMfc1dTW59jWB6j69Q1T2/T+DWsO+vrNaS+CZcphbmreU/6/A0=", "file_map": { "50": { "source": "// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,\n// the return data is computed as a linear combination of the calldata.\nfn main(\n mut x: [u32; 4],\n y: call_data(0) [u32; 3],\n z: call_data(1) [u32; 4],\n) -> return_data [u32; 4] {\n let mut result = [0; 4];\n for i in 0..3 {\n let idx = x[i];\n result[idx] = y[idx] + z[idx];\n }\n result[x[3]] = z[x[3]];\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 384e7845040..bd53f885283 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -71,7 +71,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1b207bQBAdO2mBUCDlfmnBQKFQClrHCThvrdT+RN9KCS996lf1R9qXfkc/pCzMqMvi+GXPWhkpI1mTzNqjs3M545WShB7k4u76xJ+Tu6vFun13ZZ7tWYXteYVtpsI2W2Gbq7B12NZmTCk9lYT1B9YmTHKEr9sHuamAG+o7lw9uLJZYd/3EdTmArrQiBqwwl/3+6Ko3yov8q+kNr8uB6Q+uL8u8zAfl4KZXFsWo7JdXw+vhlRnm/WKU3w6GvVv2tRTuq2BfphspkX7BheJcwuXCtDi/kmPbOLZRnzu4U2fdFRSGcXEyYZKTAowvkRiVst43whdXJests16RgAjrWUPmAZhk1lsmHJusREokmvWWCct6luWkYewrh33FsK8UHcZur5Tv8wWFY1ysTJioYL7VCBjvBd24QIp+tOnQhlgDBtAlQ+s3o8eCbuZ1wjazfV2RZl73Lisp3+MLCEM+Lk4mTFQ0MrIOG32FSQg2+Ro7uG2w3pSASNdaQ+YBQDOhG7DQV5gNwrHJZqREollvA5cLo/VQltDkY9yiKaM1dijbZr0jARFGs4bMAzDJjLZNOKbYiZRINKNtE5bRNB62NDDaqwgY7wXdkEDqfbTp0EJ/DQygS3LWb0Z6Dygaih+Zu0bHeUqwKdDYAWWX9Z4ERCrdGjIPAJo93ICFjvNdwrHHXqREosf5LmHHucYDSkqTjzGjKaM1dkDZZ30gARFGs4bMAzDJjLZPOKY4iJRINKPtE5bRNB5QNDDaYQSM94JuyCzSpkML/Q0wgC7JWb92z1oPKBqKH5m7Rsd5i/SN8yPWxxIQqXRryDwAaPZwAxY6zo8Ixx7HpGOcH9F0nLdo8jG+RWLUOnqmicKCjRYE5K9RYmE8iYCxEmgoRZ8CN621oE4VYHxHSgrqDAe0p7WgzhRgfE9KCuocB7TQWlDnCjBeUKSCSsFA54HFGWvOo/f8ArjnWKMIvecF4J5jsSV6z4vAPSMb2h6u2vT/V9+2B21N2hwtchwSb11E/tohPuQPb/7fQHzpVHxOqbv45df33+593Zq1VdZrfz9u/fjz87O7tlPzXFazdljj86TmufOaNVPjczDmORkAs6znWHecdeChuCf+5+P4NzP0VNwamPfWpPfaFc8lY76nnq6717e7toWKNfG5wtrFK/v4B5zzQy3KPQAA", - "debug_symbols": "pZRBboMwEEXv4jUL4xmDyVWqKnKIEyFZgByIVEW5eyf+gSaLShXd8ADz/ngw+KaO4TCf911/Gi5q93FTh9TF2J33cWj91A293L3dC7Vc7qcUgtxSL+NijT6FflK7fo6xUFcf5/zQZfR95uSTjOpChf4olMBTF8Pj7F782Pp3lWiRicpVt3/3a7v4dbPBZ01Pn/UmvzSLX7r/1d/kk2vW+est9blefFtu8u3qmy3+uv7M7/6nXPm2S29frKrVTl64y8cmH0sNlPIyBAYggAELVIBksMABkiItGA1ISiUwAAGcKxgLVABmYlzONE0GaQBzIcyFKBcizhXIAlWOJqQQGiJ0xOiIkcJIYXTE6IjREVc5muucyQ5ocrSVFFlbWwIGIEBSnEBS5POxFVADDmgyKg2UgKQ8/pKrT50/xPDcRE5z377sKdPXuIwsu86YhjYc5xQeq5nHZH2/AQ==", + "debug_symbols": "pZRBboMwEEXv4nUWtmcMJlepqogQp0KyADlQqYpy9w7+QJNFpYpu/LDN/zPjsXxXl3CePk5td+1v6vh2V+fUxth+nGLf1GPbd7J6fxzUOj2NKQRZUk/7ohrqFLpRHbspxoP6rOOUf7oNdZc51kl29UGF7iIUw2sbw/z1OPyo9e9SolVMZDa5+7u+dKu+rHboWdOiZ71Lb+yqN/5/8XfpyVdb/npPfCpXPe85f+ZN7/bp3aa3u/LXW/6v+neZ1U2bXm68KtVRGubzWOXRaMDIYQosQAADDigA8WCBB8RFSrAaEJdCYAECOEewDigAZGJ99rRVBmkAuRByIcqBiHMEckCRrQkuhIIIFTEqYrgwXBgVMSpiVMRFtuYye7IHqmztxMULDGABAsRF7p0TFyPn74qF5UK/sAILvdAstDMfc1dTW59jWB6j69Q1T2/T+DWsO+vrNaS+CZcphbmreU/6/A0=", "file_map": { "50": { "source": "// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,\n// the return data is computed as a linear combination of the calldata.\nfn main(\n mut x: [u32; 4],\n y: call_data(0) [u32; 3],\n z: call_data(1) [u32; 4],\n) -> return_data [u32; 4] {\n let mut result = [0; 4];\n for i in 0..3 {\n let idx = x[i];\n result[idx] = y[idx] + z[idx];\n }\n result[x[3]] = z[x[3]];\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index b55a09b2581..5434b72c61f 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -75,7 +75,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1Zy27TQBSdie087KSJ4Edi6pCyK1Lfr39I00ZIrPgCvGLFjg9gAxILxIYdEkj8GZl2bnJyfcdJiUeVESNFY889c993Ho5W921n/tP2ObR9YHsNYwrGTNu3/XC7llbIa+hLR10DHRs10DGoUEcNeepL37AGPo1qoGOz4rj7XpNaNfBpuwY6dmqgY1xxbpKOlKPJ/Ned/3rqfq9dDKJBZvEO7CRT0KZgTBKaIBsnxoAvZQwO+m37ju0bQK9wIU47TG6V/PeGo92OWm0V63/HHwNWMf9r4h/54T9sWT4H+ZI/2kJyA4bjcwLAHALm0IE5AsyRA3MMmGMH5gQwJw7MKWBOHZgzwJw5MOeAOXdgLgBz4cBcAubSgbkCzBXDUE74qZks85xzWU8VLwdkC8lu+pE90kyeUqsXFsXkx8prfaeaySN9uH9o/e0RJl/qoxktzIt2EC0CGsXX7BMvAcdzi/Sg2PjYC+Z5t+c573YfMe+yfzHvOC3Mi3Y8NO8wt3jeBR58Mc+76//rXb3yLmC0MC/a8dC8kz5aGdwFPF8CBnMVbdCCDZ7zd+b5DJo9tPZ5fDAG6NuXzD+e9pWZT/8b/zx16E/PprVytWgB8yf6iHzWRjyjdYAW5qtyYvseghzkRXpEDH9u3/u2b8Icmj8Q5DeZ/BW9hTH0EecVCGOEN3V9YJ8T+zM59NGOUR1Hy6lKO3qUJdXrQBX3A75e+zh7m0Z2NAU7SHbLj+yN9wqSHyuve9dir2gxfbh/cC0ytLag60CgafbcFuS0BTl15EW+QV9uWx+YhxQPz+eZtCPY6ON7Dv8uVbX+sR/9C2dNzAETk1dsnGiRKp7D0M8Rw78Fnq/tc18V85evoXjGCwR8zHhJ94Ey3RsCL677G9sb2z5voF8AYw2GjwQ86tlg9ki+6TM5WFtl51/K0ZDR9u34cLs2Mv75Anpw/+C5bp0vlCr6TroDYL7w9abJ5iMN16KQ6awFmjk/bJKvXUFHXWJTT8B3BfkkOwFaj/GS8hvxrtp8Z3spvyV7GlvYkzB7dIk93TX28Hol/PsSeyT9yup1R8D3SuxBW3c2kI32dx2ymw784r7E8B/U0v5fTD+cX7ZmEO4x1gzMOb5mSPFAPI9fX8BjXCh+A4ZH/0prBo+VFuTguo7fGTiN5uJ+69Pv473ln4cUc6ox3kKgI/6TfcdziQLb9v9Sz9l4ks52J7PJaHJzk00nTxh/0yjGiQf509Hz62k2mgxvU/P6bJ186f6LdWQa3aHxjo144hcx/FfCzn/f7DP/RoLyDO5nCU47+jsewliYr45Jd2/8JkF4kh3nRR2JlgANa9y0rn1HfyEv0iNi+B/2nWKC3xFo/kCQ32byV/QWxvg3iUTAJwLexOc78bM92l71XfhOJuOPY1w3yh0fdTUvqfF0Mk7TF1l6m6WjdXX1B9ekZP8xKAAA", - "debug_symbols": "pdTfiuowEAbwd8l1LzL502R8FRGpGpdCqdJtDxyk735mnIm7Z2Fh6d74S4zf1xJiHuZSTsvbsR+vt3ez2z/MaeqHoX87DrdzN/e3kb59GMsfGcwOGpOd4IUgRKEVkpAFfIJWkBaUFpQWlBaUFpQWlBawtOhYmnuWagOLIlgVVKdSd2SDGtVWpb6WzSqKzqqgOtWrQU3yXo7yiUXRWxVUp3qV8pmNaqsmNasoBupDFlSn8t5ZHoQ6iHXQ1kGqgyybF1CMVgXVqV4NalSp0a9rY+q5OM5TKXwsPh0UOj73birjbHbjMgyN+dMNy/NH7/dufDp3E63SG5XxQlLhtR8Kj9bmI22/j3pfw97DKx5/no++5mPYks+o+WDthnwIqeYjbMrHV95tyb/2L4QteZ/q833CLc+3/rV/m/Lgah7y757/JX+gWXfup/+uvpWbpr47DUWn12U8f1qd/97rSr0679PtXC7LVLjp4/6kjz20uYGMh8bQ/2zfxibFA19lvBSxgTbwFHiKtgF0h5Vf7B8=", + "debug_symbols": "pdTbasMwDAbgd/G1L3yMrb5KKSVt3REIacmSwSh590mVnB1gMLKbfHLdXzHG8UNdyml+OXbD9faqdvuHOo1d33cvx/52bqfuNuCvD2Xoka3aWa2yYzwTmMg0TGIyA0/AMNwFuAtwF+AuwF2AuwB3sQYnHYljT2LbQAJrsXEkrehE7N2QQYxiI2K/RGYRWGdEKzrRi0FMvC6H+UwC641oRSd6EfNARrERk5hFYANtnKHC1sLVgraP9iiEWsRaNLVItci8fwHYaEQrOtGLQYwidvTLolU9GsdpLIVOxpezgifo3o5lmNRumPteq7e2n59/er23w9OpHXEWl1+GC4oNr11fqFr0Z9r8HvW+hr23azz+PR99zcewJZ9B8sGYDfngU82HLesPYc3Hbfm45t2m9Zt1/VvyPtX3+wRb3m/8uv+b8tbVvM3/e/+P/AFH7bkbv92eC3Uau/bUFxle5+H8ZXZ6v9eZevvex9u5XOaxUKfPKxgfe9tkbTMctMLvdN9EneKBbkOaiqBtE2hoaQhGW3CHhRb2AQ==", "file_map": { "50": { "source": "// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,\n// the return data is computed as a linear combination of the calldata.\nfn main(\n mut x: [u32; 4],\n y: call_data(0) [u32; 3],\n z: call_data(1) [u32; 4],\n) -> return_data [u32; 4] {\n let mut result = [0; 4];\n for i in 0..3 {\n let idx = x[i];\n result[idx] = y[idx] + z[idx];\n }\n result[x[3]] = z[x[3]];\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_0.snap index b55a09b2581..5434b72c61f 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_0.snap @@ -75,7 +75,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1Zy27TQBSdie087KSJ4Edi6pCyK1Lfr39I00ZIrPgCvGLFjg9gAxILxIYdEkj8GZl2bnJyfcdJiUeVESNFY889c993Ho5W921n/tP2ObR9YHsNYwrGTNu3/XC7llbIa+hLR10DHRs10DGoUEcNeepL37AGPo1qoGOz4rj7XpNaNfBpuwY6dmqgY1xxbpKOlKPJ/Ned/3rqfq9dDKJBZvEO7CRT0KZgTBKaIBsnxoAvZQwO+m37ju0bQK9wIU47TG6V/PeGo92OWm0V63/HHwNWMf9r4h/54T9sWT4H+ZI/2kJyA4bjcwLAHALm0IE5AsyRA3MMmGMH5gQwJw7MKWBOHZgzwJw5MOeAOXdgLgBz4cBcAubSgbkCzBXDUE74qZks85xzWU8VLwdkC8lu+pE90kyeUqsXFsXkx8prfaeaySN9uH9o/e0RJl/qoxktzIt2EC0CGsXX7BMvAcdzi/Sg2PjYC+Z5t+c573YfMe+yfzHvOC3Mi3Y8NO8wt3jeBR58Mc+76//rXb3yLmC0MC/a8dC8kz5aGdwFPF8CBnMVbdCCDZ7zd+b5DJo9tPZ5fDAG6NuXzD+e9pWZT/8b/zx16E/PprVytWgB8yf6iHzWRjyjdYAW5qtyYvseghzkRXpEDH9u3/u2b8Icmj8Q5DeZ/BW9hTH0EecVCGOEN3V9YJ8T+zM59NGOUR1Hy6lKO3qUJdXrQBX3A75e+zh7m0Z2NAU7SHbLj+yN9wqSHyuve9dir2gxfbh/cC0ytLag60CgafbcFuS0BTl15EW+QV9uWx+YhxQPz+eZtCPY6ON7Dv8uVbX+sR/9C2dNzAETk1dsnGiRKp7D0M8Rw78Fnq/tc18V85evoXjGCwR8zHhJ94Ey3RsCL677G9sb2z5voF8AYw2GjwQ86tlg9ki+6TM5WFtl51/K0ZDR9u34cLs2Mv75Anpw/+C5bp0vlCr6TroDYL7w9abJ5iMN16KQ6awFmjk/bJKvXUFHXWJTT8B3BfkkOwFaj/GS8hvxrtp8Z3spvyV7GlvYkzB7dIk93TX28Hol/PsSeyT9yup1R8D3SuxBW3c2kI32dx2ymw784r7E8B/U0v5fTD+cX7ZmEO4x1gzMOb5mSPFAPI9fX8BjXCh+A4ZH/0prBo+VFuTguo7fGTiN5uJ+69Pv473ln4cUc6ox3kKgI/6TfcdziQLb9v9Sz9l4ks52J7PJaHJzk00nTxh/0yjGiQf509Hz62k2mgxvU/P6bJ186f6LdWQa3aHxjo144hcx/FfCzn/f7DP/RoLyDO5nCU47+jsewliYr45Jd2/8JkF4kh3nRR2JlgANa9y0rn1HfyEv0iNi+B/2nWKC3xFo/kCQ32byV/QWxvg3iUTAJwLexOc78bM92l71XfhOJuOPY1w3yh0fdTUvqfF0Mk7TF1l6m6WjdXX1B9ekZP8xKAAA", - "debug_symbols": "pdTfiuowEAbwd8l1LzL502R8FRGpGpdCqdJtDxyk735mnIm7Z2Fh6d74S4zf1xJiHuZSTsvbsR+vt3ez2z/MaeqHoX87DrdzN/e3kb59GMsfGcwOGpOd4IUgRKEVkpAFfIJWkBaUFpQWlBaUFpQWlBawtOhYmnuWagOLIlgVVKdSd2SDGtVWpb6WzSqKzqqgOtWrQU3yXo7yiUXRWxVUp3qV8pmNaqsmNasoBupDFlSn8t5ZHoQ6iHXQ1kGqgyybF1CMVgXVqV4NalSp0a9rY+q5OM5TKXwsPh0UOj73birjbHbjMgyN+dMNy/NH7/dufDp3E63SG5XxQlLhtR8Kj9bmI22/j3pfw97DKx5/no++5mPYks+o+WDthnwIqeYjbMrHV95tyb/2L4QteZ/q833CLc+3/rV/m/Lgah7y757/JX+gWXfup/+uvpWbpr47DUWn12U8f1qd/97rSr0679PtXC7LVLjp4/6kjz20uYGMh8bQ/2zfxibFA19lvBSxgTbwFHiKtgF0h5Vf7B8=", + "debug_symbols": "pdTbasMwDAbgd/G1L3yMrb5KKSVt3REIacmSwSh590mVnB1gMLKbfHLdXzHG8UNdyml+OXbD9faqdvuHOo1d33cvx/52bqfuNuCvD2Xoka3aWa2yYzwTmMg0TGIyA0/AMNwFuAtwF+AuwF2AuwB3sQYnHYljT2LbQAJrsXEkrehE7N2QQYxiI2K/RGYRWGdEKzrRi0FMvC6H+UwC641oRSd6EfNARrERk5hFYANtnKHC1sLVgraP9iiEWsRaNLVItci8fwHYaEQrOtGLQYwidvTLolU9GsdpLIVOxpezgifo3o5lmNRumPteq7e2n59/er23w9OpHXEWl1+GC4oNr11fqFr0Z9r8HvW+hr23azz+PR99zcewJZ9B8sGYDfngU82HLesPYc3Hbfm45t2m9Zt1/VvyPtX3+wRb3m/8uv+b8tbVvM3/e/+P/AFH7bkbv92eC3Uau/bUFxle5+H8ZXZ6v9eZevvex9u5XOaxUKfPKxgfe9tkbTMctMLvdN9EneKBbkOaiqBtE2hoaQhGW3CHhRb2AQ==", "file_map": { "50": { "source": "// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,\n// the return data is computed as a linear combination of the calldata.\nfn main(\n mut x: [u32; 4],\n y: call_data(0) [u32; 3],\n z: call_data(1) [u32; 4],\n) -> return_data [u32; 4] {\n let mut result = [0; 4];\n for i in 0..3 {\n let idx = x[i];\n result[idx] = y[idx] + z[idx];\n }\n result[x[3]] = z[x[3]];\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index b55a09b2581..5434b72c61f 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/databus_two_calldata/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -75,7 +75,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1Zy27TQBSdie087KSJ4Edi6pCyK1Lfr39I00ZIrPgCvGLFjg9gAxILxIYdEkj8GZl2bnJyfcdJiUeVESNFY889c993Ho5W921n/tP2ObR9YHsNYwrGTNu3/XC7llbIa+hLR10DHRs10DGoUEcNeepL37AGPo1qoGOz4rj7XpNaNfBpuwY6dmqgY1xxbpKOlKPJ/Ned/3rqfq9dDKJBZvEO7CRT0KZgTBKaIBsnxoAvZQwO+m37ju0bQK9wIU47TG6V/PeGo92OWm0V63/HHwNWMf9r4h/54T9sWT4H+ZI/2kJyA4bjcwLAHALm0IE5AsyRA3MMmGMH5gQwJw7MKWBOHZgzwJw5MOeAOXdgLgBz4cBcAubSgbkCzBXDUE74qZks85xzWU8VLwdkC8lu+pE90kyeUqsXFsXkx8prfaeaySN9uH9o/e0RJl/qoxktzIt2EC0CGsXX7BMvAcdzi/Sg2PjYC+Z5t+c573YfMe+yfzHvOC3Mi3Y8NO8wt3jeBR58Mc+76//rXb3yLmC0MC/a8dC8kz5aGdwFPF8CBnMVbdCCDZ7zd+b5DJo9tPZ5fDAG6NuXzD+e9pWZT/8b/zx16E/PprVytWgB8yf6iHzWRjyjdYAW5qtyYvseghzkRXpEDH9u3/u2b8Icmj8Q5DeZ/BW9hTH0EecVCGOEN3V9YJ8T+zM59NGOUR1Hy6lKO3qUJdXrQBX3A75e+zh7m0Z2NAU7SHbLj+yN9wqSHyuve9dir2gxfbh/cC0ytLag60CgafbcFuS0BTl15EW+QV9uWx+YhxQPz+eZtCPY6ON7Dv8uVbX+sR/9C2dNzAETk1dsnGiRKp7D0M8Rw78Fnq/tc18V85evoXjGCwR8zHhJ94Ey3RsCL677G9sb2z5voF8AYw2GjwQ86tlg9ki+6TM5WFtl51/K0ZDR9u34cLs2Mv75Anpw/+C5bp0vlCr6TroDYL7w9abJ5iMN16KQ6awFmjk/bJKvXUFHXWJTT8B3BfkkOwFaj/GS8hvxrtp8Z3spvyV7GlvYkzB7dIk93TX28Hol/PsSeyT9yup1R8D3SuxBW3c2kI32dx2ymw784r7E8B/U0v5fTD+cX7ZmEO4x1gzMOb5mSPFAPI9fX8BjXCh+A4ZH/0prBo+VFuTguo7fGTiN5uJ+69Pv473ln4cUc6ox3kKgI/6TfcdziQLb9v9Sz9l4ks52J7PJaHJzk00nTxh/0yjGiQf509Hz62k2mgxvU/P6bJ186f6LdWQa3aHxjo144hcx/FfCzn/f7DP/RoLyDO5nCU47+jsewliYr45Jd2/8JkF4kh3nRR2JlgANa9y0rn1HfyEv0iNi+B/2nWKC3xFo/kCQ32byV/QWxvg3iUTAJwLexOc78bM92l71XfhOJuOPY1w3yh0fdTUvqfF0Mk7TF1l6m6WjdXX1B9ekZP8xKAAA", - "debug_symbols": "pdTfiuowEAbwd8l1LzL502R8FRGpGpdCqdJtDxyk735mnIm7Z2Fh6d74S4zf1xJiHuZSTsvbsR+vt3ez2z/MaeqHoX87DrdzN/e3kb59GMsfGcwOGpOd4IUgRKEVkpAFfIJWkBaUFpQWlBaUFpQWlBawtOhYmnuWagOLIlgVVKdSd2SDGtVWpb6WzSqKzqqgOtWrQU3yXo7yiUXRWxVUp3qV8pmNaqsmNasoBupDFlSn8t5ZHoQ6iHXQ1kGqgyybF1CMVgXVqV4NalSp0a9rY+q5OM5TKXwsPh0UOj73birjbHbjMgyN+dMNy/NH7/dufDp3E63SG5XxQlLhtR8Kj9bmI22/j3pfw97DKx5/no++5mPYks+o+WDthnwIqeYjbMrHV95tyb/2L4QteZ/q833CLc+3/rV/m/Lgah7y757/JX+gWXfup/+uvpWbpr47DUWn12U8f1qd/97rSr0679PtXC7LVLjp4/6kjz20uYGMh8bQ/2zfxibFA19lvBSxgTbwFHiKtgF0h5Vf7B8=", + "debug_symbols": "pdTbasMwDAbgd/G1L3yMrb5KKSVt3REIacmSwSh590mVnB1gMLKbfHLdXzHG8UNdyml+OXbD9faqdvuHOo1d33cvx/52bqfuNuCvD2Xoka3aWa2yYzwTmMg0TGIyA0/AMNwFuAtwF+AuwF2AuwB3sQYnHYljT2LbQAJrsXEkrehE7N2QQYxiI2K/RGYRWGdEKzrRi0FMvC6H+UwC641oRSd6EfNARrERk5hFYANtnKHC1sLVgraP9iiEWsRaNLVItci8fwHYaEQrOtGLQYwidvTLolU9GsdpLIVOxpezgifo3o5lmNRumPteq7e2n59/er23w9OpHXEWl1+GC4oNr11fqFr0Z9r8HvW+hr23azz+PR99zcewJZ9B8sGYDfngU82HLesPYc3Hbfm45t2m9Zt1/VvyPtX3+wRb3m/8uv+b8tbVvM3/e/+P/AFH7bkbv92eC3Uau/bUFxle5+H8ZXZ6v9eZevvex9u5XOaxUKfPKxgfe9tkbTMctMLvdN9EneKBbkOaiqBtE2hoaQhGW3CHhRb2AQ==", "file_map": { "50": { "source": "// An simple program demonstrating two calldata array inputs and a single return data array. As an arbitrary example,\n// the return data is computed as a linear combination of the calldata.\nfn main(\n mut x: [u32; 4],\n y: call_data(0) [u32; 3],\n z: call_data(1) [u32; 4],\n) -> return_data [u32; 4] {\n let mut result = [0; 4];\n for i in 0..3 {\n let idx = x[i];\n result[idx] = y[idx] + z[idx];\n }\n result[x[3]] = z[x[3]];\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index b57089f820b..3f07a24b628 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -93,8 +93,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "nZbNbuowEIXfJess7PHfuK9SoSqloYoUBZTCla4Q73498ZzQLq5UecP3mTgHM4xN7t3H+H77fJuW0/mre3m9d+/rNM/T59t8Pg7X6byUd++dkReO3YvtO04VXJE3ZFNhK6jCVfiKsMGaQhJGZVKyMldao7RKUjqlV2qe1TyreVbzrOaR5pHmkeZRyXNCrwzKWOnKdS8s4yAs+VHIylzpjdIqS14SlvksLPOzMFcGo7RKKZoRcRAPCZAIkR9BqhkYklWigVgIQRzEQwIkQpAckRwlWSqVDMRCCCI5Uq0kk6VcbPUdJoh8ulSQPSRAIiRB5NOljFuDiWwttomFEMRBPCToMnKEJAhDdKlkDMRCCOIgkpNEEoQhWUU6torksAhBHMRDAiRCEoS3jiHpXKF07karJKVTemVQRqUsrLQWOQOxEII4iGwnIxIgEZIgDMkq0vRV7LY7yJPSKb0yKKMyKVlZEsPj0Xc4d96u6zjKsfPtICrH02VYx+XavSy3ee67P8N82yZ9XYZl43VYy9WyonH5KCyBp2kexR79827z/1tLn2W9m4x3e0D4dQIRExKImxKcxTcoalsSWBqxJjBxU4J3e0IyLQnZMBIy5YYEZwIq6Ux0TQkJayg1DS0J5azdE1JLJR3tHeXK7mpJ8LQneNdUyZgtEhKlloTEZk9g35SQ92/BFFsS+FkHDm0J8u+CNbT1g3l2lGuqpMn+2ZO+aW+m597ktt0d9lOO48+OOpTRcJzWH4+AD8lap+F9HnV4ui3Hb1evfy+4gkfIy3o+jh+3dZSk53NkeXmlmPqy9EPflf+J12R6Ngd59iuDzL01TkZ2m2h7iu7wkHX9Aw==", + "bytecode": "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", + "debug_symbols": "nZbNbuowEIXfJess7PHfuK9SoYrStIoUBZTCla4q3v167DmhXVyp8obvM3EOZhibfA1v0+vt42Ve38+fw9Pz1/C6zcsyf7ws59PxOp/X8u7XYOSF4/Bkx4FTAzfkimwabAM1uAbfECqsKSRhVCYlK3OjNUqrJKVTeqXmWc2zmmc1z2oeaR5pHmkelTwn9MqgjI2uXPfCMg7Ckh+FrMyN3iitsuQlYZnPwjI/C3NjMEqrlKIZEQfxkACJEPkRpJqBIVklGoiFEMRBPCRAIgTJEclRkqVSyUAshCCSI9VKMlnKxVbfYZkjhWMH8ZAAiZAEkU+XMtYGE6ktVsVCCOIgHhJ0GTlCEoQhulQyBmIhBHGQWH9Nkm61VRiSVaRhm0gMixDEQTwkQCIkQbg2DEnjCqVxK62SlE7plUEZlbk2LjlZVxaxEII4iGwmIxIgEZIgDMkq0vJNbN0b5EnplF4ZlFGZlKwsieF+HwecOi/XbZrk0Pl2DJXD6XLcpvU6PK23ZRmHP8flVid9Xo5r5fW4latlRdP6VlgC3+dlEruPj7vN/28tXZb1bjLe7QHh1wlETEgg7kpwFt+gqO1JYOnDlsDEXQne7QnJ9CRkw0jIlDsSnAmopDPRdSUkrKHUNPQklJN2T0g9lXS0d5Qru6snwdOe4F1XJWO2SEiUehISmz2BfVdC3r8FU+xJYPlnQEJXJflRSQ5dazDZPzqqqw7WPHrSpa69GfYzimPuSkiP3c0/u/pQRsfTvP14ALxL1jYfX5dJh++39fTt6vXvBVfwAHnZzqfp7bZNkvR4iiwvzxTTWD74MA7lf+I5mZHNQZ78yiDzaI2Tka0T7UjRHe6yrn8=", "file_map": { "50": { "source": "// The code below is inspired by [compute_encrypted_log](https://github.com/AztecProtocol/aztec-packages/blob/b42756bc10175fea9eb60544759e9dbe41ae5e76/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr#L111)\n// which resulted in a bytecode size blowup when compiled to ACIR, see https://github.com/noir-lang/noir/issues/6929\n// The issue was around `encrypted_bytes[offset + i]` generating large amounts of gates, as per the `flamegraph.sh` tool in aztec-packages.\n// The details around encryption and addresses have been stripped away, focusing on just copying bytes of equivalent size arrays.\n\n// Original values which resulted in huge bytecode even on this example (500K long SSA)\n// global PRIVATE_LOG_SIZE_IN_FIELDS: u32 = 18;\n// global ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n// global EPH_PK_SIZE: u32 = 32;\n// global HEADER_SIZE: u32 = 48;\n// global OVERHEAD_PADDING: u32 = 15;\n\n// Using the same formulas with smaller numbers; the effect is the same, but the SSA is more manageable.\nglobal PRIVATE_LOG_SIZE_IN_FIELDS: u32 = 4;\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 5;\nglobal EPH_PK_SIZE: u32 = 3;\nglobal HEADER_SIZE: u32 = 2;\nglobal OVERHEAD_PADDING: u32 = 1;\n\n// Unused because encryption didn't play a role:\n// global OVERHEAD_SIZE: u32 = EPH_PK_SIZE + HEADER_SIZE + OVERHEAD_PADDING;\n// global PLAINTEXT_LENGTH_SIZE: u32 = 2;\n// global MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n// ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\nglobal BODY_SIZE: u32 =\n ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - EPH_PK_SIZE - HEADER_SIZE - OVERHEAD_PADDING;\n\nfn main(\n eph_pk_bytes: [u8; EPH_PK_SIZE],\n incoming_header_ciphertext: [u8; HEADER_SIZE],\n incoming_body_ciphertext: [u8; BODY_SIZE],\n flag: bool,\n) -> pub [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] {\n compute_encrypted_log(\n eph_pk_bytes,\n incoming_header_ciphertext,\n incoming_body_ciphertext,\n flag,\n )\n}\n\nfn compute_encrypted_log(\n eph_pk_bytes: [u8; EPH_PK_SIZE],\n incoming_header_ciphertext: [u8; HEADER_SIZE],\n incoming_body_ciphertext: [u8; BODY_SIZE],\n flag: bool,\n) -> [u8; M] {\n let mut encrypted_bytes = [0; M];\n let mut offset = 0;\n\n // NOTE: Adding a conditional variable can result in the array being fully copied, item by item,\n // in each iteration in the second loop that copies incoming_body_ciphertext into encrypted_bytes.\n // Depending on where we place the `flag` we either get the item-by-item copying (blowup),\n // or just a single array item gets read and a new array constructed in each iteration (no blowup).\n\n // If the `flag` is here then it blows up.\n if flag {\n // eph_pk\n for i in 0..EPH_PK_SIZE {\n encrypted_bytes[offset + i] = eph_pk_bytes[i];\n }\n offset += EPH_PK_SIZE;\n\n // If the `flag` is here then it blows up.\n // if flag {\n\n // incoming_header\n for i in 0..HEADER_SIZE {\n encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n }\n offset += HEADER_SIZE;\n\n // Padding.\n offset += OVERHEAD_PADDING;\n\n // If the `flag` is here then it does not blow up.\n //if flag {\n // incoming_body\n // Then we fill in the rest as the incoming body ciphertext\n let size = M - offset;\n\n // NOTE: This made the bytecode size blowup disappear in aztec packages,\n // but in this reproduction the size seems to be statically known regardless.\n // let size = M - 32 - HEADER_SIZE - OVERHEAD_PADDING;\n\n assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n for i in 0..size {\n encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n }\n }\n\n encrypted_bytes\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_0.snap index 1581780d852..8ed43bd6884 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_0.snap @@ -93,8 +93,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "nZbLbuowEED/Jess/J5xf6VCVQqhihQFlMKVrhD/3hlmJpRFN95wTggcHOxYuXWH8fP69TEtx9N39/Z+6z7XaZ6nr4/5tB8u02mhd2+d4xcs3VvoOwQBCuoD1Qm8IAiiIAmyQCpVKlUqVSreOaVXBmVUUioys7IoQejpfGLScWZSvjCrMDilV1IfmFGZlNRHZlGCknqVWYXRKb0yKKMyKbN0Y1FqL6KyCpNTemVQRqX2UlYWJSh1fEnHl3V8WceXqecdSzRJJtmEmt6zgAmaVJXiTCjseWZKMIkmySSbFBMwQZOqAs7EymBl4DLPMiSTbFJMuMMrAPnDvAQw2zvFhH+dZ5+XsEhV4WUs4k3413nKeDGLJJNsUkzABE2qDCPwyhbxJsEkmiSTbFJMQMVzB1m8STCJJsmEO5WlmIAJmlQVvjdEvEl43EWB744HkzIrixKUqKxCvjvy/d53tpd8XNZx5K3k1+ZCW855WMfl0r0t13nuu3/DfH186Ps8LA9ehpXO0toclwORgsdpHtnu/fPb7u+v0rxW/Tb9yXEL5NeC/7tA1xasELCpEL1dAalvKSAvKSlgwKZCilsBXEuhOrRCDbWhQH+DFSLtgy0FV9NWcKmpAM8xuNx0FRm2ArTMRQzbmowhNo0hha2QYtNclOqtAKFpLgDdVsCmuYC6XQWG0lLA5/+Aua3Ae6uNITfdWfC8s7Dt3szbHoXldTZ3dDTsp/XloezOrXUaPudRD4/XZf/r7OX/2c7YQ915Pe3Hw3UdufR8sqOX95ByH0rZ9R3t9u/genQ7frLiUzH2ISIfej6kSw2Qd3ce2A8=", + "bytecode": "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", + "debug_symbols": "nZbLbuowEED/Jess7PFjxv2VClUphCpSFFAKV7pC/Htn8Ewoi2686TkhcOrEjpVbdxg/r18f03I8fXdv77fuc53mefr6mE/74TKdFv701jn5Q7l7g74jrKCK8kBxFb4CKkJFrEgVtVJqpdRKqRXvnNIrQRmUnArCpMxKrPR8Pgr5OAk5n4WlEpzSK7mPwqCMyqTMSlRyj4SlMjilV4IyKKOSe0WYlagkZan96JReqeOLOr6ovZiUWYlKHV/U8SUdX9LxJe55JxJMokky4ab3ImhCJkUlOxMOe5mZDCbBJJokk2yCJmRSVNCZWBmtjFKWWcZokkyyiXRkBZB8WZYAJftEviOTLgu4CpkUFVnGVbyJ/He59bKYq0STZJJN0IRMSh0GyMqu4k3AJJhEk2SSTVDFu8cKBy8ZEgGTYBJNJFNEsgmakElRkUejijeBx0ME8nA8GJVJmZWoJGWplIcj3e99Z1vJx2UdR9lJfu0tvOOch3VcLt3bcp3nvvs3zNfHl77Pw/LgZVj5LC/NcTkwOXic5lHs3j9/7f7+KU9r0V/zPQ5bIL0W/N8FvjawAlBTIXi7AlbfUiBZUbVAQE2FGLYCupZCcWSFAqWhwLfBCoG3wZaCw2fBpaZCic9CbLqKhFsBW+YiwLYmA4Smq4iwFWJomotcvBUQmuYCyW0FarqTWLarIMgtBZKN0QpNd5Ked5JSbnqy0rbDUC5NBXw+m/S6onZ8NOyn9eWd7C6tdRo+51EPj9dl/+vs5f/Zztg73Xk97cfDdR2l9Hyx4z/vEFMPOe/6jnf7d3Q9uZ28WMmpEHoIJIdeDnmggGl3l4H9AA==", "file_map": { "50": { "source": "// The code below is inspired by [compute_encrypted_log](https://github.com/AztecProtocol/aztec-packages/blob/b42756bc10175fea9eb60544759e9dbe41ae5e76/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr#L111)\n// which resulted in a bytecode size blowup when compiled to ACIR, see https://github.com/noir-lang/noir/issues/6929\n// The issue was around `encrypted_bytes[offset + i]` generating large amounts of gates, as per the `flamegraph.sh` tool in aztec-packages.\n// The details around encryption and addresses have been stripped away, focusing on just copying bytes of equivalent size arrays.\n\n// Original values which resulted in huge bytecode even on this example (500K long SSA)\n// global PRIVATE_LOG_SIZE_IN_FIELDS: u32 = 18;\n// global ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n// global EPH_PK_SIZE: u32 = 32;\n// global HEADER_SIZE: u32 = 48;\n// global OVERHEAD_PADDING: u32 = 15;\n\n// Using the same formulas with smaller numbers; the effect is the same, but the SSA is more manageable.\nglobal PRIVATE_LOG_SIZE_IN_FIELDS: u32 = 4;\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 5;\nglobal EPH_PK_SIZE: u32 = 3;\nglobal HEADER_SIZE: u32 = 2;\nglobal OVERHEAD_PADDING: u32 = 1;\n\n// Unused because encryption didn't play a role:\n// global OVERHEAD_SIZE: u32 = EPH_PK_SIZE + HEADER_SIZE + OVERHEAD_PADDING;\n// global PLAINTEXT_LENGTH_SIZE: u32 = 2;\n// global MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n// ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\nglobal BODY_SIZE: u32 =\n ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - EPH_PK_SIZE - HEADER_SIZE - OVERHEAD_PADDING;\n\nfn main(\n eph_pk_bytes: [u8; EPH_PK_SIZE],\n incoming_header_ciphertext: [u8; HEADER_SIZE],\n incoming_body_ciphertext: [u8; BODY_SIZE],\n flag: bool,\n) -> pub [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] {\n compute_encrypted_log(\n eph_pk_bytes,\n incoming_header_ciphertext,\n incoming_body_ciphertext,\n flag,\n )\n}\n\nfn compute_encrypted_log(\n eph_pk_bytes: [u8; EPH_PK_SIZE],\n incoming_header_ciphertext: [u8; HEADER_SIZE],\n incoming_body_ciphertext: [u8; BODY_SIZE],\n flag: bool,\n) -> [u8; M] {\n let mut encrypted_bytes = [0; M];\n let mut offset = 0;\n\n // NOTE: Adding a conditional variable can result in the array being fully copied, item by item,\n // in each iteration in the second loop that copies incoming_body_ciphertext into encrypted_bytes.\n // Depending on where we place the `flag` we either get the item-by-item copying (blowup),\n // or just a single array item gets read and a new array constructed in each iteration (no blowup).\n\n // If the `flag` is here then it blows up.\n if flag {\n // eph_pk\n for i in 0..EPH_PK_SIZE {\n encrypted_bytes[offset + i] = eph_pk_bytes[i];\n }\n offset += EPH_PK_SIZE;\n\n // If the `flag` is here then it blows up.\n // if flag {\n\n // incoming_header\n for i in 0..HEADER_SIZE {\n encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n }\n offset += HEADER_SIZE;\n\n // Padding.\n offset += OVERHEAD_PADDING;\n\n // If the `flag` is here then it does not blow up.\n //if flag {\n // incoming_body\n // Then we fill in the rest as the incoming body ciphertext\n let size = M - offset;\n\n // NOTE: This made the bytecode size blowup disappear in aztec packages,\n // but in this reproduction the size seems to be statically known regardless.\n // let size = M - 32 - HEADER_SIZE - OVERHEAD_PADDING;\n\n assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n for i in 0..size {\n encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n }\n }\n\n encrypted_bytes\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 1581780d852..8ed43bd6884 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/encrypted_log_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -93,8 +93,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "nZbLbuowEED/Jess/J5xf6VCVQqhihQFlMKVrhD/3hlmJpRFN95wTggcHOxYuXWH8fP69TEtx9N39/Z+6z7XaZ6nr4/5tB8u02mhd2+d4xcs3VvoOwQBCuoD1Qm8IAiiIAmyQCpVKlUqVSreOaVXBmVUUioys7IoQejpfGLScWZSvjCrMDilV1IfmFGZlNRHZlGCknqVWYXRKb0yKKMyKbN0Y1FqL6KyCpNTemVQRqX2UlYWJSh1fEnHl3V8WceXqecdSzRJJtmEmt6zgAmaVJXiTCjseWZKMIkmySSbFBMwQZOqAs7EymBl4DLPMiSTbFJMuMMrAPnDvAQw2zvFhH+dZ5+XsEhV4WUs4k3413nKeDGLJJNsUkzABE2qDCPwyhbxJsEkmiSTbFJMQMVzB1m8STCJJsmEO5WlmIAJmlQVvjdEvEl43EWB744HkzIrixKUqKxCvjvy/d53tpd8XNZx5K3k1+ZCW855WMfl0r0t13nuu3/DfH186Ps8LA9ehpXO0toclwORgsdpHtnu/fPb7u+v0rxW/Tb9yXEL5NeC/7tA1xasELCpEL1dAalvKSAvKSlgwKZCilsBXEuhOrRCDbWhQH+DFSLtgy0FV9NWcKmpAM8xuNx0FRm2ArTMRQzbmowhNo0hha2QYtNclOqtAKFpLgDdVsCmuYC6XQWG0lLA5/+Aua3Ae6uNITfdWfC8s7Dt3szbHoXldTZ3dDTsp/XloezOrXUaPudRD4/XZf/r7OX/2c7YQ915Pe3Hw3UdufR8sqOX95ByH0rZ9R3t9u/genQ7frLiUzH2ISIfej6kSw2Qd3ce2A8=", + "bytecode": "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", + "debug_symbols": "nZbLbuowEED/Jess7PFjxv2VClUphCpSFFAKV7pC/Htn8Ewoi2686TkhcOrEjpVbdxg/r18f03I8fXdv77fuc53mefr6mE/74TKdFv701jn5Q7l7g74jrKCK8kBxFb4CKkJFrEgVtVJqpdRKqRXvnNIrQRmUnArCpMxKrPR8Pgr5OAk5n4WlEpzSK7mPwqCMyqTMSlRyj4SlMjilV4IyKKOSe0WYlagkZan96JReqeOLOr6ovZiUWYlKHV/U8SUdX9LxJe55JxJMokky4ab3ImhCJkUlOxMOe5mZDCbBJJokk2yCJmRSVNCZWBmtjFKWWcZokkyyiXRkBZB8WZYAJftEviOTLgu4CpkUFVnGVbyJ/He59bKYq0STZJJN0IRMSh0GyMqu4k3AJJhEk2SSTVDFu8cKBy8ZEgGTYBJNJFNEsgmakElRkUejijeBx0ME8nA8GJVJmZWoJGWplIcj3e99Z1vJx2UdR9lJfu0tvOOch3VcLt3bcp3nvvs3zNfHl77Pw/LgZVj5LC/NcTkwOXic5lHs3j9/7f7+KU9r0V/zPQ5bIL0W/N8FvjawAlBTIXi7AlbfUiBZUbVAQE2FGLYCupZCcWSFAqWhwLfBCoG3wZaCw2fBpaZCic9CbLqKhFsBW+YiwLYmA4Smq4iwFWJomotcvBUQmuYCyW0FarqTWLarIMgtBZKN0QpNd5Ked5JSbnqy0rbDUC5NBXw+m/S6onZ8NOyn9eWd7C6tdRo+51EPj9dl/+vs5f/Zztg73Xk97cfDdR2l9Hyx4z/vEFMPOe/6jnf7d3Q9uZ28WMmpEHoIJIdeDnmggGl3l4H9AA==", "file_map": { "50": { "source": "// The code below is inspired by [compute_encrypted_log](https://github.com/AztecProtocol/aztec-packages/blob/b42756bc10175fea9eb60544759e9dbe41ae5e76/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr#L111)\n// which resulted in a bytecode size blowup when compiled to ACIR, see https://github.com/noir-lang/noir/issues/6929\n// The issue was around `encrypted_bytes[offset + i]` generating large amounts of gates, as per the `flamegraph.sh` tool in aztec-packages.\n// The details around encryption and addresses have been stripped away, focusing on just copying bytes of equivalent size arrays.\n\n// Original values which resulted in huge bytecode even on this example (500K long SSA)\n// global PRIVATE_LOG_SIZE_IN_FIELDS: u32 = 18;\n// global ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n// global EPH_PK_SIZE: u32 = 32;\n// global HEADER_SIZE: u32 = 48;\n// global OVERHEAD_PADDING: u32 = 15;\n\n// Using the same formulas with smaller numbers; the effect is the same, but the SSA is more manageable.\nglobal PRIVATE_LOG_SIZE_IN_FIELDS: u32 = 4;\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 5;\nglobal EPH_PK_SIZE: u32 = 3;\nglobal HEADER_SIZE: u32 = 2;\nglobal OVERHEAD_PADDING: u32 = 1;\n\n// Unused because encryption didn't play a role:\n// global OVERHEAD_SIZE: u32 = EPH_PK_SIZE + HEADER_SIZE + OVERHEAD_PADDING;\n// global PLAINTEXT_LENGTH_SIZE: u32 = 2;\n// global MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n// ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\nglobal BODY_SIZE: u32 =\n ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - EPH_PK_SIZE - HEADER_SIZE - OVERHEAD_PADDING;\n\nfn main(\n eph_pk_bytes: [u8; EPH_PK_SIZE],\n incoming_header_ciphertext: [u8; HEADER_SIZE],\n incoming_body_ciphertext: [u8; BODY_SIZE],\n flag: bool,\n) -> pub [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] {\n compute_encrypted_log(\n eph_pk_bytes,\n incoming_header_ciphertext,\n incoming_body_ciphertext,\n flag,\n )\n}\n\nfn compute_encrypted_log(\n eph_pk_bytes: [u8; EPH_PK_SIZE],\n incoming_header_ciphertext: [u8; HEADER_SIZE],\n incoming_body_ciphertext: [u8; BODY_SIZE],\n flag: bool,\n) -> [u8; M] {\n let mut encrypted_bytes = [0; M];\n let mut offset = 0;\n\n // NOTE: Adding a conditional variable can result in the array being fully copied, item by item,\n // in each iteration in the second loop that copies incoming_body_ciphertext into encrypted_bytes.\n // Depending on where we place the `flag` we either get the item-by-item copying (blowup),\n // or just a single array item gets read and a new array constructed in each iteration (no blowup).\n\n // If the `flag` is here then it blows up.\n if flag {\n // eph_pk\n for i in 0..EPH_PK_SIZE {\n encrypted_bytes[offset + i] = eph_pk_bytes[i];\n }\n offset += EPH_PK_SIZE;\n\n // If the `flag` is here then it blows up.\n // if flag {\n\n // incoming_header\n for i in 0..HEADER_SIZE {\n encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n }\n offset += HEADER_SIZE;\n\n // Padding.\n offset += OVERHEAD_PADDING;\n\n // If the `flag` is here then it does not blow up.\n //if flag {\n // incoming_body\n // Then we fill in the rest as the incoming body ciphertext\n let size = M - offset;\n\n // NOTE: This made the bytecode size blowup disappear in aztec packages,\n // but in this reproduction the size seems to be statically known regardless.\n // let size = M - 32 - HEADER_SIZE - OVERHEAD_PADDING;\n\n assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n for i in 0..size {\n encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n }\n }\n\n encrypted_bytes\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 3095fd586ba..2ef7a9a8ab2 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -73,7 +73,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "struct Bar {\n inner: [Field; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nstruct FooParent {\n array: [Field; 3],\n foos: [Foo; 4],\n}\n\nfn main(mut x: [Foo; 4], y: pub Field) {\n assert(x[y - 3].a == 1);\n assert(x[y - 3].b == [2, 3, 20]);\n assert(x[y - 2].a == 4);\n assert(x[y - 2].b == [5, 6, 21]);\n assert(x[y - 1].a == 7);\n assert(x[y - 1].b == [8, 9, 22]);\n assert(x[y].a == 10);\n assert(x[y].b == [11, 12, 23]);\n assert(x[y].bar.inner == [109, 110, 111]);\n // Check dynamic array set\n if y != 2 {\n x[y].a = 50;\n } else {\n x[y].a = 100;\n }\n assert(x[3].a == 50);\n\n if y == 2 {\n x[y - 1].b = [50, 51, 52];\n } else {\n x[y - 1].b = [100, 101, 102];\n }\n assert(x[2].b == [100, 101, 102]);\n\n assert(x[y - 3].bar.inner == [100, 101, 102]);\n assert(x[y - 2].bar.inner == [103, 104, 105]);\n assert(x[y - 1].bar.inner == [106, 107, 108]);\n assert(x[y].bar.inner == [109, 110, 111]);\n\n let foo_parent_one = FooParent { array: [0, 1, 2], foos: x };\n let foo_parent_two = FooParent { array: [3, 4, 5], foos: x };\n let mut foo_parents = [foo_parent_one, foo_parent_two];\n\n assert(foo_parents[y - 3].foos[y - 3].b == [2, 3, 20]);\n assert(foo_parents[y - 3].foos[y - 2].b == [5, 6, 21]);\n assert(foo_parents[y - 3].foos[y - 1].b == [100, 101, 102]);\n assert(foo_parents[y - 3].foos[y].b == [11, 12, 23]);\n\n assert(foo_parents[y - 3].foos[y].a == 50);\n\n assert(foo_parents[1].foos[1].b == [5, 6, 21]);\n if y == 2 {\n foo_parents[y - 2].foos[y - 2].b = [10, 9, 8];\n } else {\n foo_parents[y - 2].foos[y - 2].b = [20, 19, 18];\n }\n assert(foo_parents[1].foos[1].b == [20, 19, 18]);\n\n assert(foo_parents[1].foos[1].b[2] == 18);\n if y == 3 {\n foo_parents[y - 2].foos[y - 2].b[y - 1] = 5000;\n } else {\n foo_parents[y - 2].foos[y - 2].b[y - 1] = 1000;\n }\n assert(foo_parents[1].foos[1].b[2] == 5000);\n // Set a dynamic array value\n foo_parents[y - 2].foos[y - 3].b = foo_parents[y - 2].foos[y - 2].b;\n assert(foo_parents[1].foos[0].b == [20, 19, 5000]);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_0.snap index 3095fd586ba..2ef7a9a8ab2 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_0.snap @@ -73,7 +73,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "td3djp3lkYbhc/E2G6uq3vp5cyqjCBniRJYsQA5EGiHOfdb389wNGx5Fy/IOqzKZfu7upi9/De7A7+/+8eGH3/71/cef/vnzv9/97X9+f/fD54+fPn381/effv7x/a8ff/7p+X/9/Y/v3uk/fv/r5w8fnv+nd3/6759v9cv7zx9++vXd33767dOn79795/2n387/p3//8v6n8/XX95+f/+3ju3cffvrH8/U5+M+Pnz4c1x/fvb3148tv6m73G7sXb57//dvb5u37694+1itvv0Zv3/6lt1//z9s/HqWBh8Xbwn/9DgzvwI5XPoChv9dXvX087IW3D0u9fewvvf3+hp/ASN6BerzyAWTw9vaVbz+vvP34/fbr8UVB9i2/BJfrF4Dlr3wJ/entw195+6X3f335M2jzLT8D/DlIyy+9B/74hu9Bpt4+65XPYb59BPPKn8NsfRVnv/LrcJne/7L9yts/mrd/RWGFfhmtfOVXgX7oa7gfr3z+q/QcrHrp8zfq1+Qrb998/PPKc7iTjz9feQy1q9/x2tsXb//K12/z9dv7lV+Fx/T24/Z1b//lr7/ob/gryNTSe9CvfAW/vf3+8jcC61v+Grj5VmL7K19Df3r7/PL3cvEtP4LS2+9+5VehP739/uKvosfT8pt9BPZIfRk8z1d+JTLj24Hn+Yole/um3vyl70ie70K/LeTXLkR/7cKXf03Nb/n1aF5v78N+7aN4Wwj78kfxTb8mw9/eh3zpo/jzQn/x+ZD7m34UW9+i2bJ56aP400J88Slf/i0/ipXG+/DSdyqWfKtlGS99Huqhbzae537pfWi+Hp7fOb+0wN84sMyXfo3Kyrf3IV5aGH6dzP3V78N+6c9mvX0mq1/6c1GL9+G1792tIt4WXnriVL59FC/99ddf3od66c9mbf5sdrz0mezNRzGPl96H4dtwm3jpMzm23hZe+kwOfylns+Jr34f1kotZb5/J9K99H/K1j2LjYj9ecjETbwsv/dncb9/DbPOvfR/spc/D5m8t2H7t+8k/vw/+0kex33613y/9Wv38ZvDBg7fzpYWct4X62oWZlxY8WMj42oX1yp9NtwcLZv21Cy/91cFfFtYXF/Zr30/+/fkf3v/48fNffq/nnT2/9r575+cf4/zjOv+Yz4Hv3tX5xz7/OOcf9/lHe1wvdr349RLXy7pergW7JuzasGvErhW/Vvxa8WvFrxW/Vvxa8WvFrxW/Vvy58vx8xeP8rZSw68Wvl+fK8xMR63rJ66Wul+fK89efmOtlny/rcb3Y9eLXS1wv63rJ66Wul+fK8+t+zfn7EGufL/m4Xo7P6vFJ9Ps17td1v+bxl0DP17pf+36d+3Vfr/W4X+1+9fs17td1vx57z09F1fX39Kvv17lf9/Xaj/vV7le/X4+952em1/2a92vdr32/zv26r9d53K92v/r9eu/NvTf33tx7c+/NvTf33j72np/bbdffmd9+v8b9uq6/X77zfq379fi6OL44537d16s9jq+wdRymw3WEjqUjdZSO1jE69n2Ylk3LpmXTsmnZtGxaNi2blk3LrmXXsmvZtexadi27ll3LrmXXcmg5tBxaDi2HlkPLoeXQcmg5tLy0vLS8tLy0vLS8tLy0vLS8tLy0nFpOLaeWU8up5dRyajm1nFpOLZeWS8ul5dJyabm0XFouLZeWS8ut5dZya7m13FpuLbeWW8ut5dbyaHm0PFoeLY+WR8uj5dHyaHm0vLW8tby1vLW8tby1vLW8tby1vO9ll0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQZdBl0GXQT8N1nG4jtCxdKSO0tE6Rse+j9PgeWh5tDxaHi2PlkfLo+XR8mh5a3lreWt5a3lreWt5a3lreWt538vxeOgwHa4jdCwdqaN0tI7RoWXTsmnZtGxaNi2blk3LpmXTsmnZtexadi27ll3LrmXXsmvZtexaDi2HlkPLoeXQcmg5tBxaDi2HlpeWl5aXlpeWl5aXlpeWl5aXlpeWU8up5dRyajm1nFpOLaeWU8up5dJyabm0XFouLZeWS8ul5dJyabm1LIMhgyGDIYMhgyGDIYMhgyGDIYMhgyGDIYMhgyGDIYMhgyGDIYMhgyGDIYMhgyGDIYMhgyGDIYMhg0sGlwwuGVwyuGRwyeCSwSWDSwaXDC4ZXDK4ZHDJ4JLBJYNLBpcMLhlcMrhkcMngksElg0sGlwwuGVwyuGRwyeCSwSWDSwaXDC4ZXDK4ZHDJ4JLBJYNLBpcMLhlcMrhkcMngksElg0sGlwwuGVwyuGRwyeCSwSWDSwaXDC4ZXDK4ZHCdBs+/yPTjh+COI3QsHamjdLSO0bHv4zB4HaZDy63l1nJrubXcWm4tt5ZHy6Pl0fJoebQ8Wh4tj5ZHy6PlreWt5a3lreWt5a3lreWt5a3lfS/n46HDdLiO0LF0pI7S0TpGh5ZNy6Zl07Jp2bRsWjYtm5ZNy6Zl17Jr2bXsWnYtu5Zdy65l17JrObQcWg4th5ZDy6Hl0HJoObQcWl5aXlpeWl5aXlpeWl5aXlpeWl5aTi2nllPLqeXUcmo5tZxaTi2nlkvLpWUZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBlMGUwZTBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZLBksGSwZrNPgOo7WMTr2fZwGz8N0uI7QsXSkDi2HlkPLoeWl5aXlpeWl5aXlpeWl5aXlpeWl5dRyajm1nFpOLaeWU8up5dRyarm0XFouLZeWS8ul5dJyabm0XFpuLbeWW8ut5dZya7m13FpuLbeWR8uj5dHyaHm0PFoeLY+WR8uj5a3lreWt5a3lreWt5a3lreWt5X0v9+Ohw3S4jtCxdKSO0tE6RoeWTcumZdOyadm0bFo2LZuWTcumZdeya9m17Fp2LbuWZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBlsGWwZbBPg3kcpsN1HMt1HEtH6igdrWN07OuY0+B5mA7XETqWjtRROlrH6NCyadm0bFo2LZuWTcumZdOyadm07Fp2LbuWXcuuZdeya9m17Fp2LZ8G+zhMh+s4lvdxLB2po3S0jtGx7+MwePyA8RwGr8N1xPE/MzmOpSN1lI7WMTr2fRwGjx/8ncPgdbiOYzmPY+lIHaWjdYyOff0c7hwGr8N0+PH7wMcROpaO1FHH/9LkOFrH6Nj3cRi8DtPhOkLH0pE6tNxabi23lkfLo+XR8mh5tDxaHi2PlkfLo+Wt5a3lreWt5a3lreWt5a3lreV9L+/HQ4fpcB2hY+lIHaWjdYwOLZuWTcumZdOyadm0bFo2LZuWTcuuZdeya9m17Fp2LbuWXcuHwTx+s/QweB6HweswHa4jdCwdqaOuHzfeh8HrGB3Hch6/b/vQYTpcR+hYOvL6yd99GLyO1nEsn78RvO/jMHgdpsN1hI5jeR9H6igdffxPg45jdOz7OAxeh+lwHaFj6cjrJ2T3YfA6WsexvI7jWD4+wMPgdZiOY/n4je/D4HUsHanjWD7e58PgdYyOfR+HweswHa4jdCwdqUPLo+XR8mh5a3lreWt5a3lreWt5a3lreWt538vP36N/cBmXcwXX4kqu4mqu4aJhNIyG0TAaRsNoGA2jYTSMhtNwGk7DaTgNp+E0nIbTcBpBI2gEjaBxMG07r+QqruYarq3r/FGY6zIu5wouGovGorFoLBqLRtJIGkkjaSSNpJE0kkbSSBpFo2gUjaJRNIpG0SgaRaNoNI2m0TSaRtNoGk2jaTSNpjE0hsbQGBpDY2gMjaExNIbG5utq83W1+brafF1tvnY3X7ubr93N1+7maxfnhnPDueHccG44N5wbzg3nhnPDueHccG44N5wbzg3nhnPDueHccG44N5wbzg3nhnPDueHccG44N5wbzg3nhnPD+fnjOvdFI2gEjaARNBaNRWPRWDQWjUVj0Vg0Fo1FI2kkjaSRNJJG0kgaSSNpJI2iUTSKRtEoGkWjaBSNolE0mkbTaBpNo2k0jabRNJpG0xgaQ2NoDI2hMTSGxtAYGkMD54Zzw7nh3HBuODecG84N54Zzx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOHecO84d545zx7nj3HHuOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzwHngPHAeOA+cB84D54HzhfPzJ5eOfyKGnT+61Ou8gmtxJVdxNddwbV2H8/syLhpGw2gYDaNhNIyG0XAaTsNpOA2n4TSchtNwGk4jaASNoBE0gkbQCBpBI2gEjUVj0Vg0Fo1FY9FYNBaNRWPRSBpJI2kkjaSRNJJG0kgaSeP86/M6L+NyruBaXMlVXM01XFtX02gaTaNpNI2m0TSaRtNoGkNjaAyNoTE0hsbQGBpDY2hsGpvGprFpbBqbxqaxaWwaW43zh6Puy7icK7gWV3IVV3MNFw2jYTSMhtEwGkYD54nzxHniPHGeOE+cJ84T54nzxHniPHGeOE+cJ84T54nzxHniPHGeOE+cJ84T54nzxHniPHGeOE+cJ84T54nzxHniPHGeOE+cJ84T54nzxHni/PzBqvuiUTSKRtEoGkWjaBSNotE0mkbTaBpNo2k0jabRNJrG0BgaQ2NoDI2hMTSGxtAYGpvGprFpbBqbxqaxaWwam8ZW4/wBrPsyLucKrsWVXMXVXMNFg+d58TwvnufF87x4nhfP88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjgvnBfOC+eF88J54bxwXjhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88Z547xx3jhvnDfOG+eN88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjgfnA/OB+eD88H54HxwPjg/f1jt+Mei2fnTavflXEdjzmtxJdfR2Of1bBz/VGA7f2jtvrauw/l9GZdzBdfiSq7iomE0jIbTcBpOw2k4DafhNJyG03AaQSNoBI2gETSCRtAIGkEjaCwai8aisWgsGovGorFoLBqLRtJIGkkjaSSNpJE0kkbSSBpFo2gUjaJRNIpG0SgaRaNoNI2m0TSaRtNoGk2jaTSNpjE0hsbQGBpDY2gMjaExNIbGprFpbBqbxqaxaWwam8amse+Gnz8Pd1/G5VzBtbiSq7iaa7hoGA2jYTSMhtEwGkbDaBgNo+E0nIbTcBpOw2mczs9/RNTp/LqGa+s6nV+XcTlXcC2u5KIRNIJG0Fg0Fo1FY9E4ncd5JVdxNddwHY11XKfz6zIu5wouPo7k40g+juTjSD6O5OMoPo7i4yg+juLjKBpFo2gUjaJRNJpG02gaTaNpNI2m0TSaRtMYGkNjaAyNoTE0hsbQGBpDY9PYNDaNTWPT2DQ2jU1j09hqnD8Pd1/G5VzyYTg3nBvODeeGc8O54dxwbjg3nBvODeeGc8O54dxwbjg3nBvODeeGc8O5OQ2n4TScRtAIGkEjaASNoBE0gkbQCBqLxqKxaCwai8aisWgsGovGopE0kkbSSBpJI2kkjaSRNJJG0SgaRaNoFI2iUTSKRtEoGk2jaTSNptE0mkbTaBpNo2kMjaExNIbG0BgaQ2NoDI2hsWlsGpvGprFpbBqbxqaxafA8d57nzvPceZ47zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zh3njnPHuePcce44d5w7zgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeA8cB44D5wHzgPngfPAeeB84XzhfOF84fz8ebjJ8zoadV7F1VzDtXWdzq/LuJwruBYXDaNhNIyG0XAaTsNpOA2n4TSchtNwGk4jaASNoBE0gkbQCBpBI2gEjUVj0Vg0Fo1FY9FYNBaNRWPRSBpJI2kkjaSRNJJG0kgaSaNoFI2iUTSKRtEoGkWjaBSNptE0mkbTaBpNo2k0jabRNIbG0BgaQ2NoDI2hMTSGxtDYNDaNTWPT2DQ2jU1j09g0thrnz8Pdl3E5V3AtruQqruYaLho4T5wnzhPnifPEeeI8cZ44T5wnzhPnifPEeeI8cZ44P38e7viXyvr583D3tXWdzq/LuJwruBZXchUXjaARNBaNRWPRWDQWjdP5Pq86/gV059Vcw7V1nf8A9+uikTSSRtJIPo7k40g+juTjSD6O4uMoGkWjaBSNolE0ikbRKBpNo2k0jabRNJpG02gaTaNpDI2hMTSGxtAYGkNjaAyNobFpbBqbxqaxaWwam8amsWlsNQrnhfPCeeG8cF44L5wXzgvnhfPCeeG8cF44L5wXzgvnhfPCeeG8cF44L5wXzgvnhfPCefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8L57nxfO8eJ4Xz/PieV48z4vnefE8b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPGeeO8cd44b5w3zhvnjfPB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD44H5wPzgfng/PB+eB8cD443zjfOD9/Hm7becXxL/w+r2djx3klV3E113BtXYfz+zIu5wouGkbDaBgNo2E0nIbTcBpOw2k4DafhNJyG0wgaQSNoBI2gETSCRtAIGkFj0Vg0Fo1FY9FYNBaNRWPRWDSSRtJIGkkjaSSNpJE0kkbSKBpFo2gUjaJRNIpG0SgaRaNpNI2m0TSaRtNoGk2jaTSNoTE0hsbQGBpDY2gMjaExNDaNTWPT2DQ2jU1j09g0No19N+L8ebj7Mi7nCq7FlVzF1VzDRcNoGA2jYTSMhtEwGkbDaBgNp+E0nIbTcBqn83VexdVcw7V1nc6vy7ic62jkeS2u5Cqu5hquret0fl3G5Vw0Fo1FY9FYNBaNRSNpJI2kkTSSRtJIGkkjaSSNolE0ikbRKBpF43Re59Vcw7V1nc6vy7icK7gWV3LRaBpNo2kMjaExNIbG0BgaQ2NoDI2hsWlsGpvGprFpbBqbxqaxaWw1zp+Huy/jcq7gWlzJVVzNNVw0jIbRMBpGw2gYDaNhNIyG0XAaTsNpOA2n4TSchtNwGk4jaASNoBE0gkbQCBpBI2gEjUVj0Vg0Fo1FY9FYNBaNRWPROJ33eRmXcwXX4kqu4mqu4dq6ikbRKBpFo2gUjaJRNIpG0WgaTaNpNI2m0TSaRtNoGk1jaAyNoTE0hsbQGBpDY2gMjU1j09g0No1NY9PYNDaNTWOrcf483H0Zl3MF1+JKruJqruGiYTSMxul8n1dwHY3j34r/n/efP77/4dOHf7/72+/HvzX5t59+1L8j+fkff/3fX/Tf/PD546dPH//1/S+ff/7xwz9++/zh+Pcpn//dH3//4/8A", + "debug_symbols": "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", "file_map": { "50": { "source": "struct Bar {\n inner: [Field; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nstruct FooParent {\n array: [Field; 3],\n foos: [Foo; 4],\n}\n\nfn main(mut x: [Foo; 4], y: pub Field) {\n assert(x[y - 3].a == 1);\n assert(x[y - 3].b == [2, 3, 20]);\n assert(x[y - 2].a == 4);\n assert(x[y - 2].b == [5, 6, 21]);\n assert(x[y - 1].a == 7);\n assert(x[y - 1].b == [8, 9, 22]);\n assert(x[y].a == 10);\n assert(x[y].b == [11, 12, 23]);\n assert(x[y].bar.inner == [109, 110, 111]);\n // Check dynamic array set\n if y != 2 {\n x[y].a = 50;\n } else {\n x[y].a = 100;\n }\n assert(x[3].a == 50);\n\n if y == 2 {\n x[y - 1].b = [50, 51, 52];\n } else {\n x[y - 1].b = [100, 101, 102];\n }\n assert(x[2].b == [100, 101, 102]);\n\n assert(x[y - 3].bar.inner == [100, 101, 102]);\n assert(x[y - 2].bar.inner == [103, 104, 105]);\n assert(x[y - 1].bar.inner == [106, 107, 108]);\n assert(x[y].bar.inner == [109, 110, 111]);\n\n let foo_parent_one = FooParent { array: [0, 1, 2], foos: x };\n let foo_parent_two = FooParent { array: [3, 4, 5], foos: x };\n let mut foo_parents = [foo_parent_one, foo_parent_two];\n\n assert(foo_parents[y - 3].foos[y - 3].b == [2, 3, 20]);\n assert(foo_parents[y - 3].foos[y - 2].b == [5, 6, 21]);\n assert(foo_parents[y - 3].foos[y - 1].b == [100, 101, 102]);\n assert(foo_parents[y - 3].foos[y].b == [11, 12, 23]);\n\n assert(foo_parents[y - 3].foos[y].a == 50);\n\n assert(foo_parents[1].foos[1].b == [5, 6, 21]);\n if y == 2 {\n foo_parents[y - 2].foos[y - 2].b = [10, 9, 8];\n } else {\n foo_parents[y - 2].foos[y - 2].b = [20, 19, 18];\n }\n assert(foo_parents[1].foos[1].b == [20, 19, 18]);\n\n assert(foo_parents[1].foos[1].b[2] == 18);\n if y == 3 {\n foo_parents[y - 2].foos[y - 2].b[y - 1] = 5000;\n } else {\n foo_parents[y - 2].foos[y - 2].b[y - 1] = 1000;\n }\n assert(foo_parents[1].foos[1].b[2] == 5000);\n // Set a dynamic array value\n foo_parents[y - 2].foos[y - 3].b = foo_parents[y - 2].foos[y - 2].b;\n assert(foo_parents[1].foos[0].b == [20, 19, 5000]);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 3095fd586ba..2ef7a9a8ab2 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -73,7 +73,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "struct Bar {\n inner: [Field; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nstruct FooParent {\n array: [Field; 3],\n foos: [Foo; 4],\n}\n\nfn main(mut x: [Foo; 4], y: pub Field) {\n assert(x[y - 3].a == 1);\n assert(x[y - 3].b == [2, 3, 20]);\n assert(x[y - 2].a == 4);\n assert(x[y - 2].b == [5, 6, 21]);\n assert(x[y - 1].a == 7);\n assert(x[y - 1].b == [8, 9, 22]);\n assert(x[y].a == 10);\n assert(x[y].b == [11, 12, 23]);\n assert(x[y].bar.inner == [109, 110, 111]);\n // Check dynamic array set\n if y != 2 {\n x[y].a = 50;\n } else {\n x[y].a = 100;\n }\n assert(x[3].a == 50);\n\n if y == 2 {\n x[y - 1].b = [50, 51, 52];\n } else {\n x[y - 1].b = [100, 101, 102];\n }\n assert(x[2].b == [100, 101, 102]);\n\n assert(x[y - 3].bar.inner == [100, 101, 102]);\n assert(x[y - 2].bar.inner == [103, 104, 105]);\n assert(x[y - 1].bar.inner == [106, 107, 108]);\n assert(x[y].bar.inner == [109, 110, 111]);\n\n let foo_parent_one = FooParent { array: [0, 1, 2], foos: x };\n let foo_parent_two = FooParent { array: [3, 4, 5], foos: x };\n let mut foo_parents = [foo_parent_one, foo_parent_two];\n\n assert(foo_parents[y - 3].foos[y - 3].b == [2, 3, 20]);\n assert(foo_parents[y - 3].foos[y - 2].b == [5, 6, 21]);\n assert(foo_parents[y - 3].foos[y - 1].b == [100, 101, 102]);\n assert(foo_parents[y - 3].foos[y].b == [11, 12, 23]);\n\n assert(foo_parents[y - 3].foos[y].a == 50);\n\n assert(foo_parents[1].foos[1].b == [5, 6, 21]);\n if y == 2 {\n foo_parents[y - 2].foos[y - 2].b = [10, 9, 8];\n } else {\n foo_parents[y - 2].foos[y - 2].b = [20, 19, 18];\n }\n assert(foo_parents[1].foos[1].b == [20, 19, 18]);\n\n assert(foo_parents[1].foos[1].b[2] == 18);\n if y == 3 {\n foo_parents[y - 2].foos[y - 2].b[y - 1] = 5000;\n } else {\n foo_parents[y - 2].foos[y - 2].b[y - 1] = 1000;\n }\n assert(foo_parents[1].foos[1].b[2] == 5000);\n // Set a dynamic array value\n foo_parents[y - 2].foos[y - 3].b = foo_parents[y - 2].foos[y - 2].b;\n assert(foo_parents[1].foos[0].b == [20, 19, 5000]);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 4bc7c35ee3c..c39d463803c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -81,7 +81,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_0.snap index 4bc7c35ee3c..c39d463803c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_0.snap @@ -81,7 +81,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1dXYhkSVaOzKpbVZndVZXdXd3TP9PTVT39P9O9VZ311z09MzUz1bOzqw+KoCIiVHdPgwgr8yIsrJCyC4KiiE/ik+DPgrL6sOyTPyiuD7IgDoIwL6KL7A6srCALysKCe7vvyfryyy9P3rsVkVnJVECRt27EPeeLL07EORH33ri18Dy9+MO/WnE8XfzWi99akY/Jyu4Uv6sHS2sRZa2mwlibAIz1CcA4NQEYpycAYzYBGGcmAOPsBGCcmwCMjQnA2JwAjMcmAOPxCcA4PwEYFyYA4+IEYGxNAMYTE4Dx5ARgPDUBGJcmAOPpCcB4ZgIwvjABGM9OAMZzE4Dx/ARgvJAAYwqcLybC2bNYlYPOF0XyRYd8Up9PmvNJaT7pyydV+aQlnxTkQXce1OZBYx6U5UFPHlTkTjt3irnTyQf1fNDMB6W80+edKjfa3CguAEG8WIbkXZ19/tso/q9DfsSFkbUG6Y0pf3t1s90Q9YuI/5l8kxlf/toTkz+dBv9q0czh3U6v/EB6DUeadlrfTFzPx/NUtwB1Md1ZGt1PaqQvEMeB9DdDSpt6vkCM+gwP81MnfmbT4Fk1+XOJ5Ft9G6K+yL/Vb7H4fwbycJwaJAvtx+rSEtfPjIbXtcS8rlXl1fAcS4OnbX28CXi4jx9Po3u9bB83/U3Cmqptjof+tkF+rI/PW5nOPp4G5U13+utheRnkWfvmdvdHUD/MQzxev0FbMdyJ+8164n5z96jfdNNRv4G8Ce83W4n7TfsT6se3E/O6fjQe9XKB+oyLEI7GIzs/IePRo8T9ZuOo33TTUb+BvAnvN+8n7jebn1A//jQxr1tH41E3HY1HkDfZ49Ha3cT9Zvuo33TTUb+BvAnvNxuJ+829T6YfX9tMzOve0XjUTUfjEeRN+Hh0L3G/eXTUb7rpqN9AXup+Mx/6bWyK8uqg51FnH89fALavFsdpn7XY7D6zkuiZntVTAj/qytNsJ/Tw/uwXzln7WXvOYXnKa0DedKdXT7P4fxr0oCzDkVH5Py/+Xyx+Z+Aau74l9M+Q/h7c4hzz0hDlG6J8Hut8uTjObdL6xjudXnk7xe/qwVL3Oa1dkJ/iObCHaeS3c47yPvbNIkj0ngcqM3ZiW7RIFto+P9cUsU3apisjvWhT04CfY29+3inxc1Dd+0zmf7MhuDIq/zfFb96OH8/01tnK1IXMPKFdDYsRTA6Wb4ryOPfgOQ7GOM0wXPcsnNvt9JY/VhGr8rHotxqEFfHZtYljo7seVow/j1Hd5kM1LhZE+XlR30Whe4Hy8DqOmRfS8NR9ds380DTUA3XOQ/2xPB7nKaNzHxa/ub1+h/rUvMOd6cpTK/Tb0bzDHcffi4m5awnuFh3uWpBnx8idnfsoxONuVuBpiOt24nCzxvWzus0JHFzvfyd8J+CamO13EuQG0uWNs43Q344p7MqwoF2hTsNWFzzZMfJr575V/Cq7moPrpsQ5r0/OOdxxn0zVplaPk4K7Ew53aAt2jNzZue+GeNzNCjy8RhLicdN3nyOe7LX1ecFdjep0Cs6PYy3C9DdDf5unWIs4RXiYH1yLyPOWBNaWyEO7wTzUsyT0KFnTEWWxDWNezPsOxtfp0J8s7wzo5nWUFyCPfUCg+mPCOuV1/S7M9bgc40HbN2wZ5c0VFzZC/9ia2u/xGiLPKTDunQV+uG6MuUbnswHX8Zys22YFSDUnszJ1ITNPDzu95dFeysT2Z0T506Ku5u/Q3s+E4bqR891Ob/kXKmI9K8qjnZ8mrIjvbBiuG9v1WAndHtZzojxieIGwou5zlIfXWZ0aVDZVjHG+kIcxBuo8C/XH8nicp4zOXQKb5xjjrMOd6cpTKwxuZ8Udx7bnE3N3QXB33uHuAuTZMXJn565H5K4p8DTEdTtxuFnn+lndlgQOrvcd8h0vwjWpfYfp8sbBRuhvxxR2ZVjQrlCnYasLnvB95YzOrTt2VTVmOiPwKO64T6ZqU6vHxdDP3YsOdxchz46ROzv3ICJ3TYGH46UQj5uNhsAUSXb3OY+L0WXvx8gvgewa8XUJzo9jPmb6m4Q1Mp7ufOwS4WF+eD62LLC2RB7HystCz7LQo2QtRZRldsV2FpfftafzoZ9fS4rLM5S3AnloA5zUfMzqVHU+hjwvF8fsb3+GfCqO26l96hnCz3aBMXX3WYYw2L/UQm9svgR1VtdlAzj5eRjLPx4wlteFzDw97PSWV/0R24rnDcui/CVRV/OlaO/LYbhuHON3O73lVypivSzKo51fIqzLkHc5DNeN7XqshG4P68uiPGJYIayo+2XKw+uWi+MGlY3df6weVwp5GL+gzstQfyyPx3nK6NznwOY5frnscGe68qTG58sOdxzbXEnM3dXQz90Vh7urkGfHyJ2d+5WI3C0JPA1x3U4cbra4fhzXol6u96+S77gG16T2HabLGweZt1HaFeo0bFXt6ouOXWE8PSXOlYmZFHfcJ68m5u6a4O6qwx3amB0jd3buNyNytyTwJJwzbaebM63e474aT/bapsWd10F2jfi6AefHMR8z/U3CGhlPdz52g/AwPzwfuymwtkQex8o3hZ6bQo+SdTGiLLOrtO199968wGXJ8m6B7mXKewXy0AY4qfmY1anqfAzHLsPG49afkE9dhmtS+9RlqDPrrhMOHr+zAddlA+r5pzA+8xzLytSDXg942Oktj/2pzFzA65MqtliGvBthuG4cW3c7veVvVsR6S5TH/nadsCK+W2G4brRJnmO9UhHrq6I89rObhBXxvUp5eJ3VqUFlU8Uktwt5GJOgzleg/lgej/OU0bm/cmKSVxzuTFeeWqG/nV9xuLtF3N1OzN2d0M/dbYe7O5Bnx8idnft6RO5uCTwNcd1OHG72uH5Wt2WBg+v9DfIHn4JrUvsD0+WNg43Q344p7MqwoF2hTsNWFzzZMfJr5z507GoZriuzLn1D4FHccZ9M1aZWj9XQz92nwmDuViFvVXBn5z6KyJ2K1Rriup0QhZvuvkar8WU/Ntlr0WWvbVkseRdk14ivNpwfxxzL9DcJa2Q83TlWm/AwPzzHWhdYWyJvGY4xD/WsCz1K1mpEWWZXDSE7Hr/t7ru3yK8lxeUNytuAPLQBTmqOZXWqOsdahjzDxv72e+RT0/CnfarpKuNTU+EyGzQ7Qr+AOg1bncrz2JbRue8fAp+6lpi7tuBuLQzmDsfktuDOztXr8bgbrU/dfML+J6Ls7n5q6/FlP+XxyjhDvjbh/Dh8qulvhv6xNYVP3SQ8zA/71C2BtSXyluEY81DPltCjZLUjyjK7ShtDtbtr5MivJcXlLcrbhjy0AU7Kp1qdDuJTDRv71IsFuYljUOlT24R/mTDiOhW/V6JiR1zT2+301ivB+LPOY0w82e273E73CzLy5n+5OFb7hOD4l6dpyIvYnk9yW1yc3ceRy8f3jTPChO/hTonyvCbZEuXxvVVb/2xReWwPxc/CGPmpVeSndgB+rjv8YLzP/HxS7Kft8HOL8tCvm868H/7kUT90+6GNuUf98KgfDuInZj9cDL3c4TWJ96rY8+pbE7gXBRet0WDt7hV3oiJWbJsTo8H62DCdq4gV36fn9/Jqo+d8lesxaC8Tw1an8sxBRuf2nPWHWhjMnekKQffBmsMd20DqPScUd60I3P1iRO5OCDz8P+9Dkx9vUp6V/WWan41jvxGPC3xWfbfTixV9xU4UnJsbzENE2d05PtoK+uH8ONG7p6XXk0x/M/TbeIr1pPOEh/nh9aQLAmtL5OH9B8xDPReEHiVrMaIs3mMHZVu9R7VPjHqH+4Sodz3026b3DvcXnfFOxXeLDnfnBB5eu/hDWLv4dYrV0Pcxv+PeG2sB6sy+xtsb67ccftWebCp+VvxyjMOxCuo5UVKP18/R1lZIN3Jh1x62eV7PPlOd8vVV/KgxBfsbv4OJY8o5hx+MoUbNz0JFfhYOwE/N4adFeYPmeV+nWAjx7IQYPLXb6WKXdncfKhw7OL5I5FNKxxemvxn6+3mK+EKNU8gPxxfnBdaWyMP7foPs+bzQo2QtRJRldnUYxnD0dUdjuD+Gtxx+DusYrtaiqtqPml97dl12DC+zVjdFeTvF/6sHS91vHnlrvahf9dXF0WC957Wlh1WtKy6GwW1zWPYNNWz10D9+efuGfujE3FOCOzzH47UakxV3bAPjng8yd2Xngx9F5I7nbMhPmvlce4ufv8Cknr9YoLx7kIfzLU5T9D/WqeqzGWhHhi2jvG8NiHdj25da++OYR81bsV7sS7z7RLXQvw+76ldlxmmlW/kxlMn7niOu85Tn2fO496Hj9Z+y+9D9T8T1H9VuZfxM6rUdxZ1qy6rcfT+xn0m7F914x0qrU4qxcrY4mMSxUs1LUCbvj4p8XCghy9P9oiiPMnm/U8TFeyuyzeZpVPsDXi7kDdof8ALUH8vjcZ4yOneqqIjq71XvM6h2KzNWpt6XUnGn2rIqdxcc7mKOlXjdThRuNrfS7d2zuc17TkWU3d1fAfeMqhFfifaGKb3GaPqbhDUynu4a41XCw/zwGuMNgVW918LrdWp/ghtCj5J1OaIss6uGkH1YYwm0AU4qlrA6pYglNic4lrgsyqNM3tsP+bhcQpan+2VRHmWukG7E9TLlsc3micfNVP4w1V59bzv+8LLDnenKk4olLhN3XiyRZizwuVNtWZW7z05uLLHH+yRGlP2IfXpE2Y/ZHxpnyNct4jKO7vKxhOlvBu2fd+Lg6cYSal8f5ZeNu1cF1pbI41hC7cnzqtCjZF2JKMvsqiFkH9ZYAm2Ak4olrE4pYon3JziWuCLKo0zewwr5uFJClqfbi9nz45ukG3FdpTy22Twlngt1/aHZ4qB9Mq9A/dl2cVzJ6NwHjj+84nBnuvKkYokrxJ0XS6Te91dxp9qyKnefTxxLKO42iLtEfmqV/RRyd8PhDv34LcGdnfu1iNzxu/DIT5q4Iq6fqfoet9UphZ/57UPgZ9LF0Kur6nmXGuk9bLFoojZwY1H1fM84Y9H5iLL4O+OMM0/8jdJU46vVC8dX1mn1YR6wz2d07g8ijq81gWdeXMfczafhrnQ/Mv3N0N/OKfrRfEle1f7E88Q55vH3S1V/vSX0KFlnI8rqfr+S/rf8PCW2hY0f1RYSfXfUtYWm4NW4OyuwtkQez8Wqfu+P2z+WrKkEuIwb5LI24Nf08DnWg3bI37QybnEv6xkocwzysfzfwlj78YD3dOpDZHq8Kbvx+q+yl0Wh+1YJ3RgH7HaG6/awKp+txiY1F+f9obGOVqfE8dsq12N6SD3qVJ45yOjcPzk+u2p/mhF4FHccc497b23mruze2v8akbsFgacmMHixspW/I8pjnfj5RdR3p4QsT/enRHmUyc8vIi7e+xmv4+/E4l7CKWxmtZA3aP/iO1B/LI/HeeL9i//TsZk7DnemK0/Kf91xuLtN3I17j0/mruwen/8VkbvbDneYd5K4uzMG7lRbVuXuew53any57XB3UuBJuwdq9bWvs5SHa1+8DhSo/piwTlXXvtCOeO2rm1dMtBoCW+q1Lzu3KHRzfHM2ES7PR58VWKv66NmCX2X3J+G6KXHOi2887ji+uZ2YOzVm3Ha4KztmLEbkbkHgqQkMZWIMtX8m1omfOUZ97RKyPN1qD3WUyc8cI651ysPr2M/gHiMpbMbW/9Fm1B71dSqPx3nK6NxFx2baDnemK0/Kz7Qd7nhv+kT7FHe52xLcbTjc4d66W4I7O3c1IndrDneY9xJxl2oPXY871ZZVubvtcKfGlzWHu5cEnobAEzG+2eYYBpMXw1jefcir+q1vq1PV+AbtyLCxD7k/IfFN6r37ld2vCaxV7X7nEMQ3afrEPnfbgrsthzucB2wL7uzceyOKb7aFLC/GuCfKY534OWjUdy+x7hXSfUnoXqSyiLEhZKawGcMyPaQe9dDPG3KQ0bmfdmxmJfRzh+e8+GbF4e4ScXcvMXf3BXf3HO7Q99gxcmfnfiEid5cEnkbo5y6ij95jX4vJ8l4D3eyjH0Be1fdPrU5VfTTyZNgyyvulCfHRifaL7Nq98YF2f05grQtucS9R5veDQ+CjLyXmbkVwd8nhDvvoiuDOzn1+RD5ajT+en7wvymOdrhXHqm3uk6xrEXTjN3X52eYVR/f1CLrxO8b8bPM1oXtRXMdjOH5veFQ+Tn3juKqP+w3HXq873JmuPLVCf7tdd7jj75/fT8zda4K7+w536BPtGLmzc78bkbtrJbm7G3q5ey0xdw8Ed6853GHMYMfInZ37/Yjc3RV4GgJPxNjqicUrr4f+ZHlvgO4VynsT8qp+99HqVDW2QjsybBnlfZliq0TfJZWxlelSds+xVSpcnt0rO6tq91+JaPczAo96holjq+tj4E61ZVXuvuZwNxP6uZtxuFsQeBR3K6GXu9TfrFDcLUTg7q8jcrdSkjv28ytj4G4lAnf/EJG7awIP/2/6cYzkb1ZY2W/QeI3yU4/XPGeYId2IK9UcvUZYsO3V3LwueML5TEbnPozY9lMCT5n3K2bGwJ1qy6rcfeRwNyW4m3K4qwk8ifeD3TC96juvCo+aQ24S1kTfyN00TK8PwbpJWHEMfJ3yVF9vUNlUNmnxKdok6jRsdSqPx3nK6Ny3HZushcHcma48qbG85nD3gLh7IzF3bwru3giDucO5iB0jd3buvyNy9yCU447v96eZz/ncPYjA3f9G5O4lgach8MTjZ737TuhO6E+W9xbovkZ5b0Ne1fv9Vqeq8120I8PG3/yazp7/NgS21PETt2MNMJodnIIy/B6MXV8vWd7yApQ/Ded2O71coG/ficLDWpvtNKLsu8pGuX+gjUZs39LvW5r+JmGNjKf7jt1bhIf5sbFF9VO7tiXy5uAY81DP20KPknUtoqw3SZaq/0twbrczXLdX/p2K5Xcrln9Ysfy7Fct/umL59yqW/0zJ8vwds3eLcTkf7i8Vx2qeuVMcj+pddFuLGfQuOs8zce2m5/shdO5qUccY88wdgYf93k3QN+h9TNTnvbM4bP/5t4pj1X5l9p+fcXQP++axt6ey950ZXG/O0zTkRbQr+Z0Z5CDrlK+v4sf75hP6f/VN1Z2wj4v5we9xjJqfmYr8zByAn1MOP7hfDfPTHA0/G+P+pvjbxA9yN0N5+F45fqfog6wXP6+L5inx+F46fjP9zdA/lqWI32YJzyB75rbHa9U9j1fgeNCY730rE2VdjChrqThmf/VTjr9SHHkxieoDnn8b1gd4rxzlYzxZXv8bNj6xf0Ncdu1h+85cz/dcO+Xrq/hRz1ThGM3+Td0TUPzgt+pHzY/n31Tfqurf0D49/7bo8PNJ8W88hh7Ev6n4l/fsago82L4PO72y0B8O2qtFycqPC1hdWU2BX2E2naO6J27tUfaeOLZfTyxN574Qcc6l5oCKO+w3jDUFd8O+u83clf3u9pcictcUeLz+yftShaC5Zt97YogsvjeG1/O36k8IzKO6120x0qB73YatTuXxOE8Znfsdp00Vd+r7r+rZJI879LOMNQV3ZwV3Sw53+E7/WcGdnfu9iNwpu0u7r8F6912Rz4b+ZHk/BrpnKO/HIW8Hjjmp+ztWp6r3d9CODBt/q/SP6f5Oqn0h1P0d3lMK8bIPTb1fhb0XMmi/CrZ7fI/EjpFfO/dnEe1+VuDx4pxRfQtWcafasip3X3W4U3PaWYe7psCjuGNflWiPR5e7ZgTu/jIidzMluWNflfr9LvUN4nMOd2W/Qfz3EblrCTxe7FZ2LoPX4nWZKPsm5XWfjaSxH7GmHvuH4cd5KO9dW4eyxtuZ0M9bg64Pkeq01t7eZi5/APfj/rnEfJbX7/7FWb8bNuflObt3fyo/tnumyq7KfKdj1tE97F4X7+WDuMrc6/J0x7jXxfb3b6JdGlQmTzvF7+pBUvv97TGuJa2P+16b9WG11obr+MwPxooJ+ZFrkXWHH9Vv6w4/w+byvFaL3HlrkfUx8jNbkZ+qYwvyw2u12Pe9e5Ejupe9kdp+ho3774Zefrx7Ybjuanpynm4WZFXxbVZoFL7tndCL78i3DfZtx0S7HDb/4/UPxWHV8RU5ZP+D46vFkIfN/zQr8nOQ+7ie//H884jsp7J/VnM5z368Pjup/iemfx42Nu8SPzhG8bwZ/Y/pVP4HMfC9wmHt+7DTK0utc5Txxfkx3ytU63HKL/B607jvFRq2qvcK18GXfKeEj1fjkFpvYu68+6yp1+oUd6otq3L3wOEuxn3WsuOXd6+wSvySH/O9wikhq8z667jv//IaYtn7v+85bZpq/XWKuEu1nmf1OCG4aznc4Xz+hODOzv1ERO6mBB5Plrf+qmQFui4TZacpz8r+LK0npXo2X62/zhImy/s5Z642Jfjy4iU1diEv9gyieq9xpoQsT7fXtvnxp0m3atvFAVjyNKr3KVQf896nKNvHnkb0OardVJvy+JTo2WCXO9WWVbn7nMNdLfRzV3O4mxJ4agID9x+UZeXLPuup2uZkCVmebvXuJMrk9QnEdYryFCejenbIsAx6dmgK6o/lmYOMzn3BsRk1riquvb0eFHf8bMypxNyp565OhcHclX3u6ksRueNnIVCW6m+ej1kS5VG+vQuo2maphCyvv50W5VEmf5dLjQNqLQLH6DxNU95OcX71YEmu1RjmPGWd4fwcPwA/Vr8Wlef+hf+jrAac2+3s1+NZmc7+9YZxHHyi/TCfDVEnz96WHA6Qo1bo59p7z2JE96bk2letIj/Kj9v540P4+Uzo5ed46K0n5vE6Fh5PDcH1sPP8V62P8Xjn1TH/5TUtvJ6/OYjXYZuinFR+p2s7UI+M6hrCvt9piHqEsO937NxXIsZ5bC+DuOMYuT4G7uoRuPvaiGJkbxzLj22PD8U1j1/HHFl54r7VcPR4MSzuO5KiTW1swTZlnXmqh/6xqMcH07m/G0MM2yDujifmbl5wd9zhDsfqecGdnfvHiNw1BB7l89nuGmm4K/1usOlvhv52johnrczYgLzyN8LxWuWTeW8X9Z32eaFHyboWUZatMzYEznj8rq0bXxgTWrI8FU9b3hnCFUKv7WD9MWGdqr4Lgc+QGraM8v6D1mN5jNop/l89YFLrsXZ8LKSNhbe2n491z/jt7PPAXKP+jMp/u+AJ730F4HLnR8T5dGtv7Wl77+next6TJ+uP99R3XbvPriTQ/3hj89Hj9Y291ffX8n/vjlr/3lZ7+/Hd9cdbjzbae+3NofXP+8A3oQ+gLTMuljPlyG4JWe90nv+aj1bx9ajWdW39e9C6bgb1wfJ4HEL/s/L/5/joLPRyx+e8+CYjflLNhzgGQF15dX4woE74HL2KdzMqX5/dl2nkqfja7OdY0HbDz/WrezbKPu38nChf9n72XAlZ3tqfii3mHN2IC6/F6zKBk+9Zzgg8mZDFfZjlDrJpbP/dzvPfsnZl981nOiC3s39NnmaL/6dBHpa3emVU/hTY3GlYx3lWVujLy11xylUdG6c7vecanf7yU53+8qa72enHaHnHIC8jPceL/5EvlGU4Miq/Av0yT3NwjV3fEvrnSH8PbnEO7ZBlTYlz+Czx+QKj+VGse+z5wDOdJB/PMTaznXzs+n/PIT9H9UYBAA==", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index d19f260b243..6956571fbf6 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_dynamic/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -81,7 +81,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index a19afe4e46f..6c62469980c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -24,7 +24,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "struct Bar {\n inner: [Field; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nfn main(y: Field) {\n let foo_one = Foo { a: 1, b: [2, 3, 20], bar: Bar { inner: [100, 101, 102] } };\n let foo_two = Foo { a: 4, b: [5, 6, 21], bar: Bar { inner: [103, 104, 105] } };\n let foo_three = Foo { a: 7, b: [8, 9, 22], bar: Bar { inner: [106, 107, 108] } };\n let foo_four = Foo { a: 10, b: [11, 12, 23], bar: Bar { inner: [109, 110, 111] } };\n let mut x = &[foo_one];\n x = x.push_back(foo_two);\n x = x.push_back(foo_three);\n x = x.push_back(foo_four);\n\n assert(x[y - 3].a == 1);\n assert(x[y - 3].b == [2, 3, 20]);\n assert(x[y - 2].a == 4);\n assert(x[y - 2].b == [5, 6, 21]);\n assert(x[y - 1].a == 7);\n assert(x[y - 1].b == [8, 9, 22]);\n assert(x[y].a == 10);\n assert(x[y].b == [11, 12, 23]);\n assert(x[y].bar.inner == [109, 110, 111]);\n\n if y != 2 {\n x[y - 2].a = 50;\n } else {\n x[y - 2].a = 100;\n }\n assert(x[y - 2].a == 50);\n\n if y == 2 {\n x[y - 1].b = [50, 51, 52];\n } else {\n x[y - 1].b = [100, 101, 102];\n }\n assert(x[2].b == [100, 101, 102]);\n\n assert(x[y - 3].bar.inner == [100, 101, 102]);\n assert(x[y - 2].bar.inner == [103, 104, 105]);\n assert(x[y - 1].bar.inner == [106, 107, 108]);\n assert(x[y].bar.inner == [109, 110, 111]);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_0.snap index a19afe4e46f..6c62469980c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_0.snap @@ -24,7 +24,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "struct Bar {\n inner: [Field; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nfn main(y: Field) {\n let foo_one = Foo { a: 1, b: [2, 3, 20], bar: Bar { inner: [100, 101, 102] } };\n let foo_two = Foo { a: 4, b: [5, 6, 21], bar: Bar { inner: [103, 104, 105] } };\n let foo_three = Foo { a: 7, b: [8, 9, 22], bar: Bar { inner: [106, 107, 108] } };\n let foo_four = Foo { a: 10, b: [11, 12, 23], bar: Bar { inner: [109, 110, 111] } };\n let mut x = &[foo_one];\n x = x.push_back(foo_two);\n x = x.push_back(foo_three);\n x = x.push_back(foo_four);\n\n assert(x[y - 3].a == 1);\n assert(x[y - 3].b == [2, 3, 20]);\n assert(x[y - 2].a == 4);\n assert(x[y - 2].b == [5, 6, 21]);\n assert(x[y - 1].a == 7);\n assert(x[y - 1].b == [8, 9, 22]);\n assert(x[y].a == 10);\n assert(x[y].b == [11, 12, 23]);\n assert(x[y].bar.inner == [109, 110, 111]);\n\n if y != 2 {\n x[y - 2].a = 50;\n } else {\n x[y - 2].a = 100;\n }\n assert(x[y - 2].a == 50);\n\n if y == 2 {\n x[y - 1].b = [50, 51, 52];\n } else {\n x[y - 1].b = [100, 101, 102];\n }\n assert(x[2].b == [100, 101, 102]);\n\n assert(x[y - 3].bar.inner == [100, 101, 102]);\n assert(x[y - 2].bar.inner == [103, 104, 105]);\n assert(x[y - 1].bar.inner == [106, 107, 108]);\n assert(x[y].bar.inner == [109, 110, 111]);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index a19afe4e46f..6c62469980c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -24,7 +24,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "struct Bar {\n inner: [Field; 3],\n}\n\nstruct Foo {\n a: Field,\n b: [Field; 3],\n bar: Bar,\n}\n\nfn main(y: Field) {\n let foo_one = Foo { a: 1, b: [2, 3, 20], bar: Bar { inner: [100, 101, 102] } };\n let foo_two = Foo { a: 4, b: [5, 6, 21], bar: Bar { inner: [103, 104, 105] } };\n let foo_three = Foo { a: 7, b: [8, 9, 22], bar: Bar { inner: [106, 107, 108] } };\n let foo_four = Foo { a: 10, b: [11, 12, 23], bar: Bar { inner: [109, 110, 111] } };\n let mut x = &[foo_one];\n x = x.push_back(foo_two);\n x = x.push_back(foo_three);\n x = x.push_back(foo_four);\n\n assert(x[y - 3].a == 1);\n assert(x[y - 3].b == [2, 3, 20]);\n assert(x[y - 2].a == 4);\n assert(x[y - 2].b == [5, 6, 21]);\n assert(x[y - 1].a == 7);\n assert(x[y - 1].b == [8, 9, 22]);\n assert(x[y].a == 10);\n assert(x[y].b == [11, 12, 23]);\n assert(x[y].bar.inner == [109, 110, 111]);\n\n if y != 2 {\n x[y - 2].a = 50;\n } else {\n x[y - 2].a = 100;\n }\n assert(x[y - 2].a == 50);\n\n if y == 2 {\n x[y - 1].b = [50, 51, 52];\n } else {\n x[y - 1].b = [100, 101, 102];\n }\n assert(x[2].b == [100, 101, 102]);\n\n assert(x[y - 3].bar.inner == [100, 101, 102]);\n assert(x[y - 2].bar.inner == [103, 104, 105]);\n assert(x[y - 1].bar.inner == [106, 107, 108]);\n assert(x[y].bar.inner == [109, 110, 111]);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 33280cf4052..07e407c0094 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/nested_array_in_slice/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -28,7 +28,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index ad109635f9b..9abef9d157e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -72,8 +72,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_0.snap index 18509b0a9db..401cc218999 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_0.snap @@ -68,8 +68,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index feecb0c1b5e..6a4d5814803 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/poseidon_bn254_hash_width_3/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -68,8 +68,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "H4sIAAAAAAAA/+z9B8BuyVGei+4BCTEjCY0QMkhISELk2N2ru1c3YBA554zBpqONjQO2wdmWs3HOOeKcc84555xzzse+99x7z733nOf9Zr71/fNP62dsrW3wsTaMZs8favXXq7rqrbeqq5549Myfl/DPE8/+/UX3/q2vv9Oj5/65/uxbnv23efv+2BNlmce1xicewxofxzrf6cR1PnFHDx7Xet/5f4J3/6L/Cdb44v8J1vguj/7nOEMveUzrfPQu9xYt5ZdyvfjZ710Nrf79kkfP/3P9oH/sVc/8+8k7P39X5ltO2ogn7z33TPnJ+Pbk4vOduP7tyWdlvvjxyE9X+e/yeOSbqw580ltv8u9+lutzr+t4TO/JP+bP6V5+77M9uvNZrs9+yWPSkSfuPe/Rs/If3dvP6/OfevRYdco+ce951/Xc35/rmX/59WfeelvPE/e+96K3Pv9zXL/34jvfu77fd+Wf97/zc/d168X3vncXIH7Ks/KevLM3jx6drpP7Y9ZJ/y2ok+H/jjr5zve+96K3Pv9z/Lfq5N09ua+Td4HrZ771JsPckWef/ftjtp/tKv8x+WnzqsX67z5Lf17y1tt+XPftne987brn13fwrnd//t73nrzzvRe99bnPeerZ/37RnefclXVdx4vv/fxHPvvfr3j23+9y53euv//04vnvcu/5z1n34mv39+XJxc8/ufh56eEHPfv3lz77j3To59/BYnf1VX/e8uy/zdv556rTd8/ffVv0rne+fqYdfKG26Pr8px49Vtt42KJ3vbee+/tz1xY98eiGle/+7tOL7931J3e/d/c5Ty6e8z9K1isePf9939eFu793pp25PuupZ+W9aPE57q7tne79/N2/68+L733tk579t37/m1713M+3et/v+sDerXTzMZ+VQzdfuljraj2vWOzPS++t9aWPZ63uuqaXfzNrfem9tb7szveuv3sfIz569HydfEyf4wXbp+vzn3r0+Hy9eYE6oD/37dPLF2t9evG9+zZl9f5evnjOStZTJ8q66sWTj55/zt/y7L/NGLmE7GrJJQebugk5xR5DnN40Z61vPuetWVur4y+pO9v9vgGhehpx3Nel58g203of3Bamsz41SQ5ptzHPZiu/n/ZqUvcdSBZTnyHmOCfPzSGOFI8Y92Ur2fz83HzaRyot52Gny8UE1j9LMjVvpu0usc66l7rFNtKe55ayGW3u2wxPLvbyJtv34MzwI9Tqo4Rns4dWd/bCjMl+hRjG6GU41t5KGjOlNkZx1dh8xEHvtpDtug09J9dzDvs+y7b1EuLunLdx9n3zdRsx7sXNPPnJNPjvnf8eZvZk7bHfr1i+y+7ClpL3pRYbbUPCnorf2jRb9CPbaOyMYYt8ghw7H6UO3vTmmrc19qvsp1frjnxQt3dtY23Fpjj2LY+4xa3tPEmYOu183+W6b6G3to2tTONyCCOacpX9ypXsNFPtrDqkrdVS/B4q27Tl6Dcz9tZqRkeD3b03ffa8E4+lEJJLrk7Xjnf57qs9ya3v3bctmd6CR+WSLaUb68Y+yph29M36vs+Yd56x80JRnRA6e7c5Z6+yX7WQrTMRx7AuI5LjYaJFa1opbfhouvM17nabo47k3OY5XsPVMXZ0lOXfdPA9lnqy+5FmMXHb0ZewbdbMrZmxzTJsN3Ha3YZkZqhpcmgR30ofaHcb1W3mKvvVK9m8IJS75b7lyjHiANUxN1sLu79tqdrCEQzsubW86Tp89exSHJzYbLaDw/s2q/1G1ZodeZiUQ0dS6CVu1s1S9jTybq2JbdtmcpEf6W1Guw/nnd3s5ni5V9nvudrv3WTMjst75ff3VmZ22RlnQt1tbjbt3pps2JB95zXb5FPZWUrpkf9uhz15r9W6O7/mkeI47M5HO5urm7PZx7DnhKXpGIHu7Y6mu5bYLNSKfWGfeKsH7/ia1X77zfstogrRs9vI8G4fPWT2oXGaYkwm9xoxW5ys3fniHB+1DUwK/7ir7NeuZLsyPUdy9tD5rJPtCbG50Mzet479aLWWEaUZaHYpxtdqs52llz14e+j3e6/228/aN4xUYgdRGExqKs503MGOijXPts6dt+E3VMptk/9qJu+NXeMgHDr4upXsUHh5qdaaEkbLs5euybToQbyIJBHNY/7mNiyW9aJBA20MfBx3nJ3Xr/Zk7n3sOB02oJQSOMasblSdjOlKS9sYvOSRgufHeDnNTduzCZFj6urBDbzPSk8wnrxMV/BYLm2VHdlsGAk3WQZLa8VhyN2ceeTqWOkWkp+737FDAQN6lf2G1botRgpNjSVhUK0Zbt/5WqnWF0x/GBsurOXIai3+0WAIWmAZjXfQRzjW/cbVuouLclO72TdsVu2m1RAw/5jUnf3YeG7OxvNBGid4hA1byBfZqTnTOM7Om1bvkh/i/6xtBlsRUXKQAobCYkNz9riEgccbqeE8OZ8xc5RQSiu1L6Ee+v2+qz3Bwe/YlA2PMExJnJCQQQc4433iYTzHFm/fMzvEU3VabdkaLs9538Ih+82rPbE+8/pwgTlPjNDGeZ9h7xFHwWtjP3hrfubu+CGsCdDHA5FMxgiwY/kq+/2W626Gkz49zmuOyNHsAJ29jW3jFaAQnNdYW0M/sL0WUzgK7oQXM4LZy+Ev33+133MHVLGTWGocNzu+8a74D2dm23cz/UQZOVY9gMabjWVvHHncBoAFl3GV/QGrdYeJs802Y6wdNn/HfCRcgw3oQccrVc77VrDuSdBtVDsN/8WHGCh+iFfZH7hatwH1bTbJJAM5DX4wltYxtDU4XsKGxQL5tTQ6sDPuHMeMqXQJcAr6OGR/0Eo2hjNEs5u4d5DCJiu0bTi5CyLjoNdmWgq8ScBQtqPZ1hrnmL0GdOyH7A9e6QkwZhqMqDZnlK1jR3zALiVgBcofOegVgFGLLzMg2feUeQ9WMGLb61X2h6zWHWzfw15aSxw3AFPqqQAAd2c2PHTMmPPQhw+xDE4omDekynvZ6pa32g4d/NDlu4ytC2Y2dAso5fHKBT0wBrTdHagb/ScAwH2CE7Mpe+52K1uJzuMgjjP/Yas9CfxkLRP/ncMoACuOqBWY5YwLgu5RlmnDg3R+wqM1CZ2Mw+Ztb/HwOx++2hMtGri2Y7QM+xx5iHFBOz0wI2aTg8bkDl+a92kjXrH4T/6Dr8Rw+IaPWMlOE0yCg9qxfoQkcpvTgidwFJEIBHOHxrjedyzhDINUG64zGIKfCWA69uQjV/sdYw1bjfgDYgz8TIzBuiZ18wWjiOuv1YBaIo/BvQGneJGcXOwxmPrAEGYlu+snfePY7H5jtR7Q0fEQETNnHMad99vBmqklbGHZMAI4bYCLV+xw+B27kk2EZAgFtMM+16YD3pFtM1tiapiVQx95FfiPPnf0x8mUDPYrtJgPPOhW+62f64pq6shbjB172MDHCdXGIOJ3m+f5OEeOOahHqqnPOAt+Ntz0e1u+S4D3KIC/QdwE3kSBCTdHIHYUSLay5tHHBrKqmy+4Zr4ITonAWz7dVbZf7Yn3BMWcd5AUQSpiNmw4gA8jxmcGXOK/KlYLqGlBSZhYYgC+l6xeznHmw0K2wVRhLG3dtsCrGfwF8IO2YFd79I64JxLbcJpibNYUUEtn3zGes4+YDvsdV7ILQQfvBO/thptxB2ByzNGxKJsK0iEiR3OIx/E0oNKkHwDaFqJ1PsVV9r6SXVmt87urmfg0TAQ1ImwLgsf/DqAIeNbpkOK1t+6xNB17gzcDPvOyrrLT6l1Gnb/sdG5wApttzvCyAG8TF0yMX6arzgZMiuDsxPoAvTBCo7e+xUN2Xr3LKWgNVUC0auWywAcOv9jFRYxq6ozE41XmGvxHfIjiYYcDiCC0Hg8c+1GrdUOI6IRZDkzmPe3RxAoqTD7gdEA6tqGZlZhhBkOkhp3aI0QCBIiz/N9V9kev9tvPttW5R4AOoSOHb99x9URKhMGy1UneNEzFqplo2RARws3w0YgyOARX2R+zks1vT5mriTYHzggqFneDfoPkCQoVMeAuolYZ8b2VvYmcT8/5VPR1lf1tV7LlCQEPwIikF0Ugw1HEWeCjgWQcQJSCR7XOvgQQNavtiFbUD+g9bOzHrmQTbeABHUaIwB5HYoyiY2M5PUT0hJY40tgVN4NYLFand0McpNCcJx429uNW77LxvtGE2GsWiIrQDJAv7G4BO7jEiy3O44K6N9XCKTUYkMw7h7MgSDx08C0r2RieKuzAO3P6uPgGjrIhRAGMsBE4iIDlBgLiHzBjnB0d9jQU4oZDBz9++S5z2Ab+3PEPoZgJAiqFKJ8gO4NjIchgsogbAJnZoz+9ehMKESm/c9OTT1jIxu1BLvBJYU4I6BWc8OFHE9sTyPlPmAh8BO8BkR4IEaEoMGuAJciPcfj5T1ytmzAvCRDzqnxUlANH4kpOHnjTYGhcBCZjsKAKmoLnmiOIHE89PEfj0MFPWu03YKc5jiHOZ8phEoVBmwSnz48/GxBgfJJUseo76K3Cp+i046WAGzcb+8nL/WazoWFw5YQDCdcN1ROmuDA0nxOIU+KkY3IBGs7J1uLyiNU4YxyrQwc/ZbVuHD0QCgoDIsMSGV/eGF/BnpeuyDbBZjr5u8hWd3aHqLlENg3EbA4d/NTVu8TRBjgAhZG+dLi1woZa1BdmDfs7e+nsO+F+JU7gXW/i25qvaCXG4ogvP20lm1UDiDsBpDilwLnuiMEjc2IbkJlNg5zB4nZZMSLNQrzGQeNFcXYP2Z++2pMexl6wDBkojGnDUyGf84K2t0C40NgOgn1A99inVNMQ1hJYmQ6bdTs7n7F6lwRyPUETsDZiGEG/jH1GwcGwCbvXAEFFnC9bZAPgpRIuVOLn3RJbHX7+M1frhp1MziQH60IoCaXGnhOLNICP2IZZMkCx8AaAu4SwYCHxD5zdBGdljnV/1mrdKJkVuKtTXp24csAvKryKVSgOpi0So/BfgIF9A1k4uARF+hkNveHvz169Sxz6hk7vItm2nYjMEQBuvAbw095rbwqb2SWY2i7alFeQhBDRbRiEQ78/ZykbswxC89XgeSG2eYed84l7k9KharA9qDvHGwoIaBFMxrpEAGlDYQ/++3NX+z0U/EofoMPAU9n1BjwIxIK+FSFcmCnQ0LiQ7pCF2BpOZ9+0e+CNq+zPW60bjACR3hUaV6J62Hn2iFANjEbegTAVTSatkcWfiqfVIYbYJteBL7WHPfn8lWwM3NTnE5ICzWTyC7x+TwrGC5pvxeoLA+Cc8ubRIigaWJkdzqPewd9fsNITWW8gNQAcqoXI2l/iP9wymkzAhOOEOFDMgLPuygcYGLCIQjX2fB568oWr/QbZwFWCAwH10D4og1VIz8nomyxrJegB5l44JLuJHRMdwSsOsHu3uPiLVusuQ4AMbxsjH5G8AjgERLbzCCJ83q/ZyeyQd8HIzgDeCAH2gIAfMhkK6yr7i1frjvKNMwJm4V3x6LhZ6DwgEaxxw6V5kbuC9b5C1kNsTYK2XthGTH06dPBLVusmJVX57BNTiyoCDuAhoInxolIfsBRsOpysbIlCYQhhgmN4cHg52OVjT750tW7YysqCUVXgDQYItwMzGitb4cD4IHniWYAOoH67kN5Aw2CJGS/e+9CTL1utW7+HKTRiiDCreB6IJTYaLr1jOnC52CtQ6AbuxOLkiLWqxvUCE5Fu/vLLV7I5bUSmsLwKxwirSIfA6hHQeoKHXIiQDfEHTySnAQ0y4SIIL6DW5YP2w89/xUI2IIFDsJH7gxEDcuLjwNZEHfAG7DJwSwpECgK8rK0jqclb2XlDlZiljmuu99vdkX0/T/6Vd75+Xl46uBeaJ78+/6l7a31cefKvvLee+/tzP0/+VYu1Pr343v3c9lctnvNVi+esZL30RFkvO1HWy0+U9W4nynrFibKePlHWK0+U9e4nynrVibLe40RZrz5R1rc5UdZ7nijrvU6U9ZoTZb32RFnvfaKs150o6/UnynqfE2W94URZbzxR1ptOlPW+J8p684my3u9EWe9/oqwPOFHWB54o64NOlPXBJ8r6kBNlfeiJsj7sRFkffqKsjzhR1keeKMucKMueKMudKGs7UZY/UVY4UVY8UdZ+oqx0oqx8oqyPOlHWR58o62NOlPVtT5T1sSfK+rgTZb3lRFkff6KsTzhR1ieeKOuTTpT1ySfK+pQTZX3qibI+7URZn36irM84UdZnnijrs06U9dknyvqcE2V97omyPu9EWZ9/oqwvOFHWF54o64tOlPXFJ8r6khNlfemJsr7sRFlffqKsa/7loftk5PhJfpG4rSTsSZNWV3fTVBa7kXUj5UXKipSYLeTdNtIwc/Qa0+UCmm5s1Ifuk7lMNtXtQ1d2itctL4S2S2le7qrCUGqnd+stT+t99OiyN7X1YWrfd/vQfTLVxzpL0jPFss1tM121vjH4uCUTQxux9T2THGuhbnvYNkc+2A9+opAbL/v9O4PXPbu7X3f5/G+J+5bX5z91b60nr+fII73bvfXc35/7eaRXLNb69OJ79/NIr1g85xWL56xkvfREWffvW67u/+kWlbeDnDDaaxqpSdLLZMM9ikteuGXdRmt59toHGfvQY4ue1HHX1cPtdqdmdf+PXKi3GbVtxqk2jeOXdnL7GwcHAUrX950sdGo7+XpvHKdzszaSsbaTzO5D9//sHsmq6wSG0o0LyZXdkNc3qcTZc+4m7MOq9naQOq9R9XGdJHhLY7hs7fUd373/d/983M3ffEucj+vzn7q31sd1Pt793nru78/98/GqxVqfXnzvft7wVYvnvGrxnJWsV5wo6+gV8ugBHa7Z1KoSr6brvPlyP3DvDUeR3FDdq4mlory6zOX3umdb8lZ3P7a4bw/fYbXGmt1O1UjiMWrM+2ZD2mPMRkWOl5poryq1GWaV0U+ltBZCMTPlOst9PX2O7IzbaEZ3eY2rOEBV1c0x8B4u5G2W6L3fzWZ24zfdT9ycroTttuuazjAvX+zl/fNxN4/4LXE+rs9/avFuH8f5eI9763lbunbdu1cv1vr04nv3dfrVi+e8evGclaynT5T17vc+z10d/tZuK59+POt50FY+vdjX6969x2KtTy++d79eY6Vz77F4zkrWK0+UddXzh/oU2BGnM0WXWnRBALuSNlU8giQu9VDRmQ1TpvsJu2vZhZLKnkuMabMz2P7QnXxbO1DXJb/j0/fam+qPQdYz7SnE7H3y07u4u+DNVgAeRnWVBnS+J+fjgYfvvrf7OvyY7McL1uHr85969FjPlH3Id97dn4d0+Pq7K125j4ffHr17HOfhIR12PRAqJteS2bcWe6ylTaLDMEKMQRf7PXocqil5EO7ZbILbiy0Bj21Q5od12Ow98gDOyaXM35Rqja4o8SVd+xwmWjuJEafKL60qrx1OO3VC1b3ld/jk5+vw4/LJ9zHr2+NHX36irBeiw5Z4zhVvdEOqjJRG2vaoO2U264LGZvIGBzFta3PzauZRthG2CTMRdvgD81C86JxtlkjLE3SpJD+3OLcB8A1zhrAnG3Y/czJdnTnSZnSffW57a+Nyi6a/kLjrW5sOP+64a6XDD8Vd3xK48kwdfrd7n+cdHNXj56ju16K+PbzSq06Udd+erWwOqNFgWErFgkxb9wiFE0quhMqpbrrYmfIeHPgPpneauOkKNryP2bFndbMPxfc2RA/r67GPRs2igm/7gG6Fi9qiruDtBlu69a3avnnYI2MS9PC0vU5E7w/6e6e76c25oPtm2MbUiMGdLuP1nefCUeH2g1HTIQSWwt/GrHPnHzDIw32kYtyw1bPbVODvZt6SI95nlQ6iQP2RGlbZlNTU0mZPc+8w1MHqngbWut/HvHdlO5vhHmZyW7DQf6a3mEsGs8zBB0qRTcb0NwB2gAmZrhpd7wrNe+ML2P6+HX/uuyyb4eOpUVZNsfuiyxCFpZmerZqMgeP7tsUc+7aPqqtuuTQnNnwDnD3YR8o6W0Wvl7LxGECa282sew8QmNmPDowrycM5wqYMXcWzhr9WSEp+uLWH+kjZHGvwftZR1ZfCNT4CKNGlzCaQYmg9hMS7ltiyJfGPOD7UU1eI8ZcP9ZFyyQAliw1+h4IdI+WGejnxmXKwTsTQaPzTq68wQnvPZh9EVMbNEG/9U1Z9pKxtG0xPrCZtajLUeMwecPmwQqzOgxOa7lySRbDT19B53X6w+VM3GW/3rZZ9pHQb1FT2mhO0wd1G1r+ZsbErrQ6jK2qukOkwuasNVuy5Qz+pacaW861n0qqP1GYI2rrur+kG1xzZNDbVG7OTqcm6g0+iA8baRDaYH95SsyyaWHBDu8N8qI+Um0iqIfgcwOFqKuSMmkcUPkgq6g8QS9ii7nVvqVbIcc69dLaWgHb6B/tIdeICFE5djWDzONfYDdQ8Z50dXRzDeG1hQypsXsfczK7Lc2aO0vytb9frV7LVwc2qvdUIOcGrq1GAmwS4m5rA7N1e0ldJD9qJTQLwjq9vxo5AfGwf6iOlBjt7m5cEgA/77k0Il0tgdUD/+0CAk5uuiLWiPmk7bxi06NOcw+Z865m07CPFRyNk2nxOUPB9YrScLhLq86vN06g8oOoGpLCpHlNjU0eyrJ5Kt/v3b1ytewzjQKQBdp8t3S3ZMGBnaLpU3bLxgzdquydnQZouBNS1Rd2FA6Vi2eNDfaSIxuJMnJ8Wza5mKi5jr9V/iY/h9zkjOsEL3z22L0V42pJ5tlUfITKA4aE+UjbZjveCLcGdGDQxVWwfx6ZCluwO678pKuwYqaFmNsXz/47USTLq2FQf6iOFmVS/oZHi5qMvTp2d9ok5tFC7ENQ82rbhIGJaLVVtBdBZ+F9+hCSK8Q/1kbKhzmR3ny0vDboYY2WV1SQZUznb6j6yoYmY6uJqDFnt43rqurqIIbPpoT5SpHBa7db6iB/TbUp1mijVJahxj8kiUUQ+VLpJXgpaPHssrduxB83w5v1DfaTMlIlWt7sot07kHeKAAZ9lhIb+xA2nSYiEJ2Lv1ZsETp4XbrqOs3EP9ZEyOPcY2bjqG0R7VEcP9TQ0WI2ItZ3gFLvtHQOIZqrHmSfU92GzgAl7u1f9QUsddGEWPlxAhE9Wl3cBLCOi3dgm4i6SvluzZRaMIf5sWB63ASkrJvbWV/6DV7LN3vA5joVWH3ImFzh0lT2qIyXJDZ32nknOWci1wJuP4IG4AWOG4xCFh/pIGRIP5KWBICAU5Ta20vRKN/yx2lrq9jZQZMvwfqQAeWgi9YH+74C5ebvHvuojxQHzJpKdHOQSZ4JQiQFH2EB+wztLzNnVOA1OxdfZdnUZRWMxME1XYW9+ftlHiqQin3eM6RxJ9e6kD6XAM5LjwaDymYQwveMLmf3asfRVLX144yCa/cE+UnuzE13z7GpBS8ApeLOOKGNhQb0Al9F1eAxkBe8WgQhyrgXSCDc9H+ojxdoS+yicpI4yvei6M9lO9WDA11u1k2qF4J9kj9qypgKQ29LIuvrO53ywjxT2Dk9uwCG6b1w5MME21DcG9V7anXqgND4U6aagPhy8QSDSNAXOFnv8YB8pAJ94gq0gJKuTLz4eENnxiABWbGrfirq5qk2NmvBi6mE0AACdU+zKg32kiA048yBUjnUGFkdVf1RA3MxqkVHZf8AmK98wjK1Ey/JVYYGfBs3Uh/pIAWNa0u1nXAAGGpKOpJ/e1tgBr9hySDxltS0sIaAB9AnO4FTqVjUQfTzUR8oIOGAXLj3GeIVT3dyq4h+1MsEpG8ChhclpDkefYcWHx5uELXk14JkP9ZFCtdm/Df+b9fkxeo5cICBWbw/lHw47afkAXk2sCuhyhq7t4njxIuxDfaRc9K6qR7B+H4ij7ncEUPjmRDiScf+buhmWrvauTjA2X7qzmsH5yuHBPlIcaD7bVsku4I0HnJafCtlIz8aiJq9WZgYsn9ii5p3apqL5QPAtqvPeQ32kHO8/OnWIYjcqLgawGrOcTalS5U2tHDEcUMHqBponoWYHyoE9y+BVPdRHimDBD2yqUCDL9jwGwxonpxBzhEnM7HIALwhrGLg1UG7CUUwZ4HSbH7XqI0VoRhRZQQrYKKLUtrHDHdwJQuRdARk47yRC2Gj1Fc3Ac9IuFRqaMGCm8mAfKSx3BslDDwIIUQlcBP4l2bHbAkIJuUGEq9GGcskZ8975VI7/Qa2Ifh7sI7Vf+qPE2AAeG7kbdWDaM6RljL1vGc+LIC9pRd0UUEPS2XxQR94HH/dQHyk1dnJ9BwBmr2beGM8N/0gCPUanC/YZJ9Gzy3gy79oOjdnJEeE0ktpJ+of6SAE1OANVLRUnyIAzQ9RLiKq+CdaoSQhGfQePz45RVa87dq5BIxDdAmAe7COlxmGgMPy6DzK3cAAo8gYid61HdasDdU0nLgLKlYCr5uq9Leg2JvzWP2XZR4o0hSw2PCxuwOIhYlMj2kvPm/FMI6WhxujRkEJT6zjyHOwVULx2t7WH+kgJaOAUCH4TOrLz8TNhdto4JMA19dGU5/IqTVOTGnYaGNEIG9VnYZvuoT5SFjmKczePt8mYfpTcAQB9RUVax2nikvAam/ph7mVDNyrBVVMuUTUOD/WRskT9jf3mWILvgacOowFm9gp7MdVeDZtciSBXp5QlsYIBDEImYAH4kA/2kYqq6uAYxl2pztbJVqrRe8N2qIkKG6bPkNSsF44IVBJi7RHABCc/br1ZVn2k2DdoHqBV5gMTd5EOBXyDK3FeEPDqe1vV6FKa4VVEuAst+Uzk6mS8HuwjRWw5YI0ueQOfd2AIqBm3ySlilQaLwiao0BGfoGIVXovJ4OlL1zG7PdRHyimdNiEg1N6czSe9hm9AlydHSU3h2SLgONmFxmlSwU1Te1SwBV/FFT3UR8qQV9jrBihVMEWAgNmzyQk5ZdBlUuSKdgZcDmwCP8YxUH8vDBcpiVtv22UfKXZNPZeCPHBVg1GLu8Xr4z7JZRfV/eCqd9SZmIH4lmM8L1QBXi7e8OCnr9at1jpT7RzVkxeKcNs3VBqXEhyeGMVUAzKCwamTIBpO1pKANkBHAuke6iPlyHo7j4YER+hrIN3gINAMovWhzupKpVfEkNwE8+PQrBqrqK37xCvfaos+c7nfoHp1XyEclpqBkrV4LxhbiVfxwpfiO9RCzcvV7raqdxUEl1psxgf7SLGPUDGAaoW6c4PpQhlhCyM7oeeh+XwqeDLQ1hQZ59R8D+fcgR0hP9hHyvHqcMOTN2mjw3JENWzdyFeJqsVNqJMo3szAH1enzp+Zb22cp01h/kN9pCDkMCH41bhtausCF0CgDM2FI41dx2YToIL/2oiLi1UHU0IJPFPEmtw4pVUfKYdRwEuxBeqsvJu2Ne1ziY4gYXOqPw6zF5SEWPUCQtHyDB+hNjwlz4f6SJmtq/v7biA5rHr2ZQy1MAKUDzaP0BBz5TusGOIE0iH8iIwwxewhbuOhPlLkthO7wBvEdMtJNTz8Dh5HHfBurWA8JlR1b0TeWD/X1SMLsgpEE/Otv/KqjxSxFBgGxKGuSWrbBcsBe+CJ6rcyKsiZpHx0hBJTjQ2J/XJQ3I0945XcYsBVHylQa61YVOC7QnSC3hSasvMarYFI3BjcO+JZKbqNr+lqAeqIiwv/ZR/qI6XoHM4q8BlbIJ7BTW7yw1DAAHyoDaC59DlqSgWYMzuSAoJX3oKydv9QHylNlJj443rp8kSM6dT4K0bVswtJgRUhx8ma6O3C+QIsKjwv7OzQbAf3YB+p2OGjrMaQoC24QV5rw4ATQ/JawSfsrXoE8ky4FZAoiAoVx1U0DzByD/WRcgVqA/PRLi0E0Y8sxJzUQNNgpwgO4O+SreHSLRpkj1anJkOJkyjm4T5SKAP0DS+0EnPDz1SOIEsbWblwLLn6blkstnBPx2xfuuA6DMps406v7FUfKRwZAEEUzibalDzPAPFg0CeUaSaVZIRwoxrmKrQkEoFUB5+ipxkrYR/qI6VGYECfoJ1QG8Q69l0jcAhX8VpOxc8o+aa+9lXUm+pRd/lsDrHg2/1eUc9Z9wiYJM8mEjdWYCy0EftAVL2zM2SQwMHgBTTRi1GG4+UwRYy5plr025n/qpVs2AsSE3DDUPQW+NPUFh7GHU/EV1Rami+0G0fKTVGgOjLoLWkwMQBX2d9+tSdAhmwtNH0Gn0w175/wXV6TJAh9oBlx+rizDAeOkTdjQE/C2PDaiYr7oSffYbVul/C0pEHgRUWu1eJ0+YIgksDMq0NsCzpRHFpP6IZJIfzBAGDIyBX6w1Z99UK2G5CasAyOxAexjeqIoM2VUhPjbwtBDYG20D7Bs/gBA7NPPgwKe6b91juurPaE6MZyqAkCRiIAh2Z3hl3exjNdvTGOHUvdLgkrX1gEKQ78hldxE1HJVXZd7QnblwyQRtX/SnuqY3pWI0BwQgdSQQax8KRBHzBVUY0ZW4GUjcB8bOdVdlvJhgsAveJB4Ho0tQgPVMiCtYYHVidHxHiFbDsxHBwB2JscAh8KKGb2W76hr/YErcINEpvxG6hyG4FVCbgOfCTelCyXVxtjK2PLmQJTE3LOKZriziymsVo3vBq5VCPNhssBRWCiOlku66q0EtQwm67mKIzIHRqhCKwBxyAI/e3Mz5WeJM0EYJnOFfTOqM88YQywnsAG7VTzTJLaynJXUWCNtYP8xeOISDn8/HdcrRuMDJp06FwVfad7RTs5LdKDfPjpUIhdnYs56BcjDI2AMjqdZoHGww5+p9W6x65u1vKNXqlP9AZMrOQiXox0DFvP6jOMaYOq4ICR1fC8UIAKNNMtL/U1q3ep7snkMMRY8QuwAE5ko8UVZCPQjM1y0Dzgnw2szrv1z4yGMBtJ3Vt/5e+8kk3sT8AzgKxlaA/R3P1icW2D2NurbqVgqNR2e6tY8kQSTOQKXhp3eHCm32W1JwKUuz75uLSmz5aPqk6gqrOvViWA6DgRBLYPjKR+lXw28npZafF22O+vXb3Ljr3oVvPR2PcddqFgZbumlZVJ2AN8V+dWzU0bwG4sI5+IKKoBB2HGDnvyXZfrhj4vxAdGh92KeIb01lwZWEwl12HroOtIT5P+53VigcH+YHD86Lgzj+C7rWQDw7AfVq1wnYak6Qoe2ZtKzCab1KAhs8bCwIgPc5mgoY6YuwrVSGwcmO27r94lHB25kUQgT0xg1Fa/mD1B+gIuQOBzszyDGG0CeGwWkTDVhZl0JId4O/Tke6xks4lDyRDDfmC4EAVoBbNx8GGs4PE4krheoKy5FHLIa1SSPfwacOiQ/XWrd7kF5RNh0iB4LfKNuN6sbCv8FEqI8Ya0Khd0RI62kREDW20aGgffcvjL77mSjRvGOuHHSLwQ/BH07pozwu8R2igloMkuwDZSQCB12UpiEzTQFwKTW+/977XaE81Gg8kmoEcxYGMq2IHghqh1wwKSsu+kUdA8VRNgQ9hzcnWEUr5hgvbDxn7vlZ50MntwCzhjfgeCtUB0QswIjzuMjbQQHEjEDyIYylop8gdpGkWO9dDBr1/tCRbJGw0wAC+pOgRQvV1iSzLGducDsB2qiMgcYIgsKB9eBEkap0qKmw5+w0q2xs5wIjHh4urgpIjSARNJM2DI4QFEQeeqCoG11ogWkgiX4oOiFMqN4/g+S9ldY610hm0T3tT0M9bYUtakFOWowAtEKEatqGGUmvgINhJsH/d64JPvu9pvbBwv3gHLSBVDXeETjAZd4cayKBX1LSfmJq7F8kwwF58LcsKIXriTQ/9+K9kBU02EGqxS0GB2UnUgcWXYjKoAICJUm0rw3nQltiqGZ18ApNgK9vAq+/svZMNbGBg2IuCKl7iE9bgIlAxnSH6+6joWXxRk7pbPAsFBkk1JzKoKgEP2D1itm+xKFHdBTAI7GHBuu1GpA2DBXVrtAzCaOOtGGgavjZkCSVQYIe9hCq+yf+DqXZJjgsZU5hqGW614QVcbAZoKc40aK3Pw1W8Wx0w8P3JVwREpCsgPEmSHn/9BK9k4FkFVKAZlbgS54cPkY3CGEJBAHJXfYFY4RPgkjMkImqOhKRSs5Sr7B6/2RJXwbGS71GmQgGdx5XJHFLRTgTvYKMh3D5QmYt7VpfhSClUu47du8fwPWa2bfJna5pJvcdIHcC8ITTPKWDIvE0XpSZdIhsZJYIixhPEScpJZwvBcZb91JdsJlAix4lJQkqlWxdVhqyuGiwhY9gNP1zQeTIVKZHsKIXdSIjPf+uP/0EcrHQSNYPwxhWhDryqB1iZ3TXLqopKJ36F3W3CaB0hC0BDSg/61UzBXV9k/bLVuIA5ZfgVfGvMFZbkraCV0m7xPUBxwTbUcRKwksBJ2Ri24WUZTOH7zxT989S71QeEHEucbQwX2m1vV/Bo1XSYkA7BAUDlyMLglELKmSsBRo4i6i26Pd/kjVnuieTYceGEOks6bauOixjBhDXcngrCoGq2I6utAOTzU9FFDiTC+sAtX2T9yJRstJkDQVV5d8uWA5MsdI93x2cKlPoqYgv+5VPjwLXklwB1RipzmIftHrfYbz9sBwbB3EAZ58h9uajZkxYVqskzHKPIouWH2C2CrEZ2c3Xkpljh08Eev9nvoAxKqO5VgqsaFg8yxY4dsIZ7smFYBW1yaZteAyIn+YPeEcjHkh+wfs9oTDKnKj6BhNjgNCC8iKcgHuOkNC9agC9gxYkClMUCKoWvehkymGMPbur9xKXuDqp8p6/42UAoXiDqgjJ1X3Cr2T9mRpjJZjZEFusKpqtd6vyCP4+z82OWeKGkE3wpiAKvBtDpQOPByaNyNmyGD97GmUAMJc4zx0g2DUqvuzMxxYIgft1w37ouDYi9FbYiAqa9YDNIrdidYgayRywXXE8GSFx0K22CW2Cmg4q0G6sev9GTiraAXnGYGEtagK8RJ7E3nnGBfUBK1gcBlYF0jbFDWrBOOGXwob/mwsT9hte4hk4ZXVVFVVmXCxjsEffAFXNDFA4FcAbq2qXA5aF4J6NNyhLG4B4b4iat1J3Kj6psO1FHwJAn5AniKgjZLYB00QGSDDU/KVkPd8G9smKoAy4E1f9Jq3QgBk4GjJvwlSYGGWxb1qxbtmAAoDnA2JFtMZJQ4ptqZjpNwKhCKh5785KXsrAkdeEW8QNmD6gzUub8BWuMoaspPACR6rfcYeOsJ6El070Xk19scnJ+y2pPOJrK3MAxZ82+cRvNFOCTlAXl1cYcOJ1+tMUok6ckiazqffBMYwt9qoH7qQjb+msCpo7VkDDnj2KOgqrOMIeCliQkSRybAYoHgfCosSSaO4v0QXxzx5U9bycZpE4hAvTiVCoHJmiYsJ82hQ6WhHI3GD5LaLuyYkpxGAx1wq1Cm6caf/PTlfkOc5wQEGRqDmBonx6sMEVNtAZkAjKkvQnjwUKI1Kb/qpSBTdn+bD/szVrJRB08uw3RVsajSwai2Cf6HOKdrTFN0UHpKGDRpNMgQ9yyzTnYl3Gr8fub6XTqVqwJUa0vKpIGXiBdgc9l/znjR+FJNK1WnC/ROBIH03olXuM3V+lmrdasYKfpnJsehy0RLuajS0QivQunCQJIwVeEMGUeVzcviorWaMZVvcdrPXq1bc0SBweS8eDmawaLsdYUlgDoHQzR42kCUD/+ATdcw2qiJnShPNWpdc5X9c1brrpDS6tiR4GdUL5BVGVM1nSJi2MkM7JrfGDTjG2bTEuqo3EN1UYM49OBmfu5y3SHArhVPSJU0QyMrtdB3jWaZ8O4dagK6oGuE9YCuwB01AnJN2eEnbpzpz1vJVp2kQnRyQrpfwFrIuQCcUfepgdyZUEu1zUqXGpF8QHtAwdbZk3nLMf78lWxss8pxDESU1+g8hwlyxIAiTqDaZmzuQmYUZIGRyCERxZPf0wjjesODv2AhG1WdnHKtAz88QfQbUZ9VRQr4Ej4SU8rZnJrNojl9wFtXVWkNc6Pr01fZv3D1LjnfgSAX8udSp5+ExUllQIKphM+Wy4ggfEdiJ2D6oCCIvcEpqe27v+WlftFq3UZkOZaNExzlK7vGbfdds0TFDnAuiX95mLpFdFVXlp2ws8BBcpJu+v2L17J5b5CsRP/oLmypUSX7pkFMgYWSeSUH3sjOa0jpllV0tGMAUVUSBTf+5JesZOtQq90ScQMojz33CsGzaFLcur8UGkR4PYxez5omoosJMPIXvBQPPPhNKz3ZIumAQk4lqZQ26wJ7jppoV2EwLunLfJn70pQaIXRVNiWHyzxeoN1hq37pSnYrzkg3yMUXsTkGboawSnkLNtfqqiZZcPKjuoWBRrKCWiZsPHnZkY+44Zet9KTIyMHjONE/+IAmHzB03WHjrAZ1y4H/FifeIT0hrLDsiby0hwQyN+7xl69kg9UFAFW8Sxa3aMgg6ocKACMEeFRk5DTsUfX7Q5ErrxiWHwOmmzhX2b9iJRueQpPXkzg5lBwSr2jQNlQkxzOSLCKNRqi9X6b4TUvOjbQe0Q+WmJdzcNS/crXfPaNRflOpkjh1CB2SYBx/zCGB0+CADqUrC1zhpWgT3eT8dNC3qMnDN/yqhWw2m9NLYEPeS5kHS/rPojz8rwZ2Ef5sghHmMkIT9SZX0y4seIcBIPq8yv7Vq3VPUX5wjrorYrwGnEIWWhk64iWNUid/RKKbKE0F9wCfIL4sFGJnwPmBB3/NSnbScCoAHrENjGzd9Brh9TjR0NektqNMIlEO9OG43KuBXumqNlVm+TZX69eu9iTNS52+rOvIO2a6qtYTbBw0pzfxKprS3OIiVeOsYuSkEfCceNTx0JNft9ITDy+VBCk5DE4uV8PjFF7x5a6yE3KuqKhtqkpKTqBgu1zdjxea/Sr716/2BGIIQKDrUBoGZy9KQ5o0kAPJyjwC1FSwpdhFCUay3WQ5YYrqrrT4oSe/YbUn0CUqlyThmon1NPJJGS2iNSLUlqvCcA5UFVlVUSmSB/ww50gFtONWM/wbV7Ix3lgp/bRThqfBFgoxXAboYqVIC8DMBk3JBirrdgifijTCjJzWcpv1+5tW+60uBBrJOTBrmq2usjMr1Ka7TthoUMnmcXMEscBbqxGRQXWKSbVW7fA7v3m132SFyDRgUS5jKKvmu2mi2VBXpSJIpaCF5GWzQ4UBuBIALt8nIsBqHbJ/y3LdXSPJhoi2qdsWEGmYWnKkGCQCeWKFjAlTmRExvAj+gWfl2PJyyCgdevJbV/sNaIDj0p5o5FS43LxoSvMpvw88IbvmyGbAv5HlyqB1fB2Uu6s4pz6PGPC3rWQbHZCMZWiXMhuYWI8fT+jaUMWaziawB/QK/eknG7HLa0D8eWz+7U7qb1/tt2VbJ5YJamDihLw4rqo6UA47RpENEHGK3uOmgeScFxUAq+EVC7np4O9YrVu1JpDr6LLIKeJI3bLkuIijIR2I4Yb2hS3dHazbRpYkWc13hU6VtT1k/87Vugn7YFlUIYvrypx7nmM1nlUnqghfAWCbckhd86ah2kBZIANiE0DuYU9+12rdXRl6HBicqQYSDo1mVZfIToy5Q8GgjGJMsNlwHaTC9tQ0vzfB95HcPbDP716tG2M2pFtEapYgWvdoOXGEaRCLF+4IzwyKVpnZ1J0GlT+SW4JAqDPfdPD3rNaNdQ7K6AD89qEEsdEtCj80cxqWiWCSMJbQjawBKbFgld3FX7LoTYUIV9m/d7Vuzd2EJXmmnAcz2pTbiGYDHiOFHAfxE2yqbtOBSDT5j2ARrAS9D9Q/1v37FrL15sizazjwJYOhjipQEPKTusAThGwH5lScquZP5n6pnVGMXuSTrrJ///Jd9lp3kp+E7ZBUiTSS8zkTb2MRoauAUKqyZKdwTUSaulZGNgOTqBnV41j3H1itm3PLT4I1TBIP4celDBKtU7W3yu9g36rKFAjei9AULMTl8g6e6k58+QdX+837IdiA3sdLkWclBN/D1DESy4n5xwUQL0Of7qLIU9UsvGAUZRLdtSMG/EOrdUfVweCR6wX7ZAwtPCERxCCg59A6FYR6laiToMGEAVdUk8p5BWmEW270D6/WTfIWK0dCn5QZy9RF3+jZj7ERbAL6yH3h+uE6CZ4uRehSlw7ujJ3Q89jvP7Jat78ktDSzG2euO68YP43l67qRmXZxo6YS7w81fFRP1AnO9+TT+BF7mzH/R1d6simVQ0a0OSJLsqFSXiNu1mC6CWvgPIuyyUMYnRBZl80aZhDyVKzQVfYfW8k2mjNJAhWdgqVBmLJFhAkQB5tSD9jfqmQiXOBALXHdg9gIHNHUHeCIAf/4ak/QvMlR2C/DcZWC60mFk1XVr4VNIkPUFE7oWly4BOZTYzxJWnWlDq+y/8Rq3RBmnmQgnLyFCiUeAY1oJrbXzHmgG+Y2iPHQRWYbkNxJJJG/Ar5oyONV9p9crTsOtgNLMgkzsM5BWSISxwZak6Qr9CjY1sQYFBU5VXMDlyEndm9VynRg+z+1kG01A7eQva6q44OQUFGCUzEv6J6NnhNnv6ngFETMBrYIYU4mBuIWZ5wPruBPr9aNJwC/Qt7hBaEzVI7oRAz6qWviG4yjbig03SeNicNKzhXL7vumE33b7z+zkt0wOG0UiI3G/pFYFEudp8weCDbqNKJB5Ax0I5BECtpelYYoSWOvDwzxZ1fv0l5G3Su8JPjXhM+iGvAMhcUpmVFEhoWI6JcaJSgmFr5jBcDjhDu3POCfW607K+wAcYIbLuUV5Dt1wQbLBBwkSwJlox4TolQDZGpXrQoZCtE/6l95lf3nV+sW/UdgAAwrcBGwJAE/BrGRlQ3DERcCLO+Fp7IGCU/dd1XSqpKDhBe/yv4LK9kbGoLykS8izNFlKP0PDPjGtjZd98DnliAOtosHU85xw6TwbCLFW8+Mv7iSTYiu+2HZExhFDSI1Sm3zIQTRagwEJlH8g1XBtYq2ByQev0MCAahxnPm/tJKtGaJEdiwSNA8AqTVJTS5jQws2VwSmTR54MsnngX/I0WEfxZ0SsB345C+v3iWulgibc0eOJym4DLgXEJG0Rg30BqmjrNsUGAAsuFoO4D55Nokmgter7L+ykE1u3BBvj52cNue/SdVxjJiMGDMfIWyaoO40XXW7lOWoWQuajXkFQG+HnvzVlWwSJYDdTbUWjlhQtaRTJTK6qgrs1/XuC72H9gWQFWkajiw/z9I3d7sn8NdW+y0mXTd/d9wtyK0LnqGYVZcuMSgojtVsXAhPVBVSCOJ6IyblJ8iwzcPP//WVbLAubmAEMS42kahl71VTaXVTIylywlJdMC7W0qtqQq2Yrbql9O12Z+9vrGRznrMuJgOZ9qx2r4gh60eqLoJsNf0bEH2pNMBUqTNKIKBKlxvCUAjHmf+bq/3GvFVVznRMMu9O0B0LitIFcnTOq4sNqUX1siFe3om6qwIkkuB8vnmrlftbK9mWPCcnm/8h1agKykpGUTxH0H0DGzX2O26CQyrR7EqIb/AWpL757n5wHH97Idt0iCheUgZXs1ZS6KqSTVUJ6aASbdU9gUBh070owSCHDx4glCOVcbuX8XdWsl0XaJeb8UE3KICyeENSrjtRdtBU8UubeQ4AcB6gtct1JNSGQwUSvcr+uyvZlk0G/fIuYRmiUfzK+RQjymsgeoAmGLrHRxzKCWW5XkWnFpYogpYOX/z3VnoCuAyAUmACvmsniooKAt3l/p6VCSP0UK9OWUFgUObsEqx4pQcN6nuV/fdX75IVXVrgDAJXwjIgk8YtJ6V5seSYJI4KyWSOJZpBGJWr7m5wlsg+ZHPoyT9Y7UlQ0xsslPQcUXB1W1K8DpmsBjC76vlGV4kLfFuCtlJmxYsKBuqFw8//w5VszDDGWA2XNT46qZy56ep44vDnAMBiz0iok8RENIeXhOuFwuK06tr7VfY/Wu0JdpU4qrMVGNlIGreq6bIUhACS9L8ucT4T0g6yj+pkgl18po+MJfN7lf2PV+smmIkkilTHptIKPC3ZLd6t0mDwOh6F9oDvqgvFHBzCZJUii8cmhGjHfv+TlZ4MQl2v1GHVTUiCwaayIs7+prpJjrURN5FhvlVrsCsfRsKtOjjgSsrzKvufLtcNF6KLtwGyA7JBA8RxDqSRhpw0+KyqothHjVEfvAZeKbRc5t3Cht1yGf9sJRvWYuL7nG6W+1EuPqs7Tl/Txe0J3+YItNXwg9dAGkw1TEnTwEHMrOEq+5+v9kQI04k3Vz1EUGsLkrxJFTN1aLZ5U62jqE2Sd2r1QRTEIki1Z+DErcbvX6xks67QmhZv9Bv4M4gowl7dAVZWJ0QdU7/x7axiHFheACeoE4Zs3Hoh/MuFbKubmgBIoWN1zvByaEQcNTcF32pICvmg8IxzalVMFLr8s66EbtMfe/KvVvsNAiGWI8unqgoYqkmyFp6ATxJ0I7oGXRFWk0hCHnWgUfOJAt8Hd00G/zg7/3qpJ0NdcTjZWU3BhEHwnlYpLfDThrLDMMMcq+OJAk21GiBmjNar5uAWX/6blWxSgJBTqnmVlnMepwWXEauHURP6U1VlBpuSFE0EXkKKiuQ9MEY5jqvsf7uSrYs/BBhYJ6WLrPZG9NKG+XIb8BjoeimnvNxKyONy2Q6ICz0BrWiOPfl3Kz2x4GMcCyFaUbnQPpUeZXGgel4bGTsoAatWSlA4sE8cdX7Fq3WLqueOPfn3Kz0BC+MfOIOWLCsWUFXw4Gr4JMg1whSU0YMUcY44y4yDKgl0pRQ4hN/tXvR/WK3bcACDWkCg5o7tMZekSIoA76hab7iNXd1X1FVI9syqUuJCdoLptgNX/cfVfsN4iVQiy6erHdDDkEtDRZlgWaczCYUM84BrJxNLCi8923SiJ5Jht3qI/7SS3S8XI3e9KlwgOQoSfEEt/YDGCZaZj9R1xw4WCMOii3Fb0d1yAiL04OAK/vNKtmrsAF+icLOYbXwLPhfkI660ksEQIRPh32C1+K7RDT6cpy6V8vGOfqr/2x3ZTzz77+tz/8udr5/WsxJe/Yl7z3v0aN1D8/r8p+6t9dT13Omh+V/uref+/rzTs/++7t1/Xaz16cX37ve1/q+L5/zXxXNWst7tRFmvOFHWK0+U9e4nyjpz7191oqz3OFHWq0+U9W1OlHXm3r/nibLe60RZrzlR1mtPlHXm3r/3ibJed6Ks158o631OlHXm3r/hRFlvPFHWm06U9b4nyjpz7998oqz3O1HW+58o6wNOlHXm3n/gibI+6ERZH3yirA85UdaZe/+hJ8r6sBNlffiJsj7iRFln7v1HnijLnCjLnijLnSjrzL3fTpTlT5QVTpQVT5R15t7vJ8pKJ8rKJ8r6qBNlnbn3H32irI85Uda3PVHWx54o68y9/7gTZb3lRFkff6KsTzhR1pl7/4knyvqkE2V98omyPuVEWWfu/aeeKOvTTpT16SfK+owTZZ259595oqzPOlHWZ58o63NOlHXm3n/uibI+70RZn3+irC84UdaZe/+FJ8r6ohNlffGJsr7kRFln7v2Xnijry06U9eUnyvqKE2WdufdfeaKsrzpR1rc/UdZ3OFHWmXv/1SfKKifKqifKaifKOnPv+4myxomy5omyvuOJss7c++90oqyvOVHWdz5R1nc5UdaZe/+1J8r6rifK+m4nyvruJ8o6c++/x4myvu5EWd/zRFnf60RZZ+799z5R1tefKOsbTpT1fU6Udebef98TZX2/E2V9/xNl/YATZZ259z/wRFk/6ERZP/hEWT/kRFln7v1bT5T1Q0+U9cNOlPXDT5R15t7/iBNl/cgTZf2oE2X96BNlnbn3P+ZEWd94oqwfe6KsH3eirDP3/sefKOsnnCjrJ54o6yedKOvMvf/JJ8r6KSfK+qknyvppJ8o6c+9/+omyfsaJsn7mibJ+1omyztz7n32irJ9zoqyfe6Ksn3eirDP3/uefKOsXnCjrF54o6xedKOvMvf/FJ8r6JSfK+qYTZf3SE2Wdufe/7ERZv/xEWb/iRFm/8kRZZ+79rzpR1q8+UdavOVHWrz1R1pl7/+tOlPXrT5T1G06U9RtPlHXm3v+mE2X95hNl/ZYTZf3WE2Wdufe/7URZv/1EWb/jRFm/80RZZ+797zpR1u8+UdbvOVHW7z1R1pl7//tOlPX7T5T1B06U9QdPlHXm3v+hE2X94RNl/ZETZf3RE2Wdufd/7ERZf/xEWX/iRFl/8kRZZ+79nzpR1p8+UdafOVHWnz1R1pl7/+dOlPXnT5T1F06U9RdPlHXm3v+lE2X95RNl/ZUTZf3VE2Wdufd/7URZf/1EWX/jRFl/80RZZ+793zpR1t8+UdbfOVHW3z1R1pl7//dOlPX3T5T1D06U9Q9PlHXm3v+jE2X94xNl/ZMTZf3TE2Wduff/7ERZ//xEWf/iRFn/8kRZZ+79vzpR1r8+Uda/OVHWvz1R1pl7/+9OlPXvT5T1H06U9R9PlHXm3v+nE2X95xNlvfREWS979u+veLTeP/15cvFcPectz/63eTv/PHFvLS+68znuPvOpO5/n7s/f/bv+vPje1/7+i57597vyzze96rmf76lHz9+7px7YuycW63n54veeeBv/vj7n/tfuP2f1Hl7x6Pmf+/47utvT9XG8o2uf17vv6O4zX3bn89z9+bt/158X3/vav3rgHb3s3t7d/9pD7+hl9/bnice0P08+ev67OVH+dtWxFz967t7oz7vwz3940XO//uSdfX7nxe++7M737/78N77qJvM/PyvzFfd+Rn9/yb19fdy24apjb8s2XNf2To+er5PXv9/9vNev/e8P6N2Td37vnRdfu693L1ms58lHz9+7Jx6dr3fv9njkH7MCXvF45B8zFO72fD5Pf24zGu72gX504vpX5/L6rnWGrt+47ttVZ19852t3f/fd7n3/+vP/x7vfZL7zs79wPZd39e7qN17x6Pln5P6ZfdVj2fPbmX2PZ+XdPbN3n3ld2zvd+/m7f7+7F9evPfXs51+d2Zfe+b13XnztoTN7/bmXL37v7fXnq/fwzdn0V97TnevvvVCbfv35f31Hd97jAd156b01P7VY85OL3ztRd9o3tyeveeA8vZA9uf78X7mzJ6/7X/w8vflb8Dw9uVjriXvnX8h5fY5tefRY8Yy9/y6/uX297t2rF2t9evG9d7nz97vfu/ucVy+e8z9K1ssfPf/zv7229a7u3Ne5t2VHwkl25FfdsSPpATty/529UNuqP2959t/m7fzzQs7hy+98/Ty9d/aFnsPr8/9HncOX31vPN3cOX7VY69OL792fO/KqxXNetXjOStZLTpT1rXVd75D1DlnvkPUOWe+Q9Q5Z75D1v7asJ9+G7Lc8+9/m7fqz5ftY99Fpsm985uPhApx9vPGyO/jkVz8W+eaYx/ttHo/8Y2bpez4O+db2b47v/cZ7ceV1Ptzb4ntfcu/7159/rztx5Y9/9hdefu93rjIePbqdmcf03l4wj3J9/lOPnn+GH0f8tuIk7u7P/fjtPRdrfXrxvfvcx3sunvOei+f8j5L1eN+3T9+cnv/cF68/0wvNa1x//ge/8ibzF9zjT+7mhO7zsHc/9yvv7cljOfvmxsNez+hdHnalV+907+fv/v3uXly/9sse4GH/W7m3Vy7W8/LF7z3xNv59fc79rz3E8b3y3nPeFvf2a+/pzvX3Xij3dv35r72jO7/hAd25f86fWqz5/8569Tses16t9u4+lnuvx7x3r1ns3Xs9sHd3Z61e/353765f+wMn7t1LFut53GfyheYa//hJucZPuHMm/9QDfPhDZ/I+7l/V/9z9mXd99NznPLVY56PF57r/s+/0Nj7TX3r2czzmGh9zv0bh7rNefm+Nd3/uMedk4wvRw7vPf+reWk9ej72vo9f13N+f+9hvpWMr/buP1/5bawT/V5X1UHzy32vL7ur09XuveLTWL/15crG+/1G1qitb8t9aq/qvHvA373Rv796Wvj99b0/u/tyTjx7r2fTfnJ/59/f8zFN39mHlZ+7b5OvPmzt+5j/d8zN3P/d9HHKV/ejuZx41eD/HcMmG3ss+wzZcbq20nEbfe0q5Vj9q93vbUvRza672ZEvsJWV73/4+R3YIvu9b3GyoKUY3jZu9lr3zxX3WVmzey6jWjRL9bje+tW3TJb8H61Kr9/X5rmw301Zzny7k6mpMtfXdJxPiZljnvgefzd6naWZWeK8wg0l7C6mHkZrr/r4/e47sVnYz3Eh9n1su1nm/l5Y2E5wPtvpopw0zVW/LHsbcbLbBmTRDqSXHdNQNPr2QbVsNM/MrdcTiw8i2GjbJ8We3Lfucvc1xsifduRa6H223udW0jTZHyfdrBp+z3yU3U1lNLGl427dounEj8lFCtzWntvk+GxJj9rzjFGyK+/BxWBdn2e7H1c9Zd++xlm3f7PC5O8vmbHHk7rsdvXQ2ZtSZa+951BpNccEN3ocvcctmxnI/jnjOfvsyXIm8tx6cbdYWa+turSu19jE2I+0we00moUYl8+9t7wblLH5sw9zH2c/Zk+5MY79NDc16VsfWSggviyWXsbXCq7CRHzM+7ybGlqobI8c92b4fsl+zkj0MhyInZ+fIvgfelmFVcStI8S3amHPeSh09+K3tKHb1ZePv+PHs/cHXvXa1J9nvvtQ952qH3bJPY07eqWtjz3WWvm2hm2ytsWE3vNCUSnNmH9Y0Ft6vst97te4t5TwRyh42Xzn5dWxVj/MNWRz4nUcNdL74fRSHdhbHB8tFhzYfevK6lZ6wudH5uUdbauKkl2xbmNvOjg/P3uQcbA+l1VhtrZNDHBuP2Cav2OVj3a9fyd7QjTy3uNs09x6myaWn4O3mQrFbaTNWNLxGXjMKNVm7iSZyfs1kz4+z8z7Ld+mLNQYjmMy+e+Oq5ZRvDZXLpu5bjrzClkbeZvHep73yyLBjMjlCs+9X2W9Yysb6hNm9L83qaNgad9PLHNa3UjufomTU3DjHt1vGzu6RLevD8xJ6usp+42pPuk4knzbkPfEO2W2/cTR3v5sSCuceRWOvk3W5hJpLnN1tyZuw80rHoYNvWq27ZN45yutS9wnLxYvtuQfjMYRYuszqQ6veO1t5UG8cK9fMhskdpd1yDe+7kj332Vp3g+PW4ui5jS0mN7dUisuWY4+ioRUYxLDzyVAoVzo/02Oprhzn8s0L2S5iVTNrndhutjXMvaHWnXOTOOF9cFwzXqxwuHocI2zV4vXyxDJWrMxV9vut1s0Zw6/EgEXxKZoRYs24LtxASabX5qOvKBPmo2Ay2eLCEQh293Fzzhw+7f1X60ZtTe6pTCwse+vzFkzDepvCQezGlK039ppjONGklmuJHK6Ev84bbu0q+wNW68aqZdditN27PRhWXYxchQ7r1tjZzZXSeBHT8mAvV9zwyzhYHlaOc/mBq3WHtGHqGhsZ8Yh7ddh+/Pnos1YTOHmuJawLJrBlg0JznLZiUfri28zHfn/QQrYd2+S4RM7G1mMowiP4yD1su594Nh0ri3FEwTk7eD/XJq89R5Zh+L2r7A9erRuzMFqtG54HF9R2XqT1gBZMRshDyMIBWsZIA+SCz2a1aCFHwvML/jiXH7La7z69MAeOmD9TmoeDAOJE1yufPMQce6pZElElizMOqJHdOfkciAOffOhKtsPMyR+wDnZ9ohi2TY+6Aa0i+ufm5KRYFFKQJ8sZt7jVVmcDnhz2+8NW+12LHYGP3XQm4h5bT9OZkZwLcZrNcZRIZXH6q5AQP4dXC3zLATpiO+zghy/XzQ56jmUaMbUcMU34WfaSU9fCHnmaH30LwZQ5dZjAF5jb3QOJ5giHnnzESvZmt91ymFvsLLmgMK0Yb3a59dSbwbVxboezF+VpvFz8ZGp41IjWHjj2I1d6wrtDO7xeWYzA4y3kGbUjfWReasIqRlN1LrMBOICt8BFuWIw66zlkm5VsvKKbHIxYOfvebUCfYvLecHOBl9Wrz5Hj4wwgvWVnt2lm0i/wQfidq2y7epcCxjj3HGPgt+3OrjvvSusBN1xNwhtPXF4BXYA5gUNg+p1TU9midsP2brXfAElH6MBhmX1zaN5eRwiA1diq8xs4ixNJBAGkTSx/N95jbUG3mLdeD7+zrfYENQ5hDtMD8H2GyIHDC8+CAjUUEDgROy+0t11IplQ+DO/I8T8Dm3PoiV+tu0VeEVjbFpYY8a8gKl5nSKjZJm8E8pkoDN6pbmgIZrwBa/mM0+KPrrLDat0DPUNTK9vB+wwpDg6IzqKrM/C05hJfDTnJH1tsL2dnHzzSYJS7u8qOq3UXAp4U+eVeOc5zugwAQQWwIh3gEp1sayBLDtTCHGAafG0cshC7teOQvS/1xE5n05ZRxI1fJH4AEAJrjQMk5xFBQaaClDmdJdjitoH/E+KKRFy3c5lWskdBEhsXuiTheOxMHMXAgbdzNgVQKA+WwYQasLPYYDYe19QxKunQ77zaExTKbQR6hH2oQGuApw2w4/ZBeIhmY+82vADgr1ovRLVL+y3myqZ9HrI/aikbz8qS7ABI+KSgBCSMiyzNA+SIaHb2DKVIWTEcYTNhnTeyEcQZNxv70SvZdbOEeM0RLBJBgXEuaAilB4OgB7wydBFDjIoXXy9BAHhtAxFxVvOhgx+zkI2dyADMbHNJE/i0Zekw6jYzoGK4bnCoAQPWZgmhdmALLnsSwglXj8N+f9vVu5xjn8R3YJtE3JHxbtbbmLByeMa96Cxa9oyfCfh7/FL0OkCeTdOzrrI/diUbGIPP5oNuSMVR8i47wTww0PeRJpgeVQ8yAN1g0gZxUeOY2YEJD7c47eNWsgEME2zJqQ+bjHQHLxc2B5MbFAA18PwAk3TwD8FIID4ssYqiANfEA7O9ZSUbdUNPgI8pCmEXPi6xJid7U6iGr09bA86bDddEAMFGg7xbGyBG4u5jTz5+pSeO4wDKNlAmRNkwAoXgj2AjzSI9JsKqChnqJPzGiwyO7eBUGcXGLR/6/QkrPWHJ2W+8KixsG2wrPodYgn9Pi2pMw5sj4uFV4nl4NigW88KHsjsR5oHtP3G1Jy3EUbfo8CrNCZ50AjbOz4TqAM1jC0clTvMDLI2FIt6ZcEB8GR9ibjj2k1Z7MkCAil2wFVgfdr6PXeikRkJC0BkeA32+GJWCgdnrvm9iZ/itu1jzk1eycViTkDoFPPCmA92hTDjZIAT8ROWd7Zl3moNLBXJIQZeLyRKPouH74dM+ZbXfZbcwPsipMuBlT8aaOSJeTrG17YkgjhCLw4iGBGKf3jDJGGM01rRD9qcu9QRYRuhhQuYlDrYH/SMGqSkTUYOx0JyA2mMbHCAIXcQK44QAWCPsN/7k05b7Deu1sdlyEY3dQE8sL8x1gScPzbSzXQHHic1CgzhEWMVk9wzxRHB1lf3pK9kZLFB48/ucJgbCOkAFcQL4kvMPXsCUwjZhA/CoHlMPNoEHGlA3+iyH7M9Y7feO0657RfDgMG9ASKJswLgjwmI7xBwFTjvEJM+SJ2GvW+NpASrIH2f+M5eyWRwRVEsmTn6ryhQSCINW991W8VaBs1+Knm7wIKgq6gNTBG9FEHuV/Vkr2bbJN3rBeAWksAvgH84eLAwvbSfyxmEQ5OCfYGlxJfCxBBVVPwbqusr+7JXsOhIK1fU/KEEaRVTk5rLBfXZcW0GXfQMHwnoSZAj3EDESorCSNI5z+Tkr2Q3yTKQjQbHHuRjcuKKHRMQBM2WjTtF+0XTgm8M24BOqE7GVCCaOPfnclZ4MC8MYxSqCtzGhHGwHpK0bhCTUdTTsF2h/k4E3BK6gfjw9b5cX5Lfj7Hzeat28IYzm7BNMAhwB92DFiS5ZLdEVSgIIxX5DTWZYMYIFFM9toOUdQtIddvDzF7Itpwb3yEHBG2C3iJ/YZmL8EgDd04JvnYgOfAJhHzYTrhzixOAJAfn28MVfsNoTvC3nD46eCB2ItWEWYwVdeufHxWdAwCj+CJzwrDgFxh7rELwi9Hi8yy9cyd4MH55wWzgbNAGnmCHXYRzNxI07AH7exUxn3h/naUbiKQum9dBL+zhi7i9ayU5EqvyRP2dXZLo6HxXqFB3OUBoi3h0hIapqFBA2EYQK0D1HKR3+8otX75JDDq7GiOJ9MNtQ64UlwubCf+OheakZnz4xaDlIS/zGO+encEM78Pwq+0tW68Z2whMAs6PDcCIKx+L5xL1yqoisDDaAEKESoIUEp8I5EisC6AA11UP2ly71JBDlGeiRAbgSh2u9iLUEpIKKgRRI+IMmKhyjwEkkhN2wAaL2oCsOHuLLVutGZfms6EHmFAUcomwnENtfuEGLJ4IPJ/y0WxINQXzYMb8EzyRtSM9cZX/5at2gV9w2Rw21Q79AxkQELhDuDNTH6UMQwroMb6sH43EGm8eRgjMHL11lf8Vy3eOiUwaSw4FHOOqyzU1QBDqKOAeAgYZ3g+ZzKouAg4eAJIYrcChX2d9upSdtwLcU2F4PXoNMwaBAFfEcmeiAQ+OAEARG0UioP7gzE9nuBjMEn3Do4FeuZHvyBoTEBn8CftgqzHGG/dvhCompIZlx0xjsISahduk1nkL5Bo4vgfdV9let9sTIpOK1yS4o30AkC50CPEYrUetoUG3Cscx7NsQT7LDXomVzSJrsx7q//epdEnQRUcIIQ9+iBQb3BZEHtdY5oEVZGDFMGJs0ZXdAsBx6dDJhiThdV9nfYSUbF86v4HGbAo0C5w/Wh1fiC/aSjQpEwHgcwdFGsgpIjVEpoBi4d3P4hq9eyQY6QirgSTb4M2xUJAQkL8e5B4ETsPGOZXFBGUEPxvHhAbE+IGe82hEXl5VsT8gHCwp1upGQUz5RcAmmEODO8YHrFi7CnoLs8BKEzbA5Bh6bpITvh42tKz3BLRQF7mH6MaHPoR1F2bGohAPG4rIlUWgePy1DQrwwt3DJLUE1HXvSVrJZM8FigcYjM1kuaGzL+CudINFtEKlAYew1HoqEDhTQXkn+ZFI8oPLjzPeFbAOiB05ebN5G/iXXjQQAOwKJR+qB1AI0M/wNdgf8FhKUtReHuynzCol7lT2W75LQklzN7vCHQxrt8Qk+EJJxXDixOckO7FroLFjKADxsBWcMJuLZV9lzJZvoCFcCN4OJAnxj73bfAT5FxwPEyhaDJLYB/ia8zK1XQJtP1XRA9S1/+R1XsmH7xvABejrLZe3kHERssE2OtwpB43m/nMUJ9galiZIBptQuhbU33uc7rfbbowHsMUwE4Rc4CjaDMKeLTu7wKqxSadBEwiFbEBDZINHkeMqCet846q9Z7gmhTAL0XoIQFALLX2eFLYDlIZ0GmoA6FXFMPElIHypJCPJAnm3kwx7Y5zuvZOPSSYeLgB4d9tuDfZocmnLQHYzGEfcbC8eaOKW3c1e2kcQ/5AxExVX2d1ntifAlAD4Odq8pz0NCET3fC5kiXB073cGWQBdyAYC60Fq5BG1NrMp+7MnXrtbtOpaKYAS1JXNM3ikRbxA+iPVpuFIDjpflxrACpmDLxHGUqIBeDvQq+7uuZENcwEKg5CQZPb7BxerQAiwLTCZvbRLK63iBnrHikNkTozwcTFxQ8vAq+7utZFuOAMdae56VDOQlwUNMaMYM0knEwGD6CFeNdbURVNSqIqkNwwD/fcj+7ivZfcIe1eAgogqEP9S6q8r2x8tB55OgKnw4QlZ4Fh5F3pdcxAZhgxmah2/4HgvZqN1UpIex6h3NYOng9oaGQKtsqeIiVUZSJIn0DgE4HAWaHlUwQFB0lf11Sz2xmCk4uWfwaVOueXdol9k2IAjZGeBgzk6aB0Yn2AHxdLgWnP2A/rjK/p6rdcMVkQAAgAyjig2SaYA9snOWQ4SmR5gB9FtUPqw0gS0gArsdiDJh4NzBD36v5Z5cImKipSGyxQxANbhnZ//BVrhNwAl7CwwSTwNaxgNDSAjDKR123F/43ndkX+uQrs/9+jtfP68GKoYn7j3v0aN1veT1+U/dW+u567nVS379vfXc35/79ZLfsFjr04vv3a/1+obFc75h8ZyVrJecKOupE2W97ERZT58o65Unynr1ibLe80RZ73WirNecKOu1J8p67xNlve5EWa8/Udb7nCjrDSfKeuOJst50oqz3PVHWm0+U9X4nynr/E2V9wImyPvBEWR90oqwPPlHWh5wo60NPlPVhJ8r68BNlfcSJsj7yRFnmRFn2RFnuRFnbibL8ibLCibLiibL2E2WlE2XlE2V91ImyPvpEWR9zoqxve6Ksjz1R1sedKOstJ8r6+BNlfcKJsj7xRFmfdKKsTz5R1qecKOtTT5T1aSfK+vQTZX3GibI+80RZn3WirM8+UdbnnCjrc0+U9Xknyvr8E2V9wYmyvvBEWV90oqwvPlHWl5wo60tPlPVlJ8r68hNlfcWJsr7dibK+8kRZX3WirG9/oqzvcKKsrz5RVjlRVj1RVjtRVj9R1jhR1jxR1nc8UdZ3OlHW15wo6zufKOu7nCjra0+U9V1PlPXdTpT13U+U9T1OlPV1J8r6nifKuubIH+pj4YK9VPHmHLI1yejGkinTbio285dCTDfCXlS21vcZVS0xe20qTNJNgYf6WDhdisvTdl9rayq030jMN6srz70aZ4LLZlOptMmjxMzDYrTVjbr7lm73oNd9LCLZfpvTsBPhex/FbyrZVKHQPnoINds6ZwyudH60+FmS31PeTffmdn9k1cfCtG2aYEqsM7AVQdWxI4TB6ovLxW58fxYfgqmd/fPTltljC3N3dqbNPNTHQh0BxlZ8Mexqz27mveUebYottm0U1f2E0JyxXtV8dbi5p+Zaa25sIYdrnv1uH4sn7r3nx9TP8wX3dLrfz/PxzOl6uJ/n3f25X6PwQvt53q9ReHt6cL7kRFlPnSjrZSfKuur7fT3Un7c8+29dqOHcxFDa9LOqEUjtW7XNchr2ts/h4ii5FYeBiWPziWPmUxzZNhX7P9gPJVkbfAxW932HOgfYUHLeOKA1FVtryTNjDtKYvuY9W/XXGW5kZGPcyoP9UAxLHL1HF32o+1a6LhXWZFTAWXVztZbN6oK59WbsVv0Wtt3vIfuuBjgP9kPpowU/Yq9zD1jFWfZQy56z0+0a3cd0g30ZrXunBgOjq2APc2eKLdvtDsiqH4o1Pk9dSQ0x1mBnKVN3M0vocWu6wWFs5NOMnpzpKos2WzV2YoLdXoLP1zNztx/KfXtzt3bgW8LeXJ//1L21Pi5787p767m/P/ftzesXa3168b37tTSvXzzn9YvnrGS954my3utEWa85UdZV3x+0CXnDu6o6sey6mK3riVsedUZcr63qalLD5nQ1fpdLx/jYoWLgsMf9Ts+HlU1wOGY56IRNmDlMg6S2b85ufsyybampCUSv6qpTPYYvxZKyn3uvKrffH7IJukWS2siqylVfi8ZzXMughKyyTL9xVnUnfzMqu42YjJmLr85dLm+7+qBNaD6BQ3SFJc/QpzPOhWSD2Xy1GTCWtuiLtdP3nNKse9Pdurm5nuzGo+6f+7uyDWaqtJj2MUP1utBrDGYsq49W5AtjbqDJqBtWKaoBhjrO5FyTA6W1NO6fmeu7vvue79YEfUvYm+vzn3r0fJ18HPbmfe6t522dkevevWGx1qcX37tvI96weM4bFs9ZyXqvE2W95kRZrz1R1lXfH7IJ+Ntu1GOiGtNSGBwna21pLvTidwKqGHIG+gNMKmHKjBbDYH0tsW+Ng/mQTXA2pWS81e3n2kE6aknUdNdHd85rzVV37FKrXnege2t+tCQwoctJhC0P2gTX9qGLxCU4Pwg0EqGTjFstLZk8W9WNoKRWIR6zQKRlglX3I4s1mrk9ZBMckUwbPpW9bhgpF9yum6x++FIzW2KSdezQbMRWvshO6jZfGXn2RHhV7p/758juW7m0mBhq/oAlTCbNlNTjSbGlropVtRSpxRvP1nWvCzIWMDisoNv9M3N913ff8xvvfP1bwt5cn//Uo+fr5OOwN2+8t563dUaue/emxVqfXnzvvo140+I5b1o8ZyXrNSfKeu2Jsl53oqyrvj8YO5RStjDUKKzCVVgRIdvQdb6eiUCIcpza8WxZnYxynQQPIAszxZ+0vO8P2gTfeyUa6cXY3XaCHZv55ZABAm3qLps1eSMCgnsJu1o0mh61FngXUIl90CYM9UHK/EJidboQbGxycE27ui+oq0Xc1bIx2Ui0FlMAkzWna5a1dkKWh2yC2ScLLruMZOzdpDh3YqfZd2tagGvqoJOkxoE1l4TdnPy/S+XSSpEY6f65f+6emB06y3r1r2yJULN0Nmd4cM0cPlcBs8LDXa9qqMiP9URMNXW9bER//8xc3/Xd9/y+d77+LWFvrs9/6tHzdfJx2Jv3vbeet3VGrnv35sVan158776NePPiOW9ePGcl67UnynrdibLe50RZb3z27y9/9HybcF9Hv7XF/K99POt5MOZ/7WJfr3v3Pou1Pr343v27OCus/z6L56xkvfeJsl5/oqw3nCjrTc/+/aqHq37O1iVdC00DoJdSv4SXhOLEogPDXXz3anYdWlE7yU29QXOc6pHQ1PEvp4d6AFtC/Jl0ETINOEXd5HdQ9rHCMwAxbWpgZ6+eo9nt6sWgxoq65KkuaHt80CcCsyEsU3Lg2OS22VuJM5aqBuPwlHjXTEzh/Q70jmqeNGuHQlUvATXrHg/2AFZrPZIiMxLID34eSiGbPez7VluKrjpfLyTDJQpvpDxK724PSX3+nI339fr6Pu6+i8eES1+wTbg+/6lHz9ebx2ETVrHkSo+ve/fGxVqfXnzvft7hjYvnvHHxnJWsV54o671PlPW6E2Vd9f0hm+DgxyyRpgi/DDe1A21h0zfydeQ5L90kK1xhIQ9BfrOFGrwVUNyKgYi/9Q5c2oQ42yA3sIPzyHQ6+DqSnurkFUDMW1ZvP4LPCtV1ub6u5uPW9JLVKA7r8zBOxkpBHphYI9nIfW/q7lnJEuS0E/5n6zPBNWYhsPqwD6LmxtEmt1HG3spDNoHfrpvzO8gVG5C24ciUkAshbbuRKckpKkOSoRua8DyWA67CwEr24npL7R2x8/Ntwhvvref+/vz3xs73cwNvWjznTYvnrGS98kRZ732irDNj5xdiE4y6FthpJ2R/LqabCRlF1n+LNuLYnZowNIg8kn0ujD3tTmULuSp5z4+3h/Kclt9V7zXIP5e6QmYygZPUJAEmeT4SBDPC0I0GG+VIR2zWqEuV2hvZbdvHQ/aG5GaF0OOwh6ymedg0m8K+TfW/q07DAdQFrIcZRlennWzx5ZimsIsVfNDe2K3AI+xO40vUGtpV0Y0+7WqtaIdIwYbxVBs6sIKBdQPWDNBHUr+x0V8If//GO1//1mATHjd//8Z767m/P/+9NuE+f/+txSacaaseh315MHbItaYCTIbzcuS94KLzTlI8q9F47JxTwHkJdlczedgjIHkBP4x9tG0bLT9oEyyAWwcLH95U9TONGq/xoGl8KV19Vv2lMcpUp+cJd2+ynjRUR1Xrg3nO4UEFgeRC2bAvZhc3Tyixw9jDl1VQvWxZUlvtNF2x2DirWTrBWYi7B2Me0+CzjFpmzkpYQjbSDUP6Dk5w1ESwE/qAEWzq8MPD2BwLlzdsSDH5kY6apbv25lu7TXhM/MaDNuHu/nxr4Ni/tdqEM+3eVd8fjB1qwOGN1KMnuz6JnksNZLDbTn58I+onPiimeNxv6lNah6UATAwS6yY2+83gBJUCNH+Z+1O2NDg3xBB78qKqyQqabknXkzLE4YLIKzmzEGD74c6Tf3A+lOm1943TuF1auqvdlHqUxR2SwyVyYikGN7Jx1qtJc4K/JhtJvp6kXxq3uevLPOdemmqzLv30N363Ki4gYJoeu6jWuH7HhPpQZoj1UlQ0MvjDsIuqVnghdUVvvPP1bw024XHXFb3x3nru789/r004M1f2v4JNuOr7O2ptn6+jj6vW9n4e4+2pQ33DibJef6Ks150o677fWvkWs2lkHHRywsXknWjUbXsAYpKjJTG8q0eszcS11QMzNSYjJeJayKq087cH8aax6i5OoFkkq/jdlU3/HYB/vsXoS9WASlK2goFqk9kdDwiuXxrDPlhra9VnGh87bbNq6D4v3Ynbrqa0fAQNrmh1rwGf6P3QxKKUALJQ2QN+KvYH8+W5Zkt6gGXiqaH8ctFHV0kvWWIA7tBcG3hBUy+d84NaWgbC38Ti23x4PiALIzsQNQ1ha+pt7yycwa5qF4+L9HmwxXU60XZtzuT4QoAIyN4pSfFgXF72NEiTB+jIlNW9l0VmeVJvd0S2ixyHYzemsVFdEzvwzs33pNFUD/GAnO9+mV8zKkntpHajczQgQBF3oQ8ltbk0SSYK2g1EZ+GzmUZ+RaVID+biNYZB4666eEWrOif1zvUwLdOWUEwk06BxdejLIF8ySaOIXiGegWL07X5u4bl70hHop4u60pHJYDheFxvi+TcIbY+aHVnYlpT3WoLmN10GtTqn/sHtwTw/LEzULMldfdsvY5Sgb9ieEP0oLfK8xvIzARpcjOOHrKkwRJwqr1b9V9lvWsmucKneTTZArVs5mcNB7gbCSQ0SMM67zU8VSzkRsdUV9EjB2mZrT7c5CO+7kk32iQ0sO7kkTzjWEgGkJsnlQRjpvSYI7OKfpwrsoXhNipfRHLvP250+2m9evUtdA+rqbVs5NgMTAjO8wxgXazRUdmhW2DTDkEAaJZYS1D7ZX+7gNH8786v5gDZJGRANoT2j08FReVvpZY9gbKj7IDgN7DSautVydZrHsDWYLYzbsSer+YCWhBfqi0mCex/GscnA0tS9vbxFh3WyZVRwvBMyLpZ8WiZTYKDEa7jNTFzOB/S7porpXAdihLZnjUlEEiheowvJONhZd3VpxUr1uKUCmZaNCl8JEI6zs5oPaIjWPchZfLvdvNl3OLa+s81EDGrHbDECZBc0f5REneZW7alZ0g9NU3mOGpnVfEC3qxc0ZF9unrVHjhLJygKjR+KPN6pW8RxBgDyL4B0TgJRm2qh8c3KgrrI/eLXfI5eWlH6YTjO6IsYta7pSHcph7gQk2WITC7Zd49BMhJCo5DAG5jfcetCv5gO6zslGTzVBYCRX4xZ7QplHTn6PtaqNOUREylETvWrkNWBoI1zKZQzIEYut5gPq0ojuSXRHEKPDrOLtS9vsgr4TJZEMgu/RQyxp16hu+i5oqsZQT++DV13OB2xGHexN77liKPRhA6Ee7rNpIhHHWxfaEubPq4e36CReBq6YRBEG57j3spoP6DQVoPehZFVvZJ2HNeh4KQ1XifE3uFFnjeZeFNJSwQ95T42PjaSwb/dHlvMBMaLwUrFq8on6dHcLKQ4FPHrrWSZFDDCpoaGZbNvmA0ZgTrwqXw/tsLGr+YAWs6xpLS5sVa+O98gnIXIGJJBRxwSaS4tesuF1n9i+jQDTaggIuML2g2szS9lk6lkUGX2ARMNvapqjc5glUoHRatZR0s0+1FGTD52qdAN5rcuI037YqtV8QMw9HpXPvl+GQZGUd1MVeBDh5A1IxG/JFc2J0LyBkjQTJNkuCpFHb7cZIqv5gA6rA9bgWHa8YrMcoJE2+Db14x6qZoWMbD0GMFXCFgCmumLx7DVjyRyzIVbzAY0q8g360au9NJkOF4hFtl9TKFiYOuVjlrDzSbxDiJtHMbHrnHmQ2FX2cj5gQqEwIGAqNcrX0SABSpIzRo2ohCHE1XsfdI0SSOqwPt1HDZauW4LnuMpezgdEGOq98fLzVnthQUG3JrHNmvGGqkBKFhxnjKBMvEfmgwJQpvqM+5t+x5WeuLHtCdioGyAaGQdh2vJkj0MJAqEwJClVjeuruw28U2M3MJBwBg7ksN/L+YA4EnwU+iXrjTtPpqhZ99zA15pzCpWq6bk4f43Zxh1M/LDa6Uud7KGDq/mAEMK9tKLpaWrS7TVhpWmC1TZADjmzsxpDiA+KDm/Gy3E8i5+aKga/zR5czgfU4AvllEpy7IkG/oK9Neyb37eQSLovPISm7IAFI1XcQcvQ2F3c0i1XvpwPKPI59Bk9SS4d/KB7blZ3ViCpNqXfx6UNv0aeEFdMdc8veNC5ZyXZr7KX8wFjIdO1a4QA+Kn7rWcwCG+rA7g3vFkQcuXgo6jk/KLmF0c+nQNYFfzpVfZ6PuCuV7NtbdO05q653pDtIu/sNpVX23i/uF/sTMo8STXnKKYmF+QWDv1ezQeEto94cgNGZhPgzzYN/mWfmwbeoiWySGQLUgGGY195E6VNwrYCBKi3/V7NB+Q8km3cheejUZESbD1U3NCwkuwVKZDhM5smWfii8QC4IaITIBeQnUjgKns5HxCkZ1U0BFxlL91lbr0VGhkan6iTXgYHEh3fA/Ei0JOoEsVN1QZyBFfZb1nJJoYqGqGOnQ85siUgTtQi8p+FrbB1fwZxaUvk0XDvbHbX6HuU9fANH7/a71E2B5QHXW46IylttgG/SWwA1wb7GtmzlgmAcEATU4zXdlkJVALBcrzLT1jJzpy7nqIoXCwbIW/Fh5m47xhYvwsFsOzoZMtaN3gLBQ2gCENaiYzNVfYnrt4lh88UAxDDABr2t6SsCXOa99iwgjtxw9wuvfQ57KjfkAXcgFhGQ8AOW7WcD6gMNyz0ZghMiO303qaGkNWxGc1xZVuHQqjLZHpHrNVYL0H/1KzZm59fzgfsk0M89sg5y6rDQXFwuRZ0S4Q9sSZsOzo0cHuEZjhugcfO8YmFs3voyWo+INEAgKFJSXCVQEsS3blOVeF0TiVYnGw4UCdjJgkkki6uYK+iRr3sGMyr7NV8QLebjQS+AUQAdwjFNOG7A3Pwv6gFuxLgHwjodUE5pAZRUTUTwmoMEEblKns1H9AmzmXKKtGBFDDeE+zusCkxXKIS68XdE6eQcoDV0MTHolHjmrLkbL7VEX76ak+84kqi6D4IVlufYBB4g+JqIqLVrbwEdAE9aKCX2e0Ea6EmESXda7MPzgckscehGRr4NKXYG9EBu2y9Bi5o/CdBH7FsVIypov48wUo7UEPTLoi9rrKX8wF5R26/VNNrECjZVjBPbhVgRq4lqstCxx8AHxRpmlEvX8CwVIDjnbniq/mAJEQR2PKuoRhOs1XgUwrkSNQU0yrkkkbW5U9eIQYb+wvoymazKvW3h56s5gNaWdhNQ/aUpyECd5tm3HMIdQuip6GhIRVjg7PRHW9CFhCb8XAzWKrbzPLVfECOGi8FuFqnRhARUF0KP6qV7qDunhjLcmqxCVZlWmyzgu5SRqhYw2Pdq/mANshbgfpm0cX7ovupNgU+8yTELnmiekk+b9NANai9rsGbKiOB9CGwusr+vNW7rBhVsBmBqUdmH3BhcCiheJ5KRFzzmOoLwpbzMoE+eyQYJdLImrF7syer+YAO1kKzhrzRlfsGQ4cVJ6NeAR+gCrBFIGby6gPAj+jSvAXEQOCokG6/YfvVfEC4DPGh2HmYQDTF4/jhTjSlRM/kOClCJLrlUXhKzTklbMQvWT4tDOJV9mo+IJqK0dO8T/AvdFEjlCe1B4XpkYR6DNLnQcPeioehIHloiRQ3C9jsmvt8lb2aD4gWE0Bx7HZenL9M1CzYQQKpeaENWRrB7SR0Sezvrsw8af99k542d5sH88VrPamaX1sUpE/+ZaYqpILuzuDigWcaq2TgZ4pG0g7YFKP71vg/YO5tts+XLGQb4LDQNr5LERgGdETUzxK2EU1qWhbxGJ4Caoy4c2giFxErrNjeNaHs0JPlfEA8OUQEAY9GdOIMsFFNlVgFxg1gJL7REIZDvZa91YLPIL4nj8lR1cS5q+zVfEAF1rhruZysodHkTJ2AMgGf5k0lngEG2jpOGorPaTDPFJWtQC46f+z3cj4gR27sOFXNsCImMJweebao+dAccU1MNipNgQgRDNdVL7YDe6B9sQf2+YqlDmL7YQGaJsdCLBKqa8RZ3xA6MOakuvUusU5SFvC3qkBdgYKHcovmsFWr+YDWBpQYz4K2wZUOzVFXoevQ6OiIxQb2Q0pvcBxKMYSuzR/wTzALJuTDVq3mA5qtiytQ/puDuBW9VZwVdEeCreH0AG8x7hDVGi2pwXJ8lcxAudA345C9mg/oFOhq2HvW1FhDYD0JftAOXnHj1SrIdLr2ik/XnOedOBtOVZMZE1jgwfmATv1LLAbOwMoQ34jYwBqpFrlH1E+9g2C6HdEnlIEdGs+K/dlTzrtaLF1lr+YDOsjn7MWGcpzhoe0lQAHNF+iGfPFihEJyQQ2XjdEhOiH4Jx8QNd7piBu+eiW7qXJIXNquGddE05CjGRq12XiZ6wfvNfUkjVYCHk++7vgYhP5FJ/Mqu6z0BKetcWiw2ya1oEnzkCYa40w6gShiYBKiWr4MzcQipieSdQBGXzC7GJyr7LqSjamo/D7iPLuQWK9GHEIx7gZymZAZhAPy0bW/TNAJ0iLWirpkiA3aD/1uC9kAQeiLrvZMnDujMVrDb9hBEgUY20iA0gn9CITBbcRDBDpFdAugjujuNs9rNR9QYRMRFIgEeEkYDxoEP2kcOKHTZbwe55bFWgwVFCfOXc0hKhalEwCUB+cDatAtyaLO+4Tc9SBlUn8t6u62n5tGjxJLWAtjM0ByXVR7w+CCMQwJH3PYk9V8QFkRUbybHA/vi7OpipCke5QVc93VQqJpyiP0rMVHw/qOpiLVKvtyxFKr+YDwlgroO2wrLhzahZgX+m6AmwPhti7foPSaaldCzCjq5GtiVQlpCbmPd7maDwidpdnMHM+NdXP4BiwEoTpZAmDPjJcBtwQMQBjcjuAWxww2CMTJD9/q/L5mJbtqXB+rguAirhfFRNaOJAz5DSPujeDY4Jf7DhzEfeqtECGTTyUPF2/3Zr/zUgdJVibIL9URoluRoAqORiCLgAnH4jT7VUMaZYEhTmS1sjKAZDOBu1fZq/mAYDZMPQRMIUJtirYnpK8T+c9RB8LjnwFoZPJIcWrUtSbukSbjCBV1ULnKXs0HRCmmGEdcgdrJQccGGKoNO0q0hx3Qlhlw1sUI4K2xyFjXBk2OFY43e7KcD0ickzUzcZCFmrojBUCOoGaQIIFvU+4M2kuTeiN+e1TlY1zWZwve3eYur+YD6noEcd3GEcSLE04JCsKawP+h1rLSmVAb1VArJhDVRr4mc/w5FlBdt1mPq/mAIJFZNaNObV44m2Rzm8IxeBOwhGalwkYTMFgMICGirjQDwgGETlhpHvr9PVZ7QhRCQOI09o5gmk/B78G5Qv9jlITQKpF+EY8S8J2X1lMYduJLfD1fu8r+uqWegHrhLHn7bYdMJFvMkYHKhcbEynL+SFqOZwAb1rVG+NhN9pBkWd5u80ZX8wE1cpEc0MYxLmKMNnS7wewqkuTsCLuASZRxBTmny/hEONlgNReWHzpi1+V8wK7ugsrtk3DlQEBOxdnx7PhKCA4RSx3uk4OE3dIFmlx4m5w0OMjWbrMev3617nA5v9iPysoMtD9oHq4DW5vFv0hXiu714fvIbhOHRE0P5by3pjz7VfY3rN7lDs8H94lSGOU7UXf1I1RGm+fBY/ACNxEUO/YGvs9qMDvZQswJgVs49uT7rPbE4EDU71H8lq4wwU/jdcE/inox3qKOg8aGkj5pEwsBGueYzmE3LNphq77vSjYxaPLK4cyiU0xOC5IOulD5JxS9i9dradNYRo2vJMsEe89Pt8bf4rEn32+53wBJtNXwwSfEFUYU4A70RKUnrAo4f14KLsD5QRPQCag2nWD8W7U37vH7r9ZNQLdpJnEWniUahfEAR0ARArYhGmAklGmFneAAwB1kAs2mebfEydu88Ww/YLVuKHI1fgF77Fl0G84kqG6bBJcj6NS9jm7gBjCRDkMPh61DDJ3Py3T+wJo/cLlujD7xwhQZAWWMcUNDooVa5GVtXcNi2Rt8mRVoRF2aqFBBfmG6A2v+oJVszTzGlcDDd2BVlo2DE22dnBSUAeiqXO6JCmKpiwL7t6OL8zKgut3us/zglezLvGVyTaL6efOqHSc8tspFK2KGzBPrue2bylWDl9B0aZTHszHtV9k/ZLXfk0SWEWVHdlkSgQ5dPN1US1ASbCVqvLuwfkzyOiA1EsWCKzBd7tjvt67WDa7jVJPbwcV0lI2oVZU0yjzIGnkNiCY9XRUFAY5Qf+g24lCl1Mtt3T90IZssPqAAZatkPEk1ki0CTWTBIayduqoGsb7EmwreyAwSWZA4BHuq2OI2B/iHrfaEhPMzEAlLlJLyoHhalZoQnZKlA1CRrtpLzZe19qqfrCJWIGj6rf7khy/3G9pC5M5+KbGAIgVDKpzeeaeQ3IKeA8NCYF6nBs7zNXTbQOVvpdz6kfyIlWyMEDtsm2KaIOhTxKuRUNoFFIjLUE7yNMRN0FViDQHGvOKscp14m0v7I1f7rV6KmKEgylf5WmgMAxPmNg2Zh6UvmnEL46OBy55YWdVodRjQNKcrHXvyo1Z6orugHEtVpxVen7aFl0uamHyMvbw0LXgjUwykExZXTxRLRFwJNG9zrn/0UjZ67Dpxnakqs0JKFGtZSTI6Te6dGv89dxj4KY6Fs6AgNvA1ANnNN/yY1Z5g6tCKQLKmIBDrH8RJpH3C0oJydswSITjfAdUTXJJF4cQSamWjPNjBzXzjSjbawa/i4yH7cAFWFVXkMCGhA1ygV9yKVYUaU8qUTcHKT7VwIoeuGqCr7B+72hO76cYKW016gReFK+eoAO9x7ZFjhPutg8htg5MFzkE9EHfzQrzK1PIth/7jVrJ1R7YV5bo2kjkwP7AY5PmxIyq3ghkgSiUpIpZ+d8p1gtWxEmr/BRV0vMsfv9oTkhkcBjJ+GLuoyIPDht0t5I+Bw+I2N10i1jDurfChSDQALLyqsUq/1RL9hIVso9tBZFiNJlcrr80OgGgTOJ9IB8/QdG2hVkB4z9gakpsOvhSnQegybncGf+JqT+ASLQfOGJI5oAVYjSR+jp1RQ0FOEqH7zoezyqGolIkQBfOFK8RW9cMX/6SVbFZUgZGbOjpPNWAmSIXSjYRSui/FV3XNwasCBogfVZSRlByHBuXwHDb2Jy/XTcaJs0bUjcmvKoOauoLht4gyBxWdoDQTbgh2FTaBRLGqXVUnKmrl2JOfspKN5WjFTmkI5pnsg+gfNXUg7Qr7qzqXSwUlAbg0VR1xdf0Lbp0XYQ9s/1NX75L8DkwdMRN2aaqHEYprdEMLohOmFnp0TDEzRbfLSa0BCoziBni2Sqx5lf3TFrJZMW5sJjI8ZFSbelFgRCpHm5ORlHQUsoD/4SBCjcGIZdDjRDWt2bdbfPnTV7I3NArfh7caylsScfsBmN+V3ceAOEF6qO50gYnwbkC7pra1EOKEMsee/IzVnmCVGkcGGi9uHVaRUxeINwjVFV5CqeDujaAUcfkOKVi2YbESRPS8qnH4nZ+5ks0by0QAwamiB9/gldBE2YvVVsFkkvUVbwiDPyFpqooIo3IaTRPSD3vys1Z6os7BVm33lLMlqCKnVgGVWF6juhBnFFCA0eFPd3AiBmLfVYpFgsPciQF/9mq/SdZsGFkwCIZfATU7RN7Oq6oXnjuNoKoZ1XU1mFKBkkI4iyfyk6Dz0JOfs9xvlbKJES0xqvYOaGnAB/gVomScIvjJEKAJfaoebIPuC4SARMckEPfDN/zc5boBZCoCgyAiOzKEzyK5B6hi3cbmw4wN1gtPh0ULnHrMecW+KafBaT1qW37eat1F5cag04kmqowoOh06YtUumO8U1apnMslz3jdsgVPmWtYFPxjbYWN//updEttOHbKEhwL2AM2QXBWbEpsljrcaPRJbQKxlJVI6Uc9U82WfSNgdPu0XrPak6xYXZ9gOlFbMIMCB5EgTGSDWbTQA8j43aI2o8s2CMzWT1BUeY7+dy1+4Wje2WIkLMoCgYnAvuIaYkgO/jcpxJcARVIG/gxhg94jpnArgMDfqr33I/kWr/QaRKOIAkhFpW84NSBUyF7IxgQUv7awFeYCyM27EueGSffNwWhN/dOCTX7zaE8xQV7ftRiwdOCa7biWQ1kGSALhiN0gxmAihOHCgN3mD+CCAa/EOR/1LVutmzRp/ACtPFjVYGBQDURoIO3m5Hpsl6AIV2PfBBsFyKKZjE/XSgYpX2d+0WjenPWEyk5IAuEZwzdAFOfwbWzPV85uEEREg3AGuhnUXVfNDkokJ2Q/9/qXL/c47oRkUQFGzPBxVgHokAdowu+w4bAd+JsA5IREqbiMtQPjWSYB3FUteZf+ypezSINahuVVQoApwMCHaLNoVFJJU6KdWCkNlaagddKfbWIxeE+Tt4Yt/+WpPDKYhQl+q6oaNlX0D4gDcEn5CXQgFPy91Naq2hd7AsqH6RaztvNWt/4rVuqF3oPY95L9qs1CbqjsGIE3PGddtACccO0GapCGwjb5jH4vKMciNpQOf/MrVutlr8BS2vk/kwkL5qWLsTddjICXBxhAIeRawLJQHVD4ogly1uiqjPMe7/FUL2ZzfQWyXxaF1khR4HVWgqG5XuAdAN1g9oBJqHe4NxAh5l9T6BeDTbpzSr16+y0n6hayAyNigsBesh+YFFbP2y413UlOEELEZ9aMi7CRNT8zfcf37rUbk16z2BN5fNd7VBNhW2G0oJPIfJKug8nlz5EdA3pfW1ZNviAxTVUrbPIEJFucq+9euZOMAlfQqyctkuwJxDOYpwmzSPewjjAekGLxVz5sTPs4imYhsoVmPPfl1K9kEUEaVr+rkCP1veIGEkQ1mhlfbB64loJu4ji3I9UC6Q5hOlXk2ZZWusn/96l1adbqMUCVOl4dJwcOqER34rja7GADSuLJRIB/iNT4Q/jnMZK0Cwn6zJ79h9S7xv6XDDQZVMhIeIA/sAYiNSu+I24V042Nkxa4CtgCWqFgAxIXru8r+jat1pyR3qUKKBLFDEAZPA0axbA++csdIE5ajKANHEdVegJyjLrBAIaop5lX2b1qtuz/DnmQtWb16VTbgNKcFMwjohlsmRcN24wtEF+CCiCubapVAebd6+9+8epcksbzuL5GQhnIg0oT5VUPmXSnEy62soDS1EtuEwgF7AKc9yLluE3LykP1bVusmfsliTdThk7WBzgA7GGjoXgiJHWQYFAgjDBoLECRECNsHrON9lsNf/tbVfjfgqoUmarpgh02pBIEQgVlMilNTCkC3quTIW6iU36hfkxqy8Dux33JHv2217oRdiroJ04KKjrF3rRZ36Q6jSna4SAg17Gvj3bIxgDAiWY873Z2aW11l//aVbGVrL6lluAHxVeQZvKjXoBoGor6BYbRy65zSphIau1+qozlhONVjT37HSvZGlAM6IZm4Ax3VfoKAWyEqh7KJmYZ1U94SXldwYMAeENiqNGiqlPoq+3euZOfYSdDCbZJ4YyPgxpLiyCAF30RtqogfzinIR8A9QKrgTFTHdbmyf5X9u1bvkiWR4ME9aZwSBmivsaoH9Q5xiXNPuhSl1gG8ya6OO71kbbWTkTS3+zu/eyU7QMV6CJopDVRQwOEOVaUnTQVytmPeEwEKuY0KjHM1GpHwmv7BET3W/XtWsjUgiWi96ualKgouV4rI8RNyQgI6kKH6H+zb5fIAOUhMT1FgiHnDKx3Y/veuZIPtdtk0KDFSXmFTR26SZfAjUMgeSkMV5ABDonoFbJx/jUmC2VYr81uu7vctZMOywmvjFjjKYnzmJSrDzzWvChRiFN6sSnHg+kIn408CDFIGeNHU5OXQ79+/0hMwAYLJN4u53C41M143/1gnhiCB2XS/6FI/F8YmB78RIHLgCjD9do/xD6z2BPMWs8qXna5NAS/hxMiCmWdOurAaQT6ZEQysVQkaCTJSSnqM7lkdeak/uFp34LPhD3nlpA90x8OB9MATutFAJE+ACPUDf8SZDJ2kOIi3ASAIkvFBt3zaH1rttw8gmQTTgAlMqsX0wHBMuYqdiTp1qRNBmBmF/NAyDTgDZeqsbOQtBvzDqz2BiAAi2ZhVQgEYzEQRG3RXhUw2ghVo0uQtEpkQ5MOCTqAtwQXmZhBCX2X/kdWeCMNCQmElhicsUb03AfbF9LJErIBVAzAxY2maQCqdDBMofUS1pb5hzT+6WndSBatp5HFYnjTNgfSLQgYoWuAb0R6nhxBYNTC8Yt0VICtRlBMIN1v1x5br3nR3UUPImpJ9ZSpPn4xIaEwK4hM/oHtpDfKH4A3qeoskoYtv4NpDT/74SrYajxGoQ+qQVLBQJMqkE/p65cnReNwoqWTVsIH0iZ5mgTkgI0ZgjCE7zuWfWOkJCWDIRVWeEf1zivAIKtsA72t+Gg49XrJdyjjwwVS5nXVtsrgN6uV2b/RPrtaNubMRvKrTbXUtGX6NVAuaUIlNKpbRwKND3APKSxGo3TSTRCMS4MMP2X9q+S4xfBg4wB18GuKxp8QQKoMtGoa3iyIA9/MCaxRfg7Mk8IK6wW23W53pn17tCW+HFUXdv5ikpPHdTTcUa9qVMBtwPNClVTffdl0Qx7Ri1UTM4HzS7Q7Zn1nJJq9thNUrPDQkF0AMiArZQGxPvJnI0wG+lXk0mngTB/x6VM1S0yyG29n5syvZ8FRBdwBFPGI7iCiVViNWvXTIA/zBc6ioi6xv8rqyTLJTYRqUGBH9ge3/3FpPiG6t7lmycgATJ0cHCHaTQLlMMXhNicgUdQuewI1txl+SjyRmu80L/PMr2QQtLYuxIJ+Pw40qddxEqLFokhGXqH6PVZcvsbOQQhxV8KbSkJzXI077C8v9FmjIQlC6vIVpkYFV8f1Eswf5v5x0tvA4mlAWRGLrtrqqt1GbI274iwvZBtPQyY42zL3SzgSQfG7QICce71jUEwjEUzCRI4q53y5pJk6ozNl+7PdfWsm+VMxUpwtZYGALEekq5HQkosJAd7FUQwAaiwixsYEENh3YpOJw6NWr7L+83G+JSqofLLwjMpd7kB8g/MY7DN3j5Jyi42TZyH7B5ZE8grmSkqd4u/PxVxayiVp0mVL90dRMgNDDqtpvKkLtCREgfbJibLcmTNpYdL0HLYGL9So3vcr+q6s94VCkXfeXMU44TWTkINKLYALODo3waoda1FOgjKC2aolYDluiC4O3PPdfW8mGgd0cr3HorhVYByW4DKCSpgFC+RRdGCaCGDTXBGYFK7iBvXQx1hwY+a+v9oSMdmYPCDfypd9GHKCfrouB5DRA+SpetBiDKrOjbpO40sYR2CBa261+8G+s3qVNytVqdbwbyEZcFx+5qoTGodO6lATnrgtfhFqEs2qkqQojXCeI5diTv7mSvQHYKol9sogyIHgEp8tpRGuEJBU0AtQkyt54uXhVjjBcJ0Al42PhW48z/7dWezLVOJcPjrHrmG1lu2C+oGNAQeRMs1LUU1fEdzZjDPUGAQsEqzBju9WI/O3Vu0yqKofDNSQC1B4XCpDks8g2mO6menYRSLoH26SaML9Q7z2rLYPo66vsv7OSjfcKbAkEMZQIgAe1Jhls5HP3S3Gb9hhiKkB+p9I29B8sCp0Ncmm3mvi/u9pvnCPBDu7AgWXIMAJVsabeog1grtgBrMRXRPCQJZhXp6pFZSjYMHcH+/y9pWz4haibtCqgBx57mW8VEPLrSpxDeMh1YPg46qIOhNSJenASQrpX2X9/JVtcJmlzDxj2SpOAj3Vr0VVdmdgi7AGATumS/ZIJIFNV0fkEd1N1yfsq+x+sZKu/QmG1QHcptSgSqNkphtETcm8bnJUKhqFo1ecZeCGyPelCL4b5WPc/XMmGw8AyY7LxhT4Sbg4yoLULcgJdL/xVwO/qanux8haqZGgQZOStSU5eZf+j5bp147lW9XVjy9NuVL2ZAh4GWgAx0vuJwyR4U4dJSLCoilpdoCRyPvz8P17JtnCsqriDVSRFpTuWlogng0SIJIIq6C4lvzqF6iC0j8RHxX83FDXdfNo/WcgmB6cmcGrogTTd4yGNoB4FGLndCGPOLrOLk9+tJk+pOmCTD6nKaxzn8p+uZGOelIeEatgwoip557yjx2ofRG7+kvwjsoAkh/qGMtjR86Sq066VH+/yny1kw/tAkg44RjQcShsYu0U1nADqqwOIkqD4YpKYu3qIkruHNsQwl0vV3O0u7T9fyea4oN/k/gXGiA4UYKpbDgQ1/k0dCyBXMIpNHVGQjAu2irt11bve7mX8i5Vs+LWp1A5JB10ZThobGCMHU1O5OJ4VlVFGQoMB8Hu8DYzApe8v8dqtBupfrvbbq5TSafghObkBpQ5hBRnEb4u1Vxdl2KCAGZcpA5ji7AAX2IKmtMqBkf/VQjbvMGeYqAkTZjjnIgggacBqZC52L6fjcNdWTU7VN4ef0b3pqCGm6Prh5//1Sja2BFDPMdMtkgxgFQ0jzncD+SlpJYI+wTA13Qjr6pLoNE6iiu28xa7/ZrXfZW/oAomM6sgOjd5m0/VKoD45XTAXhAY5l4F5xIJAVE/NloYUhoEnRjkw279d7be6nSjhWuPeNZjR6woWcCzu6ipAuNrVnDZhwUQJApO7jFi4bCCp9Kvsf7daty4A+5DEn4E4h9UFpzrgYPASutGqfi0QFOSYIK0xD001/3j6jnG544v//Wq/ySCQNMI+7MrBpGeqezvqBoMyCbFx7WwzbDp6Ey/UdFECifdAxHGLpf7Dak+IpHHdfcfkkUkMDeeJsRu7Yr+ZzLwUc6I/m8oWQBwqY4C3ggJw+OPDDv7HlWz4aYKXAQMBUZVJyWy56OYzzq4GDRIhrwEM1800IJUaZzecPlRFM8RVh578p9WeQDaAJ4FXRWUKSTlQ1eWoXZXTjXrSi1UVoJhcaCCgT1GjM/YMspIsxVX2f16uG8mchapq+EksBVfVSDgXGI6q9hKxqeeb6i50p2zgp1FKxxsvikyP/f7fVrI5GbrnjObuyrKAnKSFoWheIH7oMgjBahg6SW79jUO2EzZY8jCl3jDEf1ntifqbBMUDKDmmBWcsxifopjzpEMVTvJGhDjMA9Uv+b1MgUIG6gnRX2f91IZsMmcK9Ch9gSfFgSK0aEnDGiZRI/ajcRK0vUEvwVdRF5iSihWCU13277/r/WK27Yz4jyVDOJUY6ATDJkpDPgl2ymq5CuhxssQO4AJxNZbnAtUsvrakM5FX2/3O139GrMJa4A4IfVE9GeBqRaHKOABfAYRa0DSLekuhZTG5WcYrw4e3e0f++km10SR77Cb5TYzRfRKZlxY/sOTSerhSSt+B4duiqQm50Dxc1hMsCH15l/79We6J+NwODzbnB2lcws21dTSJ0fwHip8CagAxNJN8FT6ArpmyQFuHTnXmV/+/Vu4THIN2qOoQOd7Un9d5SYSNMXVPDkk155F3ehxR0n5eKVzk2uDKWdcQk/5/VnnhR/rr2aHW5BnYG68/vkfEpqqiZ6nCjgXhhiPkk/cpWqyehMvf51lfu/1jJJtyCs0oNL+jVV4Z4ig1AGyDvsH/K0mGsPY/DwRvdmkoorZjPFPJ2+Ib/72pPvKJGP7GjO5l33QSC2t0vwRnUo8hUgkDSUAKGRRfiQEM8RrkZ4pZD9v9vtW5l56fKpnEIXde/s7iAS19GcZyExEO5x5GgxayKZ1TNAZ2su/rxlhP4/69kA+JV6Jpqd7rZRbCq68Xg16SWC0SQjvgaXCteZceANyytKUFDRFXDdJX9fy5kWyhSSwAGyB7RstFwsVkdXCAvOUVVzSPxnhh33djTtQmyQFDlZGZVC3zIfuZ/7skGX6r4FhZJ98W7iJJN4Iw0IBTmxg5VbDCpqqkLukEN2Wc01Q8VAN3qwp54YrUn6oOFod0x/iqC1ZQIjS4M6t45nbp8aOAiYASiSVSe1Rh7gKYhtRcPO/hOq3VPVTtsmi5FrE1gRqBuIVBKFpokIaIJFKTulWLQh0PPsQTwtnxMUPKBv9/5iZUOGifq33Srm0eg790Qz2peBpaIkBZoNKvXeGllcgmdJ0aeowo5icM87OCLVntCyNjQKdKpFgBoG/tJgEc+BCCEhzYkfKaKTchKkN9VY0n1acM9geTcra73xSvZGCnOJVmzpBvnQijb5fhc+puoAyhH3BB5G42WJBXJy4dmI07XLZZbbcu7rPY7i2ITp7SRMFO0QdJZvTOtKRp3a2RTSHRB3akTZoCjIYz2mMOdc3WzJy9Z6iBuIRBXKpNTXQAVhwzwA9uky0xwvGZQZz8SrwB65TPFnmLceSW8nqvsd13tCc5pAwruhJiWzI7uXnSyc2A/9Fg++pICZ4fAWMSEVc1BLS9fHVeIvK6yn1zJVkVJIuRTpK5uWvw82C17zh3ojVDEyp1FuF3iNY0QVycTnKmuJmzpwBBPrfZE5dab+DPd02Ub4TDAtIKZELGkFZsGpZMz1uxUDCtQ3WvAKA5Jdu2Id1663BPy/apSMZfabnTC7FhQ1BpojAFTQR7vQ8dXbabIa2hQO/+X1HPvlqt72WrdquOD2wAjsxP4YXQhXEo4NNABylN3UXHBVWUKXiVh2AbeDH9X1dfh016+WjdUJRaNDSVdq2tiuoGwqe7Yk7wIHteCc8DAk1sEeO14JYLPqK5XUEa3Ox/vtlp3Y7Fe7gHCBaWBhVG5argUHw6VWQ51IiLMx5zgKIrS4bpLoVa52R226hUre6LGRUoQw1UTWE61lZDDzR3jh4khT3IpC3CyB0qx77L2hKIqWcLMXmU/vdqTogYL5FMCVNSoahaYcRBG7S5j1o0jyHygX9Wtsqz6+EaKx4A+QT7GHLJfudoT4LdRg03WwDmGTiSJBHIlC1DVMD8WUjsYW8DrfunIBYkyVIWncB5XdJX97ivZvESSdLqE6byacQ5V/1y8wlSjRmKDqetMuMiixgqqs8Hd6YJTz3c4pVet/U7SvW2OCW+eHAlUyYZLDuKWIZfBFHEA2XQJJ2PoN6PL87qtxJdR+Kvs91i9y+C8xg6CGEDrZIw2lgjeVuUfCa8JTqnEml2Fq9lo7lKeaI4KUkg27ce6X72SjXkjV0GcpAalsnucuS6ABTGzc3SwUBWsAOerRnlK5AcVFuiett9vvQ2/zWpPelJBE4ZDGQtAB66MT6I6wqQMF2EVMAWOIqhzycQL5wYJXOFsCLFunNJ7rtZ9OYNkcWysmCWvsnFYL0jZorxUuNQ3o45Rl4529W28jEW+DF2H5jrW/V5LPVFRN/6hqZ4FfdvIPYcku0faFteWMeOX4qgKAFQvlKzr5Wq2oCqMY92vWe0J1knXDdSgKcAm1akaRHXGAIMUNXDoGosjQ8JPgmIGRws4FHQZFiLxKvu1q3VXq6gm6bdxMzozXXwrKFPxTXTbxbQqCdPUigqCtcF37OyM+hkfZ+e9l+uGnNw4IWTnqtwhv44bJseI80oaBWY3oUMVExPek8fkfA514xukO8dhB1+31BOn33SXrjJOdxBmkx/wqLECba/WzLsuvweVOTZ1p/QZA4nednPrMfX61Z6gBk0td7oSlWpdQ6Tq566WTBayCY3Y1UMDPVSHB2WmdfdGSUgy7/WwVe+z9DtE2U4Xv4GlQyUFsI+ETaMq0aDOpaB4JVpVZwB+BaaHqIo2VbjNWz7tDUs7iC9Uh5ZOKM25HEk1TmpsDbAVQO4QNw0Ds2dQ4dSgNQ4R/xk0VPVWe/vGpT0h4LhksTgxW9t1kQ5XJam4oRHJWBKm4ma6LvDyfrt4CcI3oAcqeuCTN63eJURMJAegkC4qxQK0CgosJ2eaV6ziZ+gV9epOKhfbYWUI7JU21qWCw6e97xJ/K3FI+ATLg8EISfGdhsZAizv4P+IpkkYYE7vBz8KcqrEniEUZWGzxod9vXq3bk5KUM+9DUNZYNUsVOsAXw9ORealieJ2ufajeWWWtVuo58SS2HBz1+632u6mUSnRG7btaKGE41BeRHAQuOSiNouYTat4gfzMhDnTXrsiOAa8PW/X+qz0pQA3cljJFvFEV7gKIC5YlqGE2RJJOZlf8OkH4/OCuQmsZtKa78FfZH7C0g6QTmlGrDaC7KAF8TsYIiQWEMSUVpebDWKld184LugE3TKCjLES73Zf6wNWeqMkx715kKJxbw1w4tclQ2QU4QlVsJCBU5DuhIQjoq64McZYHLhPzdpX9Qcs9cTBVRccgK597Ka+dhd29ODRDMJEwKg7uMCoXDTwkBqzqVA3Uj8e7/OClfm/eq6MlfpJQAFwIltflUF3j5MAHmFicPI6+b6BojlDDDauHP3GPu90b/ZDVuo3GMuRCth/QzrtnE3fRmpxzDSMjb6ULMfPSOJQjqwqSJKpZbIq99Wr60JVsgAMubVeDUoIwtVW6hNUW1NwabstogBs8L3ALTRKkmEKkSUUlJIGusj9stScwgESrWa2k1BrWAGQ3En9qoVqbah5gv3QjFQcKnibpqN5lU1cpNjnvq+wPX57LJm31mMCuKwJDNF5QswzsVtCdBqPRCGyZU1fMemm7pBwsqAUTeqz7I5b2pCnQHUADNebVXQNS5eraNYLa9pEjJrcY1GUc7AUJqhtK4DonqIJlvMr+yKVstXyB0H2mhSGCNZJq4kU92UeVZDZ4r6mGC0bXNbImaahfHuySdbf+J2b5LvOu+v/LvWjZrQmLDyYnrhFDQTAEyNFFaSyWWB+1om6AJVWnAmgOHbRLXKV7BUqUAK7UJFHTupS92C7XyErSVVKrq5+q4RT7SRSkprdqATJuHLVbySYSlW2A7FZnGH4/qKhfXeYNCg+3bDXz17u5qX+SSlhx/hgwXJ+ykVfZ20I2zBy5LBy3DJa4FDJ9SjxAoQFVHdw0557/sGpMeRkS0XE96gStErd6YGS/PPNsalBjlkvypus2wAx8CNyN6pxVwoHeqHF88aiHHxrYwUqmMiX7YQfDErMRY2iEAjYWc2X09/5M5z4TCw/Vo8luTyGjS3UvyULSVDwJhjUe+CSu9juhSzAtsLoeM0J8o7J6tc8Ar5CJQXZQmo2tr+qFUpXN3xSE453HrS/ovpLNsSETOnThdcfnKC2pEEoM4174EFAxMNgy7qpvL+qcoXrKCQYj2rj16F7Grptuy8Fu8TohtTXMHdOP9rBCaATlYUQLWQLhXcV0VoG923Sfl1d7+Ia8epc8vBGQyspyUpIaIddCMkMZUz4RfJJcM1w+qYbWxEIAvPFuxDrQFcd+f9Rq3TqEgukc9AHBxaEW0lFJAEbxmUpT74K8W1CXeKCQsyBCzIyVkb/K/uilLyashA0ReNeeiJAvsqEEKaopj4JU4Fw0DxYkqziZzDyPIUdG9ueQ/THLeJ7fG2rnv+teXiIfWnWtRJ3dsmhTIic1uMWX+g6Kw/ntmoJpAOGYmVuP7tWegBuUU7AOpbZV95SV1G+6V00Ir+5g0N2QQeQWNCsXniporwixiLhvtRYfu4xJ1EAUUEK+Hd6kFd1Tbl6PS4I6RSN2dbGW+E2HEpYCtgL/AO1R7I17/LglPiEBUnUDQU2k8O6DQGLXZGBsCQ7TaLShipQ0LehSPAZwFO+u8o506x/7lqV+6zr0EMzZSKDrcKJ1uhYJSQXer+oNTK4jkD5WT3rsn64u80mnrj4cPu3j13xsUDquAXpxD+SJOqSOMpVy/Rp21Jya0e6Ey5CIXrnAEdW8KVuVXV9lf8LyzHPoYIzV/2sXNX/pEgIk2zVXiVwOxAD5nWKbLk1gIg3H16nFGmB/u/E+n7jkTwjgi9jEqBZkKq4DbuPcCPqEDHfNsyDJit3hyE9e5qWpJbaAH3c3bv2TVrJVPKYGzmp3BetKMq3i5TV0Q63TihIAhJ9sGcsmkwQHi0o53ejT2Ndj3Z/8NrhHMGTUuCu1XeWj+32qOFgDqpV8IBQUbxqUzVUdkVXxv+bjbmTqDx38lNV+41WFTiFfdrWOIl7QpSWMP2GbmhSpBSHuU31HNajaqBeICgK2rHKLQ/anvg39Jm5B46CO2UoCGqW/1LbLZXUZR9X1NLW9UJcO1Z5vBLVEcipLPTDEpy15TZIVRGrYi1LV7xZflZVlKEKyaDZshMoASiY3r0Eumfy5mjvxhzjmwBCfvpINdgTDFM5GRlPwcKLxSMMDrrHSZF9sTkkdDFT464tuLGC7VYQ6pr31Z/uMpa1S++nBydzUM0VnmuwNPJMqKtQcheAsPtPeuvD/vEViW7WIy8rq3Xqif+ZKNjGChgXgBckzbGPjsyoNIlhpdQVbFE+ApSJvjPFWe1YZLHA9r97c5gZ91lIHIXYhfkgAElKTC7jcEdqV9951/41kCUoCV4aTJMkO7AZIgImaaLN869352at1cxZ1j20QZE422TjNtEESeGTXRZuie0nqVsvfpu6tJaOB55BYZcNaXWV/ztIXEzrzVnT7FyRhyCiaS7duEnTiBltVI7kqTwNegwVWqz/CwMusVDIbV9mfu+bwCKZJDZFtyk1jw4YSLWjjTv6TmILUPwSILmcGXdPdVGYxdk0oMbqfcJX9eSvZ+dIZosCzeY3XIAWrmzZ44KxsPVHKpQGACiRQHNXziinMbCOBhrvF85+/5GagdDHfmjw7dTEQt9tVg8e5VrZFAz7UtJZMqWJWXW3WVXHyKgW8WQ/u8QuWNvbSkZfkIQHb5nNRw0JIAQWSTiWimqQNPWsvRV2Tnw677gp5XbS60w/vC5exK9zX1JFQ+zwFA9jzLhpWje3TJQGuaisfLmO1u+bogE5lH6CEbrnoL1qtG0xDXgLTAUqoKr/F2gbycUBbTJ2q4lO7BFCiJJRzVW8aWC7ydFjnY0++eBmTsOKpTmd4GVQY9gHEanTpIaklBJwHL2/rRe241H9wE+bZCBiVS7r5nS9Zco/krnUNcp+T/FTUlSbSjvjjbUCjYHvrVEPjoKSDJprHyx023i1Z2XmbUfyla75Kw3Fg+HmVU6VmUaNZgAkejkrBtlGKfwOSAl4E6OxQS84CYlbG/Sr7y1br9hpJpUvQuCvfVBGhqsEUeXF8nk03fTX1oBM9qeUAPHbh/KqdFanZW63Fly8xBJwXmX381+UatS67Aks0Vx3cU9UOvKtl2LaRudJQDV1HKopW1Ef6dv/yK1ay5Ws7+NLBs2oCCcCpK2E2CQx23dknw6p5AlklgGTToe/EjmsyIWmIQ0++3dLGpkvCM6lNE0tKuqA8iKZI9DpgINiFUAJEKw+NnsKPZ13k2CGUNTr6KvsrV+8SrSO/A1y3SWUaVZQGJ8Vcho1BeOPjRJB3dWkjqhrq2a/SyC3pbs6hJ1+12hPlR2ClCdtBIWC1Alug+9rqncPbcgAhBfYwwir9zv6SoFW00ZWSOTjqb7/cb2io4dESqEXpli6OshVGMwyBiZAGXSnugD+Fj1Br7U1D6HDO/OYtx/gdVntCDIgpBsZkNeJXyaN6xmbSSOBVjQvT2CrUI0a1oyaJha/fy2V4me03XPXVS1+sBgFVU9LwI2SGu9HlVHzxhBatakfjMVApdjUGj8qlqdjC6jbiPm5cQVnqN9yGRjwOhYKiX2OEjGh4IRHsEHoqjoBajrsyy5h44U4NENQdm9ucprq0g2WomLbr7jcZOA6FxhRcmrWo8kk1rXw0t0WiHFGEkB0cNH7WWgL9Y0/aUgfdFEtMJBhUvA9fv6sWYWgoU2oiDdXRIGuCDgR4JK+EF8F8Qzrj+o496UtOaSe5ryY5KJfsH6E6CJidZGkuSi4ECElz3V90eqfwEuo+D2Ai4D385VidSzJN3nY1voFiSJhS7TIHxYhELeyWdoV9wZHq8iFmQKaHIEDDlG4YeS7jeZwtvmxX12xVaA9d3CaL03VBhf1RzrKKS0lTFcPkeSEmSJ36okYRhz35jkscC7ZTQ8Bt6GKLV34KVlqtdNWJbWgEMYiIrBRJbpXOBt6Du3R4J1S58ZrfaamDrchusnb1BST8B3wTznbL63LKThFt+tTk9gmFofhI1ogHhzMji3Ss+2uWPi3rY6rjMifQCpFYPcN0mT2NL0b7Erk7zgApf9XpIrpdnAgc0a1H9xoPEniptbLaWZjYL2GURkdCxRBC6eY+4Xx2qvNBX9zlRajJcCqiaq+yv8uSMw26U4Wd5c0ogFLDR7gI8vAw34L74Hqn9l5QwCABnodeQyQAVSDmjnV/7ZIfJHlBRE8y0KgrrUoGeatg7mZ0bRLiCNA2yPFK0Z2OFQDLFQguKP5wyP6uSx6ZzVTSGdsD8+WMCF2WPcDIU9QPZ1LXEDEBTaN/yNI2jf0hy6wmUwf+/m7LPYFGHlaFGxrXrPuVVdlJ9ViCYCSY9P1SN0f2ET3VfTWrJihZDcParZ/Sd19iiM7TgcBEGyqxClDdXc0AAinnqcb8GNlAbKLrEmSiulqTZbWIiBPHcevRveSr4OagMzXboxOlwvOrPSxIGIVAidBwZZMVCmoagwc3sx0xoJNt3OkD9XVL/F3EWNahOZfwdaTUia5xLHgy8oFoonEY26ru2U7fCGroZdSwP+ryxFX291ztya4cPDn9LtctHlJXU1RgrtongiDVbPFui/rCKXMO0lBeDwh+mVh5lf29lr5YbOywelOiF/G16pCaAJcQzJtgCXBcxTSkjKbaA5O5KgmKBaps3HDV917u96WbwuXGcwdDyWbhIYJTIwujgh8HL0aMKBKCGBzgA5KVP1K++rbur1/JHrrGDWIdmM14YR94k3gFlXtCDqiBGklcTrmoFUWUkIgQ4BAJm9DFVfY3LH2adkNDoExWRTJBG+QRkY3aFKmBPdtKBF+Juz0pGo2BdWokq249RMpHDPh9lnZQU3F0ZjQ8D2ZpU8/2qfrYoQlcIG9CLWgCiCeSbBc+YtcFqKnQ9tZn+PsuYylQmToD6UTDnMD2qp342IRUjL9cbFVHavUZjuTWNBECfnaWoI4wt3sw329pTwBorNSTEwKSXaCnmtSo0/gmeVHoGYAO5xgI3arKJIgcIA4UExx48PuvZJfLlflQKiAZBgkWL+p2my6nkTvhpGNeId9wu3FASaj1mQwQ6lrF7F9l/4Alhwf4S6ihU74TS4ROaAgXQFkti9RrbyZgubpgE61pFogq8WEuNBKuHhjiBy4xMgAV9cLgBV1yIE6Kz9TjEKiqSFNFBGkXsosNA4MZxH0ONfgd4Ohj3T9oycfuysZN3c4l/wKw2Wvt6hAh/KOrusC0XdSKyHpglxqOYNXDmKR4b77hBy95CPYS2nyHwdRlPJF4m4V3yGIyxH1gO9QykM1Nu9KtOAXBXYCzUppX2T9kiZHhioUXwtw0H5JwG4aYwAnwTBZKOZ6hUglOKHaeg6OaIguDrXmm+y1ueOsS22sqXdDtFzhzIKea7m+wJnhgFDgqHxN05T2RP1NHSBi3DDLf1KzI3mpyfujSxoJKYdGkGfbS01WDBJxuYGpM+axJQ00VUXjiERJX+GXNIlWDalUpXmX/sOW71FVREvQai7NpUIup+XKFDFaCp6H2Iyr3NTUPVGXIoBjAihoHY6qO/f7hS1+sIUqwilZYifyNKnfrJXOmy9W6u2hVEJVkTnQBmGy+uA/d1yIbfGC2H7Fad7C67S82oJEo0SQHdhduw6pZEdFrV04D5J9BjOpEkzUa0Cg1QBhxm5P6I1fr1jQFo8E1SSUEJHB2sqG6ARfJ901IT6JZjb/eum7vjF1wijeJDzLY7yPe+VErHeQl6SJRVf1R0LgnpJKztcrxxE3tz0loatBhVrYDs6I2GiQGVJlab3jwRy8xclSueJfj1XgTMAm5L8ipGBSqga28gNuuDvXifjXWDhMTdIUeI3Dg7x+zjBuseh2RLeegkNHqRsPMGoefDBSgDGaKIGGoRyhbpEvdu2qMlSeZpN2PdX/jEmtu6ndDRIY3SZrBneNlJIamh8F4Z3Vg5X+IsYJey1RBDo4QqKcJYocd/LFLzrRrFhEHGepFYTQJ7ADLRXKEOBBvrklLRjWmbm+oo6a6eK/uU1m3jY91/7glhiDiJoOrWix4eV2l0T39pLmrHvqnXI4t2REDxUwCrfPYFHE4TszwbYbfj1/bKlIjvB/wpO4Otkkcr7Z4SQ2fI8QoceRQdRXMaSkarK3GWEY8BXblsCc/YSW7KLMaFPZyrlX6pFpSNV+PuuKra1dqU0RUFHW1G9/AH9wZbFVV35Kr7J+42hMYRTI4G3nWofphAkIIRnAV/GK41Iehydjdxp6gllH0g2ayVvw2Juw48z9p6eezZgImcdLKwoPeOI3YQyC3QmVNPiAJA2+tntq8c02phd2Ap1Hv0WNPfvJKtu5tQsCzQPADsaU6pMKAkT0zGkZNgriJrw6XHsdO4zI5DXA/uEJcw7EnP2W1J7pENjUSVF3UrMaqYDo3kAQBntf8FpUTw4Jo0KCuU5GUIoDx+gfrftiqn7q0VbB0qhfXfYysclvNwYKMgJsFyBrVL+k6Pusl5CPIKLqWrpI6sWK3nNdPW627aySEAmmCEJgjJWGhCLtoZHUVULoKTqlrprPRoPpdjeR3tenCZN16OPz0JUYWHyWjoRviPEHXzTlF0cixkQlNVU1XwC3wtGTvOKu6QN11vd7cqeX/Gcs4DbUgp5LVkkRzWJP4QJLj+MWkvvrkLuRLsdlJY9bVpaCQLNlkE/Jtzt7PfBt2cLCNQM1nJhKQ26lCv5umY+mWp+yqCju8VE9FF7oI4SEsLwVZV9k/ayWb1CQgCiLAwaSo7eOOQ9RNFXg9hGmuVCcEVTMx7BomkveMXYgaskdO/Cr7Zy9jQFyJAW9bVbQop43uselWpMD0AaasNdyQsv/q4cCOqKCjK6OuHvtX2T9nGacJpsLxAAwI1tjHCgsTu6b6qeAs4p3lm3cNC90u146UxzLQj6rxOPDgz13abwJs8li67JMwG0Q5eALEXJreYXpVBcRmqcGcvKmunzipLXFSzLd6tp+3tINkWDTqUcVTGl2oc0nMB+BsQGG4zv3ZCTHJ6UpvgnjTfEN1+SzjVuv881f6TVSJN8cDE4iRkAP6cJCcxgWi5rgHNRQmt1CNLtNqyDMA6MIddOioW6/UX7CO00gBYfalX5wUSNh5GfSiqe7qO6VUrGYjq7xqwJiqfx+eFXuJeS+H7F+49MWaY2vxWuTmRlO/5lrBYsq86N/QBaTNiNx0EMlQ77wJ0TRqqgtiufX/Xu33DllGxBcVK6ivt5p8TU2+BcWp37fTFIvsNX8KM8LzncreGr46kjI+9OQXL30DeyGknVT45NSOpGmY1MAFc4YIa6LT9Yeoz4M3gGvHxE+INvLF++0O2S9Z2lh7uf+Iceq6gF62CxGku5wohwaSgAAUVwk3Qoup1Y2mTSoNTJbjwIPftMZsRkMFu4pCjQYuFzHoRgXy6v+mjL1K7qT5lvM0NP4JhAv3hPm84apfusQnO4e9a5gC4DLo2jjhB0FZucx16xt0EpgOW0m4OcmW6EKwClOzxlfGI274ZeuzA0K6VGnVrEEYcClbFptPSEjAYDRC8nKTzCd1b28qFVddDdE/mbtD9i9f2lhd6wNzjMt00F3tC4oakqv3iVMfPKJN6KaLB+ON7ipvn+pZr1v77sCDv2KN7TUwWpSs7kj2S7flqGmfO58DQL/zba/7ZOKXNShDrWaVPLSarHTo969cxmkRYvEyRUD0iLqiBxVJN0IHBzQBUGie61DbxqZ5lUWzkTi0u66lh0NPftVST9T8CihmIhilqn3fUAsOXbhJ+Bh5S5asvhPkBktIW4X8UesIXre/3UH41Usby5GBcB16VUY3/9gjfOGuC/nYUIxIUk2AVaOJGMFfyotrak7VtO6DK/g1yzOvu5aaS1xVlA1v5ZX3Kp3Y1KmbwmWgg3qMFE0UyxrPMcQRQWaxfYe//LUr/YbEUWMtCEZDgCP0nTX1DUeJDQGwkaX0kJF6jdhFvqqmuPnS2FuTZa+yf92Sm0m7ZpfCZl/qmhTiKciOqjZl/4Pq8DhPu0oCSNiBzwlzvdqIZbIQh37/+tV+wz6AVkPVzC2yQRDP8BCqi7rcnQpTVla5NsHt5i7NnwZnkpc9hICusn/D0u/U3bnCaVYFeAdLFM4hplvdKnWZWFd3APv9crusak4e5gDeHmpku9Pz6DcuuUeixKj7KixZlCMkAe+PWIGTyEEkN7yrcQn4EAqZbyshqj5JBR6v3fTkNy35Qc6YUU+g7ZIawfx5gY+m2Q3aD7WckJvMaibP1lglIC7JGkzjdujJb17i2Ka+LFWVb40QVd2H1HtbLe/gP8gG7qrLTZdAQcOGJ7kq9CmqOvfOvf/fsrSxmGyjcUyNgE1sl2x/1e2UXR1AWWjSHaGhy9kkUuAeQSeGUN6rhOzQk9+65PDwj6KjcWtBbYIsbNKUNUIPkr84I3XF5PRu6jKsl3MZHJzEm916Rv+2pa3S3UXdCEfRqmqJ1OWRk09AqzyeBj31S7vxsl3iIB63yZQUVQTe8g2/fYk1QQIo81YUd6gLfFN0X9XfEAxI7kRDOiBMQT97gZyGZieVoTw7OdjbLI7fscQ+EPfwpZpDmXVvuYgpDkoEXq69t+IJl7GNmncizlM9SrHE2BqNnTjs9+9cyma5XoVyuiznNM5w2zWWg6hS40o0EFWAWUOiCZ3UiqVojJO3Mt83e/K71nsSNB2o6baS0ZWApC6KWSlNh9p0laez46oiUrs/ogXMeWMLVSRym9nyu5ec6ST1QZKfrQQ7dc4M7FfQhRdYIzUTgJRSmwhNWocGsSWDyJPGMhhM0bHu37Pk8BpAVXP01EdPqQ9YTo69UW0HOTM0X80Q4Kc1zyLo2oqalCaNVdMHvsr+vcsYMKtJO2wBcY2mbHq1SYINH7qlqBPqdIs04fTUEc1iX5qmPjpdHre3c/n7lhiiA2wA3l23U8nEKVRHIzWE2vdJYgZDpV78IDTNNm5agua46Kod4PEq+/cvuRl+UnNeyGgYjfnUuG7DubFKRHH6cA/q5NL0fNEouu6UVM9aVU13nJ0/sOQKyBaRLPZe8YcSjT1BMKKMSWaxYq2tapYVfWZ1vYEI8nl3mmJT0y2e/4NLWzX4zNAFuAQ4dU1YJThRfcRQAdflZhaWyukiJglSdt0qUlZnXM1GOvD3H1rJ5ojA9sNYahjBrib9on7UcNk2CDsVsejWmErYlI6C91W7xJrU3eVOXPyHl+/ymfB8yowmsdpor6pW1b0S7AxXJ48HHVk0zgKFH8rUq+4NQzGPdf+RJT6BdNnV5l95r6nhDWIegMYa60MkSEYNSMUPDBUEwR92mbGAk2cBt3X/0dWe2EsNEuGfurOlCn9FSEZkKsi6AzCIAEGsJGdV7dZVYgOU0S14TR+8zYD6Y0sMoWLdwAEMXhk5HMSuTpK6dIXFUy5eKWhVQ2WVvBRdOYozOAXf7ZaL/uNLv4My4LCwJ2qAxxYCGhQQq6d1vhAORTVWhKoNDF3E4oiW0004Yo0jvvwTq3Wr+SehIyxXVB5E7X6h/zFVsoCaGlhUUEi6BV5IR3fCI8CbqjDe5lvdzJ9c6onCVl4c/6C4SV3V0RBd5CSziiMiiIQvHgqEebAHFhNqhcutBYLQw1b9qSWushrv23zclKkfW1NSAyMy2E4xjiTE2q72RBh2HGsXYFFNrdqgkke/yv7Tqz3RHKqkAUGkSrCcOUPIJPWy10SUEVAVNkEZbV1B3reU1NST6I6DG8etL/+fWeIqvJUmO0K8aJ6C7lxxrFsgx0ewA670WY2DxjM30EkFBDQlR6/bUv6Gq/7s8sxroiiZYV3ijho+ogqappG3Xc3iIZdRIl2AB/1pgjG5LxJScIR8CMzPVfafW/qGrq5xUAIqnlJn4o2oGD6FqEPXF0P2ACNSDpuSEQOS2mveCLywxnLd+t7++SXPtuuOQNXo6ajBEkaZbZHKmu6RdR0Dg6oWc2rKCE/Whooem8oVIVOPs/MXVrKBvKOqE3JwlshmBk02Is/YYcU1cVTx/tSQ0P+rvSuBj6wo+m+STLK5Ngm7yd6wgLcomcxMZuK5CoKi4i0KKiaTjDfet0hE8UTxPlBE8EDAA0VFWUUQEcUDLw5BAcVbQEDETz8/P6tmp3Zqaur1vNn8ZzOwvN9vf5t5r96/q/tVVVdXd1fTIJcXIZR42XrlqNrc3ExtvebFbt9AIVeKw5PSkZdM4Q6a8yIdIbeEjHqJg2m8RoZzQNFEOtEWODdFkQ9eohDzZO08rx97fE/xqT2THMrkDW0U0KMQxwKvlCe7xGm/2Skp5HmcM1XZ/cBLmoiZSiLlUm2+4Scu35Pk8PGi24VKkviF2TKZ6SkOSXLEm+N2CySYNExh77/EqkthucwUJxXhs9MF+6eefPP0Pqdlm6eQ2AxZ2eI8rx4gaz5fSSjHR82T9JHLmq8sM2M/mbzCLDl41J/WfIifuTGl6SneyZot8IHfvIs6w4elctIg6j7Jcd2W9ZUiDmVODUUDCPLmaKhPYzQSnfntcfuf+/abDzFcoBJ4Cw8fGDnPp6GTE0SR47nKsZE8qV3gJHK8G6iY41wgNGrg4XdtX90lrq2i+XearaNhE834EevkkfEakxKFgOd5Uz4NNXlxNXlZ5GxOl9iNphkTnoksF0u1M/wudcfcBY5s8Bwqp4ek7r5IozJORkEhGz5kkuIFnO2Wk2SxV0UCTpLOJ7XytH2tb7jM7S9JySjWms3zQQgU7KfANE1nTfMuxYUsbwApc9bUeU4PkeWhJ7X2ZI5X5HFW0Frelss9+eYjCvO8rJwzieT5FGNy5ClqyKuxyeOaL/M4nPeUUCdDHtU0L9Gm4U55Zm6Ou2nB/oU/LiZ5oh6EopQ0oKRJuoVKykvOtUeOGYUgpgs070tNRj1CkZPybzv2Jst+1kxtfucKT07yfBovhQqmyWpxcnTeQsK5fkg6SgslTnG9wEM5imFRwJbiENt27tF3LNL0Wm0/4JW+DM7TMIBPP+HUI9ksHxmUz/NGID6ghQbHOV6YMs2H+/BmIZLHLOdNJfNCXkpt7v+XLjavXi7zWQyc6pqidgVOKUGdco6XCJPLOkOmKj9X5Okqin/TTM8sZ87ieBvNBm33fX7ljud5odxcgWN/fMQgL2qZ4qUsZNepn+N1OHwoPdkTPtVihsaFNLwkbOpAyDmv+WxXufHBygZCGqtTt06fkxPYczrHTKVxi4XKlq+FHGdiLXPu9jKfvE46O1XmrG61tRZX+749r2nhrTM0WJvj7duc6qhcKBYzPI2+wAdOZDjZVyWknqvEm2jWnrofjn5sH6dd48k3Z2KhMMAkJ9njbRl8khn1byXeJ5SZJIGhQDDNyxPHFCYrUGPPFLhjzVCInLeUCfavXfkuch5aGucQ6zSuLy/wkr887z6a5GlBCq1k+Ki8DC+umieFzfAHz01yEtkFFff5jYdd5mPEywXmi+ZEadBKfjgnuqcAFZ8mzFMAM5yYgxyMec5Wns3x8ZcURSZ/uljbP3+t1yZ8ZkdltizP+pHj3ZU0lcUr+wqzM2zVeUAyN0tyRB+aw0hkTGjSixPDFdUeyd+6esknVpMrz07mLJ9YxclHOIsuH4lBHSe5PkUyW5yRtlhZFM/5CskqkNUiL2Z7P/87Nw4xz1m2yBaRI8tBBg4MlirpV8s0I8hBeqpGmfNH8DlEFGGlcTF9itxUkScztvuxv3d9ewqSz3PMNMvSzMf4kZ9XoBrwsfb5Eh96N00OTOU05jzNXZZ4kE6TJpwkoVCLn/zB9QdJ9diJpEahb7jAmQh54XR+Lpvhs9B5uSpv7sxXsiryGiDyxTm9D+9uoq5fsP/otQnVi6YW5ym8SgMqPgaY2puzyE5xpLjIZ6LwHEFhlhyqIi+rolD1FHtHNCnD8T7B/pPrD87McE5/nmwhr2q6RLIxSyPhSU7mx5uXOecMBZXY3cyT/1kkI8WromgkQH1KbS7jz26bVBaD8PEPZT5ZmLNO5ysLJAplXhbGBwTRBFuZT90isOlKzoc57hxIW2ey28euf3F1PsPpMkqcPo5mdEixp3k7cY7gZ/N5Cn2U82zfSyQvNL9OVpZ3eVGUhvfvTpG/KdjXuTZ2ho/JKPPZW/Qp+XzpcpFPly/zyYxZ8i/4rAYa2HKEmhcekVxTRDvDu15pQLH9W17v2ype9MCBNV6PxTu6Sbj50FxeKZ3neM8Un/1LlmSGQhU0z1ie4zTPeTYHs7W45g2uD0Hhrywvx56igPY8tT3FRWnuqMyxTRKgORpi0uQAmZsSRQRp6ELuOokIqyjnHK3l/3bjPpW1WHw0PCk++bIkK+ST82ieZk1naP4ox9O7M7yHnxzQqUKJz2/Kc4phmhasreu90cMuTnMyvSIZ/+LcFB8cNcWaQV0DzTEszBA0hWf5uByqGqnTHIdQZvnwwAWy4FO18+dvcm0szeSQ/7RtQW++Em+jGNs0H1lHAs8eLZXOK3vIHPAcOA0rSEj5yENyP2o5/2927WCWt1Zmi5XaF2Yrm/QoeMWna87xQgveW8jnZk1nyZDTcJkDoJyyeoFGpio37d/ceFWG80byFi8+BovXBHLe2VkOJlGvRvWg70DT3HP8ycvUqS2Q0cry7BFNMhXyc8NV7FsUtvwp5f49Vbvfrb/HUi4SwpQpL6ri63u6/AHDK5SfyclKWhxdnvBj26er+r+03a2pRl5HnWdpVSf9TJdzq1OOhzUOxFoDxFoLxFoHxNoAxNoIxNoExNodiIWU1T2AWJuBWHsCsfYCYu0NxLoTEOvOQKy7ALGQsnpXINbdgFh3B2LdA4h1TyDWPkCsewGx7g3EQsrqvkCsSSBWBog1BcTKArFyQKw8EGsaiIWU1QIQqwjEmgFi3QeIdV8g1v2AWPcHYj0AiIWU1QcCsbYAsR4ExHowEGs/INb+QKyHALEOAGIhZfVAINZDgVgPA2IdBMR6OBDrEUCsRwKxDgZiIWX1UUCsRwOxHgPEeiwQ63FArMcDsZ4AxHoiEAspq4cAsZ4ExHoyEOtQINZhQKynALGeCsR6GhALKauHA7GeDsSaBWLNAbFKQKx5INYCEKsMxELK6jOAWM8EYj0LiPVsINZzgFjPBWI9D4h1BBALKavPB2K9AIj1QiDWi4BYLwZivRSI9TIg1suBWEhZfQUQ65VArFcBsV4NxHoNEOtIINZrgVhHAbGQsroIxHodEOtoINbrgVhvAGIdA8R6IxDrTUAspKy+GYj1FiDWW4FYbwNiHQvEejsQ6x1ArOOAWEhZfScQ611ArHcDsd4DxHovEOt9QKz3A7E+AMRCyuoHgVgfAmIdD8T6MBDrI0CsE4BYHwVinQjEQsrqx4BYJwGxTgZifRyI9Qkg1ieBWJ8CYp0CxELK6qeBWKcCsU4DYp0OxPoMEOuzQKzPAbE+D8RCyuoZQKwvALG+CMQ6E4j1JSDWl4FYXwFinQXEQsrqV4FYXwNinQ3E2grE+joQ6xtArHOAWN8EYiFl9Vwg1nlArG8Bsc4HYn0biHUBEOs7QKwLgVhIWf0uEOt7QKyLgFjfB2L9AIj1QyDWj4BYFwOxkLL6YyDWT4BYPwVi/QyI9XMg1iVArEuBWJcBsZCyejkQ6xdArCuAWFcCsX4JxPoVEOsqINbVQCykrF4DxPo1EOs3QKxrgVi/BWL9Doj1eyDWH4BYSFn9IxDrT0CsPwOx/gLEug6IdT0Q6wYg1l+BWEhZvRGIdRMQ62Yg1t+AWLcAsf4OxLoViPUPIBZSVv8HiPVPINa/gFj/C8T6NxDr/4BY/wFi/T8QCymrUQqHlQJidQGxuoFYPUCsNBCrF4jVh6xjhMNaAeSrH4g1AMQaBGINAbGGgVgrgVgjHSqro0C+xoBYuwGxVgGxVgOxxoFYE0CsNR0qq2uBfK0DYq0HYm0AYm0EYm0CYu0OxNqjQ2V1M5CvPYFYewGx9gZi3QmIdWcg1l2AWHftUFm9G5CvuwOx7gHEuicQax8g1r2AWPcGYu3bobI6CeQrA8SaAmJlgVg5IFYeiDUNxCp0qKwWgXzNALHuA8S6LxDrfkCs+wOxHgDEemCHyuoWIF8PAmI9GIi1HxBrfyDWQ4BYBwCxDuxQWX0okK+HAbEOAmI9HIj1CCDWI4FYBwOxHtWhsvpoIF+PAWI9Foj1OCDW44FYTwBiPRGIdUiHyuqTgHw9GYh1KBDrMCDWU4BYTwViPQ2IdXiHyurTgXzNArHmgFglINY8EGsBiFUGYj2jQ2X1mUC+ngXEejYQ6zlArOcCsZ4HxDoCiPX8DpXVFwD5eiEQ60VArBcDsV4CxHopEOtlQKyXd6isvgLI1yuBWK8CYr0aiPUaINaRQKzXArGO6lBZXQTy9Tog1tFArNcDsd4AxDoGiPVGINabOlRW3wzk6y1ArLcCsd4GxDoWiPV2INY7gFjHdaisvhPI17uAWO8GYr0HiPVeINb7gFjvB2J9oENl9YNAvj4ExDoeiPVhINZHgFgnALE+CsQ6sUNl9WNAvk4CYp0MxPo4EOsTQKxPArE+BcQ6pUNl9dNAvk4FYp0GxDodiPUZINZngVifA2J9vkNl9QwgX18AYn0RiHUmEOtLQKwvA7G+AsQ6q0Nl9atAvr4GxDobiLUViPV1INY3gFjnALG+2aGyei6Qr/OAWN8CYp0PxPo2EOsCINZ3gFgXdqisfhfI1/eAWBcBsb4PxPoBEOuHQKwfAbEu7lBZ/TGQr58AsX4KxPoZEOvnQKxLgFiXArEu61BZvRzI1y+AWFcAsa4EYv0SiPUrINZVQKyrO1RWrwHy9Wsg1m+AWNcCsX4LxPodEOv3QKw/dKis/hHI15+AWH8GYv0FiHUdEOt6INYNQKy/dqis3gjk6yYg1s1ArL8BsfoiHNYAEGsIiDVafTYSNcpbd/Xv/qixPfjZlurvySVeKdNGPaoeusy0qo9tU/k7qtLpe3ut3Pb/Cvp38qqoru3SUWPb6Xu27bodfoad91Ix/0cGI64c7zuMRI31tt9oyDzbUv09ucRL2kvkRX8jXeaAqo+m139HUe0byb17Bb7RgGk7ey/0jYROvlFXVI/NVy/9y6ysv9+t+Ox23p0w9RD6TWM1zNzK+rKFJlJlt1m3ppPIny5/IGpsQyA/mZQpL1Ltq9tH2lrabsDhddR51qv+3hHZ2VWx2iuH0zlP//qrfzMPB6z065RW9/S7K81zoT9utIb5sCrRSBRvu2/PNvXRO8mm6veW2u9536GZ7T4EZLuPVLJzaEB2BgzPIZ+pPXY0k2vWJocH9ClJmwh9WbXJ3C6uT89aRn3qd3hdDj9Byh+I/O+8BcNPxn7LZu0qbTfu8DrqPLN96LhTzrhTzq6OJe2sv8tSbb6W6aT++lEg+3Y/Zd+ODtg3K0tJbT7/21L9PbmkK1vqj9qpc5mZNtvnmbbasKlMqZmP+VYjM2NGJuy73ea50H9mpIb59hbGeG2ylYltt5S/s8Z4Xp8YGuMNOryOOs+sXRt0yhl0ytnVsfodbNx3z+eb6d+JRv/kWdIxntDvpvTvZGOzdd2sT9oXaJP+trRJOLapyxTeWo1tnhrwSb0Yi75nZabX4WfYeW+p/b33HZr192cY2ZH3kvb3Qh8p2TkzIDs2xpR2eL49y9XWNsuV13bWj2pTfzlpbapuu4FA22mbOui0ndw7H9h23Q4/7dbJpHGXi0Bxl0tX1jB/aHRS1yekk6nI5yVSvGiaFVF9OZ7fZ7HTDm2PeSa0l1Tr0d440OTkbgrX8s/yOOyUr7/h5YE+udt5135Dob9KfcMrY+Qiiny5kG/hyVu34vUiIxuenbO6rcvsV/esTA859Frfhd6Lbw0lwOoNlD3s0NsxmC5b8zWcAGt9oOyVDv1woGzN10rzTL8ndP2Gtl22vNqt19nylU47dRl6/TdfaXPvhoAtHw60nZTF16jTdva7jThYQw6W0HtxMV0nK6+6PBu7GVJlxMlXFDXqVZweyDvdi7Vnonvyf496hhwL83f65KoaH5pHvtKq3Dhd9eKLSXXVfnPd7oPmmbZZdn1Iv1OOtsPWZupnesx1eQIfNxU11juJ3fJsrK6HlUFtr+PkqMuh7Te0g4Y2zqdthis4nrxqP56vHvWs3fKq62vltV39mmejbAxGy0u/KafXKSdpHy/v6nGe18/a8bwXL9pZc0wiM3FzTFZGtR3QNiRt7q2rGnGvv2k1BjTg8DMc+frn/S/l2HuhWJON31s54Yu/8+aR+vte/F6/Gxe/P16N5/eu/u3JjrW9aYfn27Nc3bPNchWy/6mofgym6+C9NxHV8xfql+z30nXujaG3a0uEPqvaaGuMTbZynDdyPKiwk8ix0C8qOS4G5HhXsIEPbLOsem1nY0/DbW47b43CcKDtkq5ROBDYdt0OP+3uP2zsKU7vDjZ6J3KXVO+E/olK7x5j9M7zFb3+w/Jo/VVrC0dMHZvNlwxHjbql2+JJpi2GnbYYCrSF0D9NtcVhMe0bRX77Wv9OPxtSvB5s2tiTeSlzzCnTG18L/SqHfkzRCE9SttapVQmwQuPC1Q69xhwyZWu+VifACsVwvHUdqwNla77GzTP9ntD1G9p22cQ1VTxtE8edduoy9PpvvtLm3hEBm7g60HZSFl+jTtvZ77bGwVrlYAn9Wode18nKqy5Pv6vLkbbx5CuKGvUqTg+8MbHcW44xcV2fp8qN01VN36quSv1Go8Z2HzPPtM0aNeU0ixVZm+nFB7V99/yWdIIyvT4+FTW2k+eHWBkcarG+Aw6WLbs3hl73Y5r+zY6fbjHTMfXpi8F8m8I8x2B6/dBL1L1W+yHhJ9QPWVr57bW/p6vyzZdDV7WvYHXVk7dQnNtre91eVle9dvZ8NutLheJqnq56vqEeD4ZiEEn0ha926Gpk3utyaIcM7aihjRvHNcMNyaseu/LVo57tqvKq5cXKqxcTSSqv8q6Ow4nMaH/L9i2evzLulClY2pdZa/jRPmsq5n8px94LrVMeNuWMOfxxvb804tdN9xv63VXquaa/i1o/fJZpS11/62d77ezphdAth17o7231Yp161u3QW73Y4NCvMzR8jRp63Y6ezMXFGD3+tC0ej+EvHcOf9RuE/oKA37DR4SHkN2xy6DcqGuFnJGpsI/2urb+VRXnPkzf5hsshb3VjuMX6tvHkR9PbtvTafoOh4Ws0im9nz2+QMj2el2rH9Dey63/Xqne8scS44WvMvB9VMS8zdk/ei7N7NlYk9GPK7l0RgxlFjbZBY1pd7Y2hHzc8CP1VgXh9nN2/pkW7b+sv9DeqWNm1xu7r9+Wb3pbsfkgPQzELvqwehvoJTw+1zbVjbU8PU4ZW30sac5V39R6REYdX6w9tCNQtilq3ScKHlK3bYmMCLM2r9cU2tIg17vBl+6neGHrBSxv6fwXG7ZvU+17ft8LwsLvDw4oAD0L/H8XDeTH9tbYFmq9Rg7mdv9EapvUBpNxIYd6Sqt2zMrKHQ7+7ohF+RqLGNtLvaloZi3kyEEWNsmxlT3A6zV/QtsXaKU+mNX2rvpe1RVouNphn2k5YH9ezn15f5fVj8q7ux7x+xdrGZjbY6vcGVY5HL3jWF55QemD1u5l/PRqDuS6gW943DukWwr/2bHM6QTkh2fNshJYv2y9onvW7upwd0flxB8fzTa0f7fl7SWVa3tW+qdf3jjepp6a1/oX+7c2PJZF/bz7Fyuo+SlbPSyD/axNg7tui/Idi/c3kX/gJyb/Hu5Yje0++j9YXO2baaGjjsD3ZG3b4t789XbDj43UxPGkcL97ULvsu8Sm7hlnKEboHjNbf99ZBeGur7DqI/dV47kEG04s1Jl3bqWONRxnfOjSX5M2lhuKuzeZS7Vpk/Q3XJsDqDpTdrH+16ws1X+sSYI0Fym4WV7Nle7rl9Wnar7O60465f9E3Pffv6WtX1Kif2g5a3/zxyn7auf91gbaTsvgaddrOfrfQeExjJbXFVl49fzyKfDvnyVcUNepVnB54fr7ez8NXj3rWbj9f9/1pVW6crno5TZLqqv3mXr/l5S2x8eTQvhLPZnr7aLR9D60FTRl+vDKjKNm6IV0nK4NevDFUdreDZctOx5Rt4+1Cf0TAH/L6jFC8vVmfMWrq7+mKpZXfcbHZSlmLtWedOu/pyUao//Xa3pun8cYTodw6SeY9d8QXOTxBfrcksh1F7dGryLyXZJ5+3NDGrRluhhuSV6n3HfLqrzG38trtlLMje58PCfjOdk/AqMNPp6zhtHKXdA3n+wN+nKef3vo/b4+bXpPi6Yn3v5Rj79lyvO/QbDx3Amg8N6jyEH/M+BBe/ZPYXmtvrLzKHEt3oP6pqH6eXtusblMn7/vEtdsppt28dYChdhP6m9Q4+DTTbro+Vuc8GRedW2PqvqX6e3KJl9RVfBGtc97ak1CsTLeF3PtCQOdazSXo+cpe2+n+xfLajrZb57Td2kDb6fFA3fyDufc1YNt1O/y0ex1VtyknTu/ONXoncpdU74T+QqV35wfGPOOGZ28fp9eX6jHVAWZfjZ0vEbrvmbp5awXWBOom9Beruv0gpr2iqPVx4hrF67mmzTwZljLR89Y2xtTqvHVorX6zOIldX+HFrENYoX01zeZlbNnevMyI857Q9Rvadtk4mRfWNs6bU+4y9PpvvtLm3tUBG7cp0HZSFl/e+iv73bw58Y0OltBvduh1nay86vL0u7ocbw7BxuFCc+iCsyvPodt8EqE59FbnWLQdtjbTW4es7XvIvwuVGbJbyDmBZuuuB2LKjlufo/sxTf/PwPy9nvP36tMXg/nvQLzO64dC8bpm/ZCdv/T0z9LKb6/9PV3Vvj1fPerZcq7L8+QttC4v6byRtx7bzoeG1uWFYtKerupnen/YKQnGsKmosd6IuUOrq6E48BpVhqW1vnpo3mZNC7h3zNs0yutyz9ucYORVj79s35I0T3ZSHm18uc/hMYQVssGh/VBe2Z4+W14ih089lquUtVh7tpwxaJ1z1cq09x293K5JbWOSeKJng21eN1QMOhNz5oLGTTu4ofqG5LzZXjobg9NyaNfMeXOLtpykMQuhL1b/0L5Np/kMug2tvIbW7fHV6pyJtcG6P7Pyqr+BlCk8ezEdlr/r0/V09jsK3f5jPt/6+3o20cakDlIx9AMNppfH2ZN9r059itcLqg9CewZDfWDIx1vv0HvrVr2Y0foEWK2uS9KYNg+45mtDAqzQ2KvZOMGWrfnaaJ7p94Su39CC9Xh73EbGxzpus9Fppy5Dr//my+7DOFTZrZMTjMn0PdsnrXf4STk8IOJtVl51eXYd9HpVRpx8RVGjXsXpgWfXRffabNdzre7N9XS11b25+rtKu3tjQbtOPLSu0us/tB22NlM/07Fuse/efjtrM0PrcflqdZxhZTC01q6V8V2S9exJcEOxC6n3csgrMnaRtF/zbFRoLXdoT2GrfbzeU3i66eNDccDQGlxdj3b0N6LXur/RZYb2lmgbYvcwHBPobxBrcL1YdirmfynH3gut+7S5K+LmC481PmKz+ULrd26PTe9WwzzO2Dqv/t46pFAs9PYiVx9os1yF7H8qql/HouvgvWfjLs1i+nYOwNuTFIrpC/2Jqo22xthkK8cnGTn2Yv8hORb669T46RMBOd4VbODpbZZVr+36TNvdVvdwnAlsuz6Hn3b3H/bcpji9O9vonchdUr0T+m8pvfuG0TvPV/T6D8uj9VetLbT5Fbw5IebneBPDsXEGofu2aQtv/+T6QFsI/UWqLS6Mad8oan0eeb3i9WzTxp7MS5nemNgbXws9Yg1KCCs0LmyWi2C9KVvztUcCrFAMZ7NDv0egbM3XZvNMvyd0/Ya2XTZxzyqetombnXbqMvT6b77S5t4VAZu4R6DtpCy+Rp22s99tTwdrdwdL6Pdy6HWdrLzq8vS7uhwvvhWX60J+e3rgjYlF95ZjTFzX56ly43Q1tOapma7aOVDd7pvMs9D6vWaxImszvfigtu+e3zKQoMzQOqRm8V8rg178N1T2WgfLlh2XO0P3Y5r+FsdPt5jpmPqMxWD+w5mfCvVDh6l7rfZDdi9xKEeFjb967e/pqnzz5dBV7StYXfXkLRTnTrqmNck6Oa0r1pcKxdU8XfV8Qz0eDMUgkugLX+3Q1ci81+XQrje0oXWdG1rA7YB1nbcpedXyYuUVta7zWFDfosv05G+D4add40eb09bL81bJ5bubX7e4NZs2p63Qv1vFH/eu/u3VPxR7CK3fWU47XhejWaxvr5At4qtVvZDv6+nFevNeXD6p7ib8hWKGUl46hj/rNwh9pvrNk+azC/kNzfxSO98e8vGtvdeyGMpRt5w+fsgOo+fHrbx57RzyGzyel2rH9DeyOW11vyr10Xs/bXzOzidHVcz9jN1rtlY9Ll59pLJ7B8RgRpHvp9j4vjcO8OJC1mc/SOne1lXx9dd2/xEt2v24WNlTVP0fZey+tybitmT3Q3oYGtPy1arPavUwlEss5L/beX/bN4RirtofeouZf/b27oVs0lLik3YestX4pObV+mKbWsTy5pVsP9UbQy94dg9c2dFXi5mK/L7Pro/d7PCwIsCD0D9b8XBeTH+tbYHma43BFPrnBXyAzVHtEsyb1T0rI3s69JsVjfDjxXL1u5rWiwnaOEMoJig4u3JM0NqiUExQ24lWY2R23ObFw3Q/5vUr1jYm3Qtm7VpcfxyXs/rogH4386/XxGAe06J/HdIthH/t2eaBBOUsZQ+u7Re8+Rtbhx3ReS+W7fmm1o9utg4wJNM6drafkelQDtIkMamU81v4884HDMl/KP+s0H8w0Ld48r8hAeaHW5T/UE7bZvJv49Ke/Hu8azmy97z1C3bMZOeu4rA92Rt2+Le/PV2w4+ONMTxpnB2d89kR+y7xKaGz56EJ3WlmPKPjVN3Ou3Y8I/RnqPHMZw2md95b0rWddee9Gd86dD7ohFNm6HxQb720Hh+HchCtSYAV2pvWLBZrz9LWfCXJpzscKLuZ7bVle/MW3rhVr9e3Mt+OuX+xCXru3xuDNJuvsOt7zlX20879rw20nZTFl7dHy3630PoYjRWyE94+glAu4siUI23jyVcUNepVnB54fr4+35ivHvWs3X5+aG90aJ+dtImmb6ardj28bvcJ80zbLLuXwjvXVNthazP1M3lX2/cRh876nasDZfJl26LZWdhWBr2zsENl9zlYtux0TNk23i70VwT8Ia/PCMXbm/UZq039PV2xtPLba6tlPHvW1Ssto1avPNkI9b9e23vnd41G8e3sjZ/tWfMoX2Sd8UX6HLokss1XO/QqMu91ObT2/GObf2+1g5MENySvep00Xz3q2a4qr57tTkWNctKqvOq9z2MB39nuCVjt8LOzctpKO8XltLVyp9tVf5O0uddVrYjnx3n6qe9ZP84bdwxHvp54/0s59p4tx/sOzcZz/aZuOzqee/mqGuZQ9e/QuCuJ7bX2xsqrzWm7OgZLz9N7OW2HHP6atduqGJlI2m5C/1TVbhOm3XR9QnmOhE50bsLUfUv19+QSL6mrl0dal2n7haR5pDcFdK7VvKyer+y1nd2Hc1vNB3xnYNv1Ofy0O6et3YcTp3f7xPjgSfVO6LNK7/Y1eqfftzlttb0aNDxr26THVJHZV2PP2BW6fMyZGbpuE4G6Cf19Vd2KCcYsSceJE4rXfUyb7czcKDbG1GpulNWBspvFSSZM2TszN4ote1fLjfLwgI3r5NwoVl7vyI2y7UqrcuN0dSm5UaTd25EbRdthazP1M72/Mp/AvwuVGbJbyDmBZrnEBmPKjtv/bufahX5B6fPWmFh53P7asRjMZyrMcxLsRw7F65r1Q3b/g6d/llZ+e+3v6ar27fnqUc/arat14+PF+rbx5E3T7+i8UZIcoV7+v1TUqCOt+jfyrh7fLcfcodXVUBx4QpVhaa2vHpq3mWgB9455m0Z5Xe55m34jr/2KzvYtK50y+9U92xYjDv1KRWPjy5rHkQRYIRvs5XkaCZSt+dLv2rItn/KeJ9PSNssh03r+wcq09x1D829eW3rfcdTQ67YLjYNTUaMstRqDlndZpm/o2fZ3O9u9UNw2bqnwWsUXn8NePeq5pj+p+s10m8j/PUvgs1yYzZSzs+XZ/Oz8fK40u5vB50u+8WAbyp8tZIulqVypMJfPzmanm5YvMtK7WHuu9YivvupvGRtaesFLG/pTVUzjdKUjFVqnvErujwBdKub/CoZzr2ex/l7/YiN992IjvZQ9sNjIozwbVM+0jvM1VP2t20tjCR9pQ3+W6g/4WqHekfdHnfJXmPLr+HbuaRtjsbqde0LP3+cMoze67kC7mhHeeg2+vmd5E9lph17l8rOF0mwhk5nJZRZymfzO1utSfnquRExMLmT459TOLn+qWJyemZqbzBXmS+X5XLZZ+f8FEhXRNnHCAwA=", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index f96690d780a..d6a547ab5fe 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -47,8 +47,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_0.snap index bf187d2ef13..1396e518b8d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_0.snap @@ -47,8 +47,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 8e435c8e4e6..4c82f8dacc2 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/poseidonsponge_x5_254/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -43,8 +43,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "H4sIAAAAAAAA/+29B6DdxnXn/SiRtEgV0pK7HZtUcUtDG2AQJ46c7jQ7zemJBwMgySZxem9K723Te++99957731TvMm3m63Zmt39fn+IwAXB8y4frXkWFeklMsl3cQ8Gg1P/58w5Jw7u/znNfycu/f3kpT9PrP581MHlP/Nn9176M3tgP3lCWtlxrfHEQ2CNNzwE1njjQ2CNJx8Cazz1EFjj6WNY4/SzVkhatBhfjKUXp405fXD4z/yQzzl3/59nLv37htXnCZk0P7O5b0r6Pqu6M8bzJVx/eWa1x8dAvzmzonkM9LOZV17nvh397bPMfHDi4NjeU3XMz9ncunm2g9WzzPc+eTz39ic29zvYPOfB5v5nD46Vp/ITm/vN69nuz/z3W+dr7tut58Tms5P3Xfkc82en7rv8OfRzE/89fnXdlrduWF135+rvd136+zHzY3fMcp3dseeZ59896r6D5WfetxtXv5v3dd7nm9bXbz47s/rs5H2X3+fspX+fXN1nTWtex6nN9Rcv/fuSqTg4vfrO/P3zxv1Pb+5/2bqN32335Yxx/Rnjetm5J136+82X/hMP3bGybWue1M+9l/7Mhs5V1TgMhc9d34dmdOVQtDGG2Pqhb3rv266rhq6vmlj6uhrLWHS9z0PdB9/mW51yGW3nqr4p6zJ3na/rYsyKse9C0/PLZuxiyNsmDF1eDKGumrzko7IcC181Li98XHjzlEG7GH3Ztf1YuLYrutp3sW8qn7m6zFhn07iqzZp+zGI2dpgvN7rMN9H53g0+Fv2ih09btGNosqEYfN+MZRvyoqqaEH2ZuaJyeVfV+Zi70XdVHho3jGXe5q7I/OhCF9raL7byUQbtPHZubPlKN9ShckObdxmbVPDT5LGt2rbK23pkT/qiiK6vhtjkbex8OcRxCO1M+yZrv0Mbs47V1MEPVd6XddZnxVDzKK7Pu9bHsurHCMW6rXjH3uW+boaqHvKiHsOy7jPWuvu+7kLZlPlQtX2RszllPbR91edDH3o2ZujGtuv7dui6OguFKwbeRxXqss3GOsy0z1r7XYWhCDXvrXdFHvM85HnX5HkRuq4fhjITd2RN5zMPG4WWP8umz2DOUA3lkM20b7b2pC+yyH5nnYt5xerYWhHhZbHkMJQx8Crymsuyqm2yuo6+K4ahrRuf981C+xaL9pAhFK0v8nFoq97xtjJWVZcBKlWs87pt2zJ0Q++qMjYwdleFkr9jm9qqcjPtW609aaumCl3Ttl0+5GVb+WEceadFHJq2G0Nflq7P2jzPctdkvFDvQyyyZsizyML7mfZt1rpL37YjRNnDWHVIfjeUnW5XRWgh8A23GuD5UDVDKODOUPBgbZDQtgufnLP4hM2ti2ps6jx0HkkPbR7dWDbs+FCxN23r8t6F2NVd3nUjQlxHblGOvOKiXdZ93qJdwhvtWNZN7semd2PWht67Ki8LF/IyxLHu4PCu5jXDUCNrz+qsRn6zkT1fZOfR5rusQo5JzJ3PmqbKii5HyssIy7VZ15RtzSuMfmjLMVRV5ZuOW7oGlYkIjf3iv95u0kb7uLGvqhBziUbe1U3Wh3HIqxi6nqcILWyeFQUfxxY929RsWT9UvITez7TvsPakl0TytK5tPO+Q3a5KRLOpmiy4gNzDaOy1z4s2uK4N9dgXpa8y1/BKh4UHH2OtO7S8c5i38H3l0Vy82L7tXVahCNF0Lat3sauqIu+4UR8RqyJmJSp3CLFc9vuxFu2xGWPsiwFxi/XQt3Eoa1+MpQ+haHPEHkaDK1CIruHJYKgi9FzT16ErwiKXjzNoFzVatWWtI7qbbXVjE2HrHrnxSHg/IK4tViwgXH09DK7scqxeO6IZO7TMTPvx1rqRMexK7dAola+zwdVdi+nCDASf9V2s6qqDmVAfAZXJFgdEwOVNVZdFkS027QnWumHbrO19GNGw7G3Vli6LaO8sIIh9loWyj+w1YjjCSbHtQo1weex1W2LWZtpPtNaNVmuLWNd5XxWNy1h1yGQqJKxlZGfLIoTIixhzblzJFEfsMgaWm4VFLp9krdv5ElUX2cgai9h0Bbofez70Y9dlDskroke7oAJjm8HQiFMZcpg+VHFsl/1+skE7H8oRcamRjbKvXZA/go1sXNlUI5ZNYpWjHGFwZAfrV8SR197WLCPjezPtp1jrRi0MsetKLA8mKDa8yLzCaUFluHaQZ1HgtAyDH/BcsNmsFi5EJCq+UC1y+QrWfvdjJZ8DQ8zPKM7DQODi1EXf8eSubuved60owko5xtjBRnmD5CMQi3/yVIt2gZqTPWAd7PoIY+RxrGA3XKsa/ivGEUnJYUi5PK2McazLLnZjxD1Z9PfTrP3uQj44HjtKJuqmjr0fi2zwReHqMSsLRCnLRqS/kyfEdVg1x0cFTkcdFz14wVw3O1ghln6ofWxrVBN2lr1E6qJrau5WDX3pXBbGUcKEf4G6bSpconFwC59ctGiXednkCHOse5YcYJgYsiprZNZ9HzNMG3I7FPnEPJGXi530EYtaw7WLH3unxSe8O7ij0iura9zj0rVjrR3ph5aX6tGKddZJLtsMxwHfChtRDDlKnfUstO+yaGMVixHBqDtkvypKXJ+QtU3EzDleVt9VbY34FBlOemyLvByz0esLPAjfmWnfbb1LOcYY97auHd/OG3a9qIoQe4cZ7jKPNR4xeQHvAp8TdwifvkFqOrYo7nz7e6z9xpEsCB0QlrEvCziv6QbncFbr2BVViZ+FRBJB4NJ6lt+AfaBt8W5Rb3232J2nW3sCGzs3DlnvcN9HVyNwWOExwEARBsSdqHteaB8beTKh42F4RwX/M6BzFj55hrXuWPOK8LXzwBJr7CseFa/TedislDXC8xlhGKxTV8IhqPGIW8szjjn2aKb9TGvdA3wGp3ZsB+/T+XpAQCSLRTc67hYLz29d62WPc3QvstMM3DJDKffFTPtZ1roDAY+v+XLfIc7jWLQ4ILAAWqTHcakL6VaXwSBNQB2gGqouImSu7vN8WGg/2+STfCxyX7YwYskXiR9wCHFrswInuR1qvKCsw1NGOoPLQ1EO2D95XDUR104uX9GiPQQosXGuFyUMTz56RNEh8Pk4RgVQMA+aIXOdQ8+ig9l4TFOPUvELf7+StScwVFES6BH2wQIx4jyVODtFMxAewtnouxIrgPPX5ZU8qkbcn6Ouct+MC+1XNmljWVlSPuBIVF5BCZ4wJjLECkeOiKZhz2AK3yqGI2wmrKsy6QjijJ2OfRWLdlfmhHixIFgkgsLHmbwhmB4fBD7glcGLKGJYPFTdFATgr5V4RMhqu/Dgqxq00RMtDmabt8GPuE9lKx6G3cYWp2Io+gyD6lBgcQzOdT1uCyZ7JISTXz0s+juz3uU4NCPxHb6NJ+5osW55ldceLYdlbIJkMWfPuMZh77FLdSUBqtg03WumnVu0cWOw2TxoCVUMJe+yJ5jHDaz6wY/49LC6kwLoM1TaQFwUEbN8QIW7XZxWWLRxGEZ8S6TelVLSPf5yYHNQuU4BUMSfH/BJevwfghFHfBjqThAFfk29+GylRRt2g09wH30tDzvwuMSaSHapUA1b78uIO5+VmCYCCDYazzvGAY+RuHvZk8rikwJxwMvOgEyIskEEAsEfwYYfg/iYCKtTyNCNhN9YkQGxHZCqTLFxbBf+dhafsOS2KnlVaNg4sK3YHGIJ/hxzWGPMeHNEPLxKLA/3xotFvfBQeUOEufj2tbUn0dVDV9YFViUWck96AjbkZwTqwJtHFw4dcVo14EujoYh3RjAgfo0NyXZ+bGPtyYAHqNgFXYH2Yef7oZF30tWEhHhnWAz4eVIqAQXTdE1TCp3hW2tf01u0MVgjIbV3WOBSAt0DmSDZeAjYiY531rS809YVPgAOKegqap8Tj8LhzWLTWmu/Q5OD+ECnkwIPjc/ybBxqrJxi67z3BHGEWAgjHOKIffqISkYZw7FZXGi/msknuGWEHplreYkD2wP/EYN0viWixseCcxxsj24ocILgRbQwRggHa3DNDj95jrnfoF4lmy0TEdkN+CTnhRW9nKcKmKlhuxyGE50FByFEaEWfNy3AE8HVTPvVLdotvkDgzTfjmNWOsA6ngjgB/xL5x19AlYI2oQOwqBWqHt8EHGgAutGzLLRfw9rvBqPdNR2EB4S5xIUkysYZL4iw2A4hRw5pB5jkXrIk7HWM3M0BBe1w8eeatFkcEVT0WT3yrU6qkEAYb7Vp8k64lUP2Q9DdMywIrAr7gBSBWxHEzrRf06KdR9nGSm68AlLQBfwfZA8UhpfWEHljMAhysE+gtJgS8FiCik6X4XXNtO+1aHeDh6F6/Q9M4IcgKLIs2gzz2WPaArxcRfxAUE+CDPk9RIyEKKzED4tcPs+iHQHPBDoSFFcYlwwzrujBE3GATOW1pKiZOB33rUA3YBO6QsCWJ5hY9uS1LD4ZchDGWqgi/jYqFMEucGm7EkAS6LrO2C+8/VIKPiNwxevH0vN2eUFVucjOa1vr5g2hNMd+xCfBHcHvQYsTXbJaoiuYBCcU/Q002YKKESzAeEWJt9wASBaLHnwdg3aO1GAeERSsAXqL+IltJsYPDqd7zPFvCwEd2ATCPnQmWDnASYYlxMnPF1v8utaeYG2RPzB6InRcrBK1WHd4l1VRDZPNAIBR/OGQ8FZxCog92sFVitDr5V2+nkW7zHh4wm352XgTYIot4DqIYzZixgsc/LYRMt3y/pCnsSaeyvFpK+ClZlhi7te3aHsiVX5kz9kVqa6eRwU6hYdbIA0B7wUhIayaKSCMAggVoFeIkl/s5RtY7xIhx69GiWJ9UNtA64ElguaCf2OheaktNn1EobVOXFKVvHOuwgw1uOcz7edb60Z3ghPgZtcFihNSGJaKJ+47pIrIKkMHECJ0BGjOg6kgR0JFcDrwmrqF9huafOKI8jLgkQHnShhuXglY87hUQDGAAh57EAWFoxSQRELYEh0gaA+4YsEh3shaNyzLs8IHLVLkMIjSnbjY1YQN5lgi8HDCz7z0giGID3vUL8EzSRvSMzPtN7bWjfeK2UbUYDv4C8+YiKBwhDsD7FPoIQhhixbcVjfG4gxsHiIFZo6/NNN+E3Pdw8RTGSBHgT+CqEs3R7kiwFHEOTgYcHifwflIZZDjUAFAEsMFMJSZ9ptafBIH8JYA2lvhrwGmoFCAiriPVLTDoCEgBIG1YCTYH7+zJbJtMtQQeMLCgy+waFfkDQiJM+wJ/kPZgRy3oH8NWCExNSAzZhqFPQhJ6HrxNZZC+QbEl8B7pv1Ca08yqVSsNtkF5RuIZIFTcI/hSti6zmBtwrGW95wRT7DDlRYtnUPSpFnW/WbWuyToIqIEEQa+hQsyzBdAHtBaj4AGZWGEMKFs/Ci9gweL0MOTHk2EdM2039yijQnnK1jcqEAjgPnj64Mr8Yt8ykY5ImAsjtzRSLIKlxqlEvBiwN6zxTa8hUUb1xFQAUtSgp+ho2pCQPJyyD0eOAEb71gaFy/D6cYYPiwg2gfPGau2xMVvadGuCPlAQYFOSxJyyifKXQIpxHFHfMC65RehT/HssBKEzaA5GTg2SYmqX3TsW1l8glkICtzdWA0j8DmwoyA7FuUxwGhctqSWN4+dliIhXhhLN+WWgJqWPXmRRZs1EywGYDwyk2HyxsoWeyUJEtwGkIorjL7GQpHQAQJqOpI/LSkevPJF5t/aoJ3h0eNOTjqvJP/SdiUJAHYEEI/UA6kFYGbwG/QO/pvzQNaVMNxSmVdA3Jn225jvktCSXE1TYA8HcXSFTagcIRnigsS2Xnqg0ULHgKZ0uIcxYIzxibj3TPttLdpER5gSsBlUFM43+q6pehyfIPHAY2WL8STKAf+b8LKNfYfTVvku63Gqd/nLt7Nog/YNQ+WAp1uZrIacg4ANtqngrQLQVLxfZHHE98ZLEySDm9L1Yth8h/u8vbXfFRzAHoNEEH7hR4FmEOb0gpN7cBVWqTSoJ+HQ5nhAZIMEk2MpA+y9w6jfwdwTQhmP0zsFITAEmr8bO9ACUB7SaXgTQKcCjoknCeldRxKCPFDFNvKwi+/zjhZtTDrpcAHQQw/6XeH7RBk05aB7fDREvCpZONqkUHq77ZVtJPEPOANQMdN+J2tP5F/iwNcDuxeV5yGhCJ83gUwRpo6d7vEtcV3IBeDUuRjDFLRFoSrNsifvbK276NFUBCOwLZlj8k6eeIPwQahPxJRm+PHS3ChWnCnQMmEcoVZALwM6036xRRvgAhQCJifJWGEbiror4AI0C0gmb20klJd44T2jxQGzR5TyUIDEOSUPZ9rBop0jAoi19rxVMpCXBA4xAjO2eDqeGBifvgarRrvmNV5R7BRJlSgG8O+FdmfR7kfQo84VAFEBwB9oveiU7a8nQedJYBUejpAVnIVbkfclF1EC2KCGxsU2RIM2bDcq0kNZ9T2cwdLx2yMcAqxS+g4TqTKSIEqkdwjAwSjg9FoFAwRFM+3e5JMcNQUmd79/GpVrbgq4KytLXBCyM7iDbVuI8/DRCXbweHqwFoz9APwx0x6sdYMVkQDAARkyVWyQTMPZIzuXI0Rweg0yAH8LygeVJrDFiUBvO6JMELhiwQdHc0+miJhoaRDYkg041fg9DfuPb4XZxDlhb3GDhNPgLWOBASTkwykd5uc6s3dZ0V5qii79/V1Xv09X71W7E5v7HRzYNYDz/c9u1pp2PbsawHfdrGe7P+saQH32bsZazxufrZ9t/dn6Pu9m3MeidTIhrVMJaZ1OSOtRCWndlJDWmYS0ziakdXNCWrckpHVrQlq3JaR1LiGt8wlpPTohrdsT0rojIa3HJKT12IS0HpeQ1uMT0npCQlpPTEjrSQlpPTkhrackpPUKCWk9NSGtpyWkdSEhrYsJad2ZkNZdCWndnZDWPQlpPT0hrWckpPXMhLSelZDWsxPSesWEtF4pIa1XTkjrVRLSetWEtLKEtPKEtIqEtMqEtKqEtFxCWnVCWk1CWj4hrTYhrVdLSOs5CWm9ekJar5GQ1nMT0nrNhLTuTUjreQlpvVZCWq+dkNbrJKT1uglpvV5CWq+fkNYbJKT1/IS03jAhrTdKSOuNE9J6k4S03jQhrRckpPXChLTeLCGtN09I6y0S0nrLhLTeKiGtFyWk9dYJab1NQlpvm5DW2yWk9fYJab1DQlrvmJDWOyWk9c4Jab04Ia2QkFaXkFZMSKtPSGtISGvOkZ+59G+rj0Xh8qmKt21dm2dezU26LIx5qWKzairELAbXBJWt9c1Yq1pi7LuowiSdFJhpW30sCh2Ka8e8r7ouRhXalyTmY64jz32XFZkr2qxUqXTWDqFuuVld510xdE0V/e4ctN3Hoibbn7d+yEeIN/0QqlIlmyoUaobeua7Nu3GsXRF6Lg3VGHzV+LbJ+irbnR+x+lhksRwzl4W6Gx1b4VQdOzg3sPpQtCEv+XwMlXNZ17N/1ZiHsa+jG5siH325nAt4lLknRTaUoQoZu9q3xdg2se3r3NexjuUQVPfjXCyyvFI1XzcUY+NjEWMshtK1bs6zr/tYnNi85zOr3yesCahPbO53cGDXKMz3P7tZa+L1LDUKZzbr2e7PtkbhrLHW88Zn2xqFs8Z9zhr3sWidTEjrVEJapxPSmvl9y4f6uffSnzpQg9zULsSxGjs1Aun6sstjjjQ0sRmHoh5CG0OBgqmHsvKIWeXroc2jiv3PGGtaaPs8d1Xtcp33HdQ5IHehbUsEtPMh77rQji3qwA9j1bVNm6u/zlAMLbRRbkstl9kPJWOJQ9/XRV25rilDr0OFnc9UwNnp5GoXylwHzPMqG5pc/RbKpmpcW/VqgDPTNvuh9EN01VD33dg4tOIYGteFpm0Lna7RecxiYF+G2FeFGgwMvQr2UHdZyEO5OwNi9UPJs6oddSTV1XXn8jGEUWczg+vrMuoER5bXPM3Q+yLrVRadlV2Wj6jgogmuameZWfdD2eqbde3Ag6Fv5vuf3az1uPTNuc16tvuz1TfnjbWeNz5b6+31Z+v7nDfuY9E6m5DWzQlp3ZKQ1tK77GCPTmhLrKuqE0Ojg9k6nli2QzfWmN68U1eTzpWFjsY3Mukon3xQMbBr6mbV88HSCQWGWQbaoxPG1o0ZlGJTFnlZDWMoSx/VBKLv1FWnq1B8vg6+rcam71Ru3+zTCTpF4uPQqipXfS0i9ylii5fQqiyzKpFVnckvM5Xd1qiMsQ1VVxTT4e2i26sTYuXxQ3SEpR1dPxZZUTifu6ysurzFGfNlXYU8H6u+9X7smqizdWNZ9D4vudVW7te0M9RUiLVvhtF1lQ70ZhlqrFUfrZpfDGOJN1nrhJWv1QBDHWfatvMFXlr0w1Zm5ne9fs/rmqAHQ9/M9z97cCVPHoe+efRmPYfJyLx3txtrPW98ttURtxv3ud24j0Xr5oS0bklI69aEtGZ+36cTsLd9ph4TXZZF7wbEKc/zEAvXh6ohoKpd2+L645h0hCljnaMY8qoLdV9GBHOfTihy731W5Tr93PV4OmpJFHXWR2fOu67tdMbOx67SGeg+xmqIXs6EDicRtuzVCUVsBh0kDq6oBgINT+gk5daF6LN2jJ1OBHm1CqlQC0RamcvV/ShHG41t3KcTCiKZOFQ+NF2Jkipc0egkazVUoWvZksznBTs0RmKrKkhP6jRfGNqx94RXYSv3l9HuyzC1mBjU/AFN6DM/eq8eT4otdVSsU0uRLlRZxdb1lQ7I5DiDQy7XbSsz87tev+d1rd+DoW/m+589uJInj0Pf3LFZz2EyMu/dY4y1njc+2+qIxxj3eYxxH4vWLQlp3ZqQ1rmEtGZ+3xs7hBBKN6hRWAdWkQsIKQcd5+tbIhCinELteMpWnYzabiR4wLPIRuEnsW2avTqh6vuOaKQPWd7kPcFO3vJl1+IIxFFn2fKsLYmAwF5coxaNWV9rLeAueCX5Xp0wqA9Syxc8q9OB4Cz3BVhTo+4L6mpRN2rZ6POaaK32Dp8sFjpm2XU9Ics+nZA1IwsOjZRk3feZr8eG2GnsmzyLDqypxzvxahzYtcGjN0f+v/BhaqVIjLSV+8v3JGuAs/JK/SujJ9QMPZszVPg141C1nRyzwM2LvlNDRS7rPTHVqONlQ11tZWZ+1+v3vK7hfTD0zXz/swdX8uRx6JvHbtZzmIzMe/c4Y63njc+2OuJxxn0eZ9zHonVrQlrnEtJ6dEJaM7/fenClTtjy6PUW8996POvZG/PfauzrvHePNtZ63vhsexbH8vUfbdzHonVbQlrnE9K6PSGtWS/MfGj1c84Lr2OhfsDR876fwktCcWLRAcUdqr5Ss2sXg9pJluoN2tajeiREdfxrl/OLVg/gnBB/9DoI6QcwRZ3kL4Ds6w6cARcz9xHfuVLP0bZo1ItBjRV1yFNd0Jp6r03EzQaw9L7Aj/VFOfYx1GMdOjUYB6fEurbEFFXV4HrXap40dj0QqnoJqFn3ggOet9at1nokRcaaQH7geiCFNmtc05Rd9HXRFVU3gQxTFB5JeYS+Lxrn1eevyOstX8/vY/0ujskvPbJOmO9/9uBKvjkOnWDFkhYfz3t3h7HW88Zn27yD5Y/fYdzHonVTQlq3JaR1LiGtmd/36YQCfCwn0hTg14JNNbi2oOkl+TrynFM3yQ6sMJCHIL8ZXeeqXI5iGTKA+F3vQFMn1GMcyA00+HlkOgvwOpKe6uTl8JjLVr39CD47oK7p+Lqaj+dZH1o1ikP77PeT0VKAB1nd1WQjmyaqu2dHlqD1DeF/m1ctwTVqwbF61wxEzRHRJrcRhiaGfTqBb3dlUTV4rugAXw4FmRJyIaRtSzIlra+VIWmBG6L8eTQHWEUGKtmHoo8+PhI7X6kTjit23uYGHkhceVNCWrclpJUydj6KTsjUtSAf8xGwvw1Zn42AUWT9yzqvMeyFmjBEgDySfYUbGt8UKltoOyXvuTzuy3PmfFe91wD/Ct8rZCYTOJKaJMAkz0eCYKxB6IYIGlWQjijzTF2q1N4oL8tm2KdvSG52AHoIu2vVNA+dlnvXlKP633WFhgOoC1jvRjf06rTT5thyVJNrhAru1Td5GcARmkLjS9QauugEN1a+UWvFfBAoGFGeakOHr5CBuuHWDHgfXv3Ghv4o+P31phOOG7+3dMI+/P6oOmGL318vOiGlrjoO/bI3dmi7zgfcZDCvgrwXWHTbkBRv1Wi87pFTnPPg8kbN5EGPcMkD/sPQDLEsh9ju1Qk5DrcECxseVfUzZmq8xo3GrAqhV5/VamqMMqrT8wh2n7W606A6qq7bm+ccKrwCR3IhlOiXrBE2TyjRgNiDl3V49dJlXm21/ViEHB2Xa5aOK3KAu70xTxbBszK1zBw7whKykcWQkb4DExw6T7Dj+gFEMKrDDzdjc3KwvCF3vvbV4JeapbW+ud51wjHhG3t1wnp/rgeM/XrVCSn13szve2OHzmHwBt/XFdn1keg5dI4MdmzIj5dE/cQHIQsV5tf3o7gOTYEzMZBYz+qYX8VPUClArKa5P6H0A3JDDNH4SlA1WcGsz0nXkzLE4OKRd+TMnAPtBzv31d75UFnf9X2JNJZTS3e1m1KPsroB5Cg8OTFfu2JosyKv1KTZg1+TjSRfT9LP85R785xNiKrNmvrpl3y3U1xAwDRW6EW1xq0aVGjlwujqbioqGlr8j4xdVLXCUeqKrjedcNx1RZZO2FdXdFSdkDJX9nDQCTO/P1JreyWPHlet7TaP8UDqUG9PSOt8QlrnEtLa2i3LtmSlRsYBJ3tMTNsQjRZl43AxydGSGG7UIzZviWu7CjdTYzK8J64FrPINf9vrb2a5uosTaAbRClVThFL/drh/VazrKnQaUEnKVm6g2mT2BTdwRT81ht1ba5urzzQ2dsxjrobu49SdODZqSssjaHBF7JrOYROratDEIu9xZIGyB/Cput+bL2+7Nic9wDKx1EB+bdCjq6SXLDEO7qC5NuCCWTd1zndqaekIfz2Lj+P++YAsjOxArWkIZVRv+yIHM2hU7VJhIqt2YIu7sRBsF8fRF/zCAQS0VaEkxd64PDR+IE3ugCN9q+69LLKVJa3yBpJxolNg2LMsslG9JnZgnWPVe42m2ocDIt/9NL9m6Ehqe7UbHYeICxCEXeihxDZTk2SioCYD6Aw8WxbJr6gUaW8uXmMYNO6qF66Yq85JvXMrkJYxDy5kNZkGjauDXwbyJSNpFMErxDNAjFXc5hYu35MegtVY1DrS0ZLBKHhdbEjFn3hoTa3ZkYFt8W3TBaf5TdOg1qJQ/+C4N88PClNrlmSjvu3TGCXgG7bH1dUQYs39IstvCdDAYgouyrMOhAipqtSqf6ZtzQfUALBYFSMboNatSOZQAO46wkkNEsiKqiirUcVShYDYrgjwkYK1Mu96v5uDYM0HzMk+sYGhIZdUEY5FTwCpSXLtQBhZVZog0Ah/HlVgD8Sb+XoazdFUbbnqo23NB8x0DKhXb9sOsRlQISDDDYhxyDMNlR00K2zMhowE0hDqEJzaJ1fTGZxY7WTemg+YezEDpAG0x7qQ4Ki8LfShqfGxge6d3GnczkxTt2LbFZrHUEaQLZTbsifWfMCchBfsi0oCex+ygk3GLfV9lU9vsUA75WHo8OMLecYhJ5/WkinIgMQ7t5uZaM4HrBpNFZNcO2KE2LQakwglvHiNLiTjkI9doy6taKm+Ln0ATGszFb4SICyyY80HzIjWKzxn4e15WWVNA8bWN2wzEYPaMecoAbILmj9Kok5zqxofc9IPUVN5lhoZaz5g0agXNGBfGyvWXiNKJCsDiB6JP96oWsUjgjjyLIJ3TAASYhaHjg9HBGqmbc0H1PmC6JV+GAvN6KpRbq2mK3WDcpgNAUmboxMDul3j0LIaQKIjhzGgft2uB701H7DokWz4VBMEBl90dVn3HmYeWl81ddepjTlAhG9rTfTqal4DirYGS5nGgCyxmDUfUIdGdE6iLwhiJMwq3p7aZgf4nSiJZBB4j26Sk3at1U2/cJqqMain94KrmvMBY6YO9lnftx2KQg/rCPUwn1ETiRBvHWjzqL9KPbwFJ/EyMMUkilA4y7mXC9a6NRWg7wclq/pI1nnIM3g8hIipRPlnmNEizzT3IpCWctUg66nxsTUp7N35kYsG7QwlCi5Vd5p8oj7dfQ4oDgQ89LFvpVKEAJMaGjSTrSwrhxIYR6wqv3dx0bF3WnuCWta0lsKVnV4d75EnIXLGSSCjjgrMpha9ZMO7ZkT3lQSYuYaA4Ffk/YK13WXSJlPPosjo40hE7KamORYFaolUYJ1r1pHXyT7YUZMPC1XpOvJa04jTftFV1nxA1D0WlWdvpmFQJOWLURV4AOHkDUjEl74ImhOheQPBayaIz3tBiNy63M0QseYDFmgdfA3EsscqxhwBGnwJ3qZ+3IOqWQEjY187fCqPLsCZ6hWLt5VmLGXLbAhrPmCmivwM/ui7fGoy7SYXi2y/plCwMHXKRy2h571wB1eXFYyJXkfm8cRm2uZ8QA9DoUDwqdQoX6JBApQkZ11rRCUIIaa+qpyOUeKSFmifvqo1WLorPTjHTNucDwgx2Lvk5bdl1wcW5HRqEt2sGW+wCqBkwHDWNV4m1qPlQXFQRvUZr3b8/SyLT4qhbDxuo06AaGQcgGlsR/bYBScnFITE+07j+romd7zTLC/xgeRnYEAW/f1sizaGBBsFf0l7Y859FtSseyzxrzXnFChV03Mx/hqzjTkYscNqpy92yhcetOYDAgj3IQZNT1OT7koTVqImWJUDnkPbsrMaQ4gNqgusGS+n4F5cNaoYfDd70JwPqMEXyikFX7AnGviL761h33w/B0TSeeFB3lQ+gIKRKu7xloGxe2FLu1y5OR9Q4LPrx7oiySXBdzrnluvMCiBVqfT7MLXh18gT4opR3fMDFnRsWiXZZ9rmfMA6kOlqNEIA/6mvyr7FB+Ft9TjcJdbMyXNF8GFUcn615hfXPF2BYxWwpzNtez5go1dTlrHUtOZec70B2wXe5eWovFrJ+8X8omd8y51Ucw5janJBG93C35lF22lyR5XhI7MJ4GelBv+yz1EDb+ESaSSyBT7ghqNfeRMhjoRtAReg2+23NR8QeSTb2MifrzMVKYHWA8UNGlbSVooUyPBlpSZZVEHjATBDRCe4XLjsRAIzbXM+IJ5erqIh3FX2spjm1ufyRgaNT5SkhwGBhMcbR7yI60lUCeP6LnfkCGba5nxAYqigEeroedfWbAkeJ2xR88/AVuRdc7/HpS2RRcO8s9m9Rt/DrIttqKz9HkJZ4MrjXZaSEe/LPOJ+k9jAXRvY15o9iy0BEAZoRBVjtYtWCVQCwbC8S3M+YIvc9b4WhItmI+TtsGFZ3TQo2KqRF8Cy60K6LPYZ1kJBA15ERlqJjM1M25oPiBqEvTIcMRRgxv4G32rCnOY9RrRgQ9wwllMvfYQd9hukAUtcrExDwBZdZc4HVIYbFLrMCEyI7fTeRg0h64Yy0xxXtnVQCDVNpi+ItSLrJegfNWt2Z+fN+YD9iBAPTY2ctarDgXEwuTneLRH2iDZh2+GhAbNHaIbhlvPYIz51QHYXPrHmAxIN4DBEMQmmEteSRHfbjarC6ZFKfHGy4bg6LWqSQMLr4Ar6qtaolwaFOdO25gMWTVaSwM9wInB3CMU04bvHzcH+whbsigN/IKDXAWXnI0BFp5kQucYAoVRm2tZ8wNwjl75ViQ6gQFZVBLsNaErtpqgkr4TdE6eQcgDV0MTHoFHjmrJU5O2ujtCcD1gpriSK7geC1diP+CDgBqHoPBGtTuV5XBe8Bw30ypp8xNeCTWqYtOlivnc+IIk9hGbQwKdRjF0SHbDLeaWBCxr/SdBHLFsrxlRRfzviKzW4Gpp2Qew10zbnA/KOimaqptcgULKt+Dxt7HDMyLXU6rLQYw9wHxRpZkM3/QLF0uE4ruaKW/MBSYhCMLaNhmIUmq0CnhIAR2pNMe3kufih1eFPXiEKG/2L09VmZa5S/3zhk3utPZGGLTVkT3kaIvCi1Ix7hFCnIHo/aGhIh7LB2OiMNyELHltWgc2gqXYzy59n0QYsajrc1W7UCCICqqnwo8vFO7B7RYyVI7XohFxlWmyzgu4QBtehDZd1v5ZF28la4fWNQQfvg86n5t7xzCMhdmhHWM/L5pUaqAa012vwpspIAH0IrGbar229yw6lim9GYFpBsx/AwsBQXKi4KxFx1w6j+oKw5bxMXJ+mJhgl0mg1Y3enT6z5gAWohWYNVZmO3EcQOrQ4GfUO5wOvAt/CETNV6gPAJTo0n+PEAOCokK7Z+fbWfECwDOGh6HmQQDilwvCDnWhKie6JOClCJLrlVlhKzTklbMQu5TwtCOJM25oPCKei9DTvE/8XuCgSypPaA8KsoAR7DKTPnYa9hQqEguRhTqRY5jibveY+z7St+YBwMQEUYtfw4qppomZADxJIjRNsyNIIbkdCF8/+NsrMk/ZvSvFpLHbzYN7A5pNO82uDgvSRP7JRFVJOZ2cw8bhnGquUgc8EjaQdQFMynbfG/uHm7mb7PN+gneEOy9vGdikCQ4EONeyXE7YRTWpaFvEYlgJojLhz0EQuIlZQsabXhLKFT97QWjeWHCCCgEcjOjEG6KioSqwA4oZjJLwxIwwHeg1N7AI2g/iePCaiqolzM21rPqACa8y1TE6rodHkTAs5ygR8mjfluQc+UNljpIH4Cg3mGQVlK5Cri2rZb3M+ICI3NBhVzbAiJsiQHlm2WvOhEXFNTM5UmgIQIjdcR73YDvSB9iVffJ83MXkQ3Q8KEDU5FmCRUF0jzvoSogPKnFS33iXaScyC/60q0CIAwQO51dmiq6z5gHnuYGIsC9wGVjpojroKXQeNjq7R2Lj9gNIlGIdSDK7X5g/gTyALmWsXXWXNB8zKXliB8t8IYhn0VjFWwB0etAbpwb1FuQNUa7SkBsvxWzIDYYJvhoX2Cw3ahQJdDXtvNTU2I7AeCX7gDl5x5NUqyCx07BWbrjnPDXE2mKomM3p8gb3zAQv1L8lRcBmoDPGNgA20kWqR+xr2U+8gkO6C6BPIIB80nhX90/i2bdRiaaZtzQcsAJ/bSmgo4gwOnU8BCt58AG5oJytGKCQTFDHZKB2iE4J/8gG1xjstcYM1H5C0RVd4YWmNZlwTTQOOtsCoMa+nuX7gXqPupNFKuMcjvy94DEL/IMmcab+lxScYbY1DA93OfHSaNA9oojHOpBOIIgZUQq2WL4NmYhHTE8kWOIxVQO2icGba1nxAqYqO70OuYhc869WIQyDGJgNcJmTGw8Hz0bG/lqATT4tYq9YhQ3RQs/C3NR8QRxD4old7JuQu0xitoSrRgyQKULY1AUpP6EcgjN9GPESgEwS34NQR3e3meVnzARU2EUHhkeBeEsbjDeI/aRw4odM0Xg+5ZbE5igqIE+Ou5hAdGqUnAAh75wNq0C3Jop73Cbhb4SmT+ou1zm5XY6nRo8QSeQ5iM+DJ9YLaIwoXHyMj4ZMt+sSaDygtIoi3lOHhfSGbqgjxOkfZoa57tZCImvIIPJtjo0F9h6gi1U76ZYmlrPmA4JYK6HvQVkw4sAsxL/DdgN/sCLd1+Aam11S74OoWRh35nVBVQlpC7uVdWvMBgbM0mxnxLFk3wjeAQhCqkyXA7RnracAtAQMuDGZH7hZiBhqEx8nFuzo/cz5gp3F9rAqAi7heEBNZO5Iw5DcyYW8Exxl2uW9wBzGfeitEyORTycPVu3Oz72jyIMlKD/ilOkJ4qyaoAqORk0XAhGEpNPtVQxqlgQFOpLVaZQDJZuLuzrSt+YD4bKh6AJhAhBoVbY+AvoXAf0QdFx77jINGJo8Up0Zda+IeaTJEKKiDykzbmg8IU4xCHDEFaicHHOtAqEr0KNEeekBbluFnTUoAa41GRrtGYHK0cL3TJy+29ps4p9XMxIEs1KgzUjjINV4zniCBb1TuDNhLk3pr7PbQKR9TtHo2VxW7ucvBWrdGBpMoQQSx4oRTcgVBTcD/YGtp6ZZQG9ZQKyY8qpJ8TYv4IxZAXbtZj51Fmzxhpxl1avOCbJLNjQrHwE3wJTQrFTSagCFHARIi6kgzTjgOYSFfaVz4O1p7QhRCQFJo7B3BNE/B98Bcgf9RSvLQOiL9IBzFYTun1lModuJLbD2/m2n3Jp/g9YJZ8vZjA5hIthiRAcoFxkTLIn8kLYf7HTa0a1eDx5bShyTL2nI3b9SaD6iRi+SASsQ4CDEq4e0IsqtIEtmR74JPoowrnrOfxieCybpcc2G5aIldzfmAvboLKrdPwhWBAJyqxx7Ljq0E4BCw1IN9IkjoLR2gaQNvE0kDg4xxN+vxXa11u0l+0R8dK8uA/fHmwTrQta3wF/FK0Lk+bB/ZbeKQWtNDkfcYlWefab+b9S4bcD6wT5giU74Tdlc/QmW0uR84Bi+wFEDRoG/A+3INZidbiDohcHPLnvwra08yDIj6PQrf0hEm8GmsLv6Pol6Ut6Bjp7GhpE/iiIbAG0dMxyEv0WiLrnp3izYxqK+UwxmDpJicFiAdcKHyTzB6L1wv+lJjGTW+kiwT6D1Xx8jf6mVP3sPcbxxJuDXjwUeAK5QojjuuJyw9gqrg549TwQV+vtMEdAKqUhKMfevyHfb4nta6CehKzSRu5c8SjYJ44EcAEeJsAzSASCjTCjqBAIAdtASaUfNuiZPLcYezvcRaNxC5Gr/gezSt4DaMiVPdNgmugqBT5zr6DGwAFVmg6MGwJcTA+bzMolp8zfcy143SJ14YBUYAGaPc4JA6B1rkZZW9hsWyN9iyXE4j7BIFhcrll0+3+JrvbdHWzGNMCTh8j1vVSseBicaenBSQAd5VmM6JysVSFwX2r4EXx2lAddydZ3kfi/Y0b5lck6B+3rxqxwmPc+WiFTED5gn1LJtS5aquElE/Ncrj3qj2mfb7Wvs9ksjKBNmRXRZFXIdeON2olqAk2EKt8e7y9Wsvq4OnRqJY7gpIV7Hs9/tZ68avQ6rJ7WBiepiNqFWVNMo8SBtVGhBNerpTFIRzBPsDtxGHKqUedut+f4M2WXycApitI+NJqpFsEd5EK3cIbaeuqk6oL/Gmgjcyg0QWJA7xPVVssZsD/AHWnpBwvt9FQhN5rzwollalJkSnZOlwqEhXNaFrp7X2na7sBKwA0PS7+pMPNPcb2ELgTjOVWACR4kMqnG54p4Dccj0HFAuBeTdq4Dy/g7czoPwyhF0/kg+yaKOE2OE8KqZxcn2CcDUSSo0cBeIymJM8DXETcJVQQxxjXnGrcp16N5f2g639Vi9F1JAT5Kt8LTBGBhJWlBoyD0ofNOMWxEcDlytiZVWjdUOGN410+WVPPsTiE50FRSxVnRZ4fdoWXi5pYvIx+fTStOCSTDEunXxx9UTJiYg7As3dnOsPNWnDx0VPXJd1KrOCSi3UsiPJWGhy76jx32MDAj8KY0EWFMQ6fodDtrMNH2btCaoOrnAkawIE0f5OmIRvRlBavJwGtUQIzid49QSXZFGQWEKtNlMebMFmPtyiDXfwVWw8YB8mIFdFFTlMQGgHFlgpbkWrAo0pZcqmoOVHtXAih64aoJn2R1h7kpc6scJWk17gRWHKERXce0x7jRhhfruByK0Ek8WdA3og7uaFVCpTa3c59I+0aOuMbAzKdZUkc0B+QDHI86NHVG4FMkCUSlJEKH1TKNeJr46WUPsvoKDlXX6UtSckMxAGMn4ou1qRB8KG3g3kj3GHhW2WOkSsYdxl4KFINOBYVKrGCv2ulug+g3am00FkWDNNrlZemx3Ao/X4+UQ6WIaoYwtdhxPet+gakpsFeClGg9Bl2J0Z/GhrT8AScwQuy0jm4C2Aanjhc+yMGgoiSYTuDQ+XK4eiUiZCFNQXphBd1S+2+GMs2qyow40s1dF5VANmglQg3ZpQSuel+K2OOVSqgMHFr1WU4ZUcBwZFeBYd+7Hmusk4IWtE3aj8TmVQo45gVGUNMzsVncA0I9gQ6CpoAoliVbuqTlTQyrInH2fRRnPEkI/iENQz2QfBP2rqQNoV9Fd1LlMFJQG4OFUdcXX8C2ydF5Evvv3HW++S/A5IHTETemlUDyMYN9MJLYBOkFrg0WEUMhN0upzUGk5BprgBnK0j1pxpf4JBmxVjxkZPhoeMalQvCpRIh2gjGV5JR3kW4D8IItAYiFiL9zjCmnnWlLv48hMt2iUche3DWg3KWxJxVwPOfKPsPgqkkEsP1O0nNxHcDdcuqm0tgDihzLInn2TtCVopIjLAeHXZgyoidY54g1Bd4SWQCuY+kytFXN4ACoZyyNESRPS8qmGxO59s0eaNtUQArlBFD7ahUkITZg+5tgokk6yvcEMQ/BGQplMRYa2cRtSE9EWffIrFJ+ocnKvtnnK2BFXk1DqcSjRvprqQIlNAgY8OftrgJ6IgmkalWCQ4slUM+KnWfpOsKVGy+CAofgXU7BB5u0pVveDcfnCqmlFdVwQplVMSCGexRNVI0LnwyaeZ+61SNiGioa5Ve4drmeEfYFeIkjGK+E8ZAZq8T9WDlcB9jhCQ6JgEYrPYhk83141DpiIwACKyI4P8s5rcA1CxTmPzMEMJ6oWlQ6M5pB513qHflNNAWpfals+w1h1Ubox3OsKJKiOqCwkdsWovN79QVKueySTPed+gBYUy19Iu2ME6Ljr2M613SWw7Ssg8Fgq3B9cMyp1iU2Izj3ir0SOxBcBaq0RKT9Qzqvly5UnYLTbts6w96XWKCxnOB5hWyCCOA8mRKDBAqNsQcZCbsQTWqFW+GTCm2UjqCovR7OTys611o4uVuCADiFeM34tfQ0yJwJdDh7gS4MhVAb8DGGD3iOkKFcChbtRfe6H9r639xiNRxIFLRqSdIzd4qoC5gI0eX3BqZy2XB1d2rEviXDdl3yowrRF7tPgnn2PtCWqoV7ftSCztEJNGpxJI60BJDrhiN0AxkAh5cfiBVdaWAB8EcLFeYdSfa62bNWv8Aag8WVSXg6BkAKWOsJOXW6Gz5LoABfbNwAaBciimYxP10nEVZ9qfZ60bafeoTK8kAKYRv2bQATnsG1szquc3CSMiQLADTA3rDqrmByQTEtIs/P355n63DaEZEEBQszwMlQN6JAEaUbvsOGgHdsaBOUERKK4kLUD41pMA71UsOdP+ApN2iADrwNwqKFAFOD4h3CzYFS/Eq9BPrRQGlaXBdsCdRcli9JoAbxdb/IXWnmSohhr4UlU3bKz0Gy4OjpvHTqgLodzPqa5G1bbAG2g2WD8ItR13detfZK0beAdovwL8V20WbNPpjAGeZoWM6zRAIT92xNMkDYFurHr0Y1A5Brkxv/gnX2ytm73Gn0LX9yN0QaGqUcXYpY7HAEriGwMgtGPAlwXyAMrHiyBXra7KMM/yLr/EoI38DsR2rTC0niQFVkcVKKrbld+DQzewepxKoHWwNzxGwDuv1i84PnGHKX2p+S5H0i9kBQTGOoW9+HpwnlMxaz+deCc1RQhRx0z9qAg7SdMT8/eY/mZXI/Jl1p6A+6vGu8scaCvoNhAS+Q+SVUD5vDnyI3jeU+vqkQ8EhqkqJZYVgQkaZ6b95RZtDKCSXsFXUtlFADjG5wny2cR76EcQD0AxcKu+LQv5x61AJiJbYNZlT77Cok0AlanyVZ0cgf8zXiBhZASZ4dX2A6bFwZuYjtLJ9AC6A5iOKvOMyirNtL/Sepe5Ol3WQCWFDg+TggdVIzqoerXZRQGQxpWOwvMhXuOBsM9u9HmugLDf6ZOvst4l9jf0YINOlYyEB9DD98CJrZXeEbYL6MZjtIpd5djisNSKBfC4MH0z7a+21u29zKUKKTzADkEYOA0+Ss72YCsblDRhOYwyYChqtRcg56gDLECIaoo50/4aa939/ehJqyWrV6/KBgrNaUEN4nSDLZOiYbuxBYILMEHElVG1Snh5u3r7r7XeJUmsSueXSEgDORBpgvyqIXOjFOJ0KsspTa3ENqGwQx+AaQ/kXMsRcHKh/XXWuolfWqEm6vDJ2vDOcHZQ0MC9ABINnqFTIAwxYCycIHmEoH24dbzPsNjLr7f2O+Ku5sBEUQfs0CkdQSBAYCskpVBTCpxuVcmRt1Apf6Z+TWrIwnfqfpc7+gZr3R69VOskTHQqOkbfxS4UU3cYVbKDRQKooV8j75aNwQkjkq0wp02h5lYz7W+0aCtbO6WWwQaEV5FnqAS9OtUwEPUNKMZcZh0pjSqhyZupOhoJw6gue/JNFu2SKAfvhGRig+uo9hME3ApREcooZBrUTXlLcF25AwPoAYGtSoNGlVLPtL/Zot3WPQlasE0Sb2wE2JhXHOnE4KWgTRXxgzk52QiwB0AVjInquKYj+zPtb7HeJUsiwYN50jglFFDT1Z16UDcAlxh3r0NRah3Am+zVcacPrba6kJLMdud3vtWi7YBiKwCaURyooADhdp1KT6IK5PIe9e4JUMhtdLhxRVdnAuE1/QMRXdb9bRZtDUgiWu908lIVBdORInL8hJyAgAWeofofNOV0eIAcJKonKDBEvWGVFt/+2y3a+HaNdBqQGCkvV6ojN8ky8BEg5ApIQxXkOIZE9QrYkH+NSQLZVivzXa7uOwzaoKzg2pgFRFmIzzhFZdi5WKkChRiFN6tSHLA+15PxJwEGKIN7EdXkZeHv77T4BJ8AwuSbhVyWU81MpZN/rBNF4PHZdL5oqp9zQykDXxIgInABN313jvG7rD1BvdWtypcLHZvCvQQTIwuW3S/p8tUI8smMoGBzlaCRICOlpNvonNWSl/pua92OZ8Me8spJH+iMR4Gnhz+hEw1E8gSIQD/gR8ik60mK4/FGHAiCZGzQLp/2PdZ+Vw5PxoM0oAK9ajEr3HBUuYqdiTp1qBNCqBmF/MAyEXcGyLTIpSN3MeD3WnsCEIGLlNetSihwBluiiBK4qwNMzuRWwEkjb5HIhCAfFHTEtSW4QN0MhNAz7e+z9kQ+LCAUWmKoCEtU702APalelogWyNUATMiYHzNHKp0ME176UKst9c7X/H5r3V4VrFkkj8PyxGkFnn5QyABEi/tGtIf0EAKrBoZXrLMCZCWCcgJup6t+wFx3qbOLGkIWlewLo/L0PhMIjUqBvOcCnUuLgD8Eb0DXZU0SOlQRv3bhkx+0aKvxGIE6oA5JhRyIRJl0Qt9KeXI4HjNKKlk1bHj6RE9jADkgI0ZgjCJb5PKHLD4hAQy4qMozon+kCIugsg38fc1Pw6DXU7ZLGQceTJXbrY5NhqIEetmdG/1ha92ou7zGX5V05zqWDL5GqgVO6IhNOjRjBo4OcI9THoKc2lIzSTQiATx8of0j5rtE8aHgcO7A0yCPPiWGUBls0DC8RhABfj8vsKuF12AsCbyAbjDbcVdn+qPWnvB2WFGt8xcjKWlsd9QJxc43SpgNYDzApZ1OvjU6II5qRasJmMH4+N0Zsh+zaJPXzuSrd+DQgFw4YriogA3E9sSbnjwdzrcyj5km3tQD+HqtmqWoWQw72flxizY4ldMZQAGP6A4iSqXViFWnDnk4f+AcKuoi6+srHVkm2akwDUiMiH7x7X/C5hOi21znLFk5DhOSIwEC3SRQDqMQvKhEpK91Cp7AjW3GXpKPJGbbzQv8SYs2QUtshViQz8fg1ip1LAWosWiSEVNU39SdDl+iZwGFEFX8TaUhkdclTvspc7/lNLTyoHR4C9UiBavi+xHOHsj/tV6yhcXRhDInEFun1VW9DdssccNPG7QzVENPdjSi7pV2JoDkufEGkXisY1BPIDyegIocaiH35ZRmQkKlzpplv3/Goj1VzHSFDmThA+cAkUUHOF0TUaGge6FUgxxoNCLARoknUEpgvYrDgVdn2j9r7rdIedUPBt4RmcvGyQ4QfmMdBp3jRE7hcbJsZL/A8kgegVyJyX29O/PxcwZtohYdplR/NDUTIPTIVe03KkLtPSTw9MmKsd2aMJnXQcd74BKw2ErlpjPtn7f2BKHwjc4vo5wwmtBonUAvggkwOziiUjvUoJ4CYXBqq+aJ5dAlOjC4y3P/gkUbBLYseI2Dzlrh68AE0wAqcRpOKE/Ry4ep8Rg01wRkBS1Y4nvpYGy2+Mi/aO0JGe2WPSDcaKd+G/WA99PrYCA5Dbx8FS/mKINOakfdJjGlEREoAVrjrn7wl6x3mXvlarU63g1gI6aLR+5UQlPA0zqUBOauA1+EWoSzaqSpCiNMJx7Lsie/bNEucdg6EvtkEaVAsAiFDqcRrRGSdHgjuJpE2SUvF6uKCIN14qi02Fjw1kXmf8Xak1GNc3lwlF2P2la2C+QLOAYviJxpqxT1qCPiDZsxDOoNgi/gcoUZ5a5G5Fetd+lVVQ6Gm5EIUHtcIECSzwLbQLqj6tkFIOkcbBRrgvwCvfet2jIIvp5p/5pFG+vl2BIAYiARHB7YmmRwJpvbTMVt2mOAKQf47UMs4X98UeBsPJe4q4n/dWu/MY4EO5iDAl+GDCOuKtq0yuEGfK66x2ElviKCByxBvRaqWlSGgg0rVr7Pb5i0wRdqnaRVAT3ucSX1rQJCvq7EOYCHTAeKD1EXdCBPnagHIyFPd6b9mxZtYZmkzSuc4UppEvxjnVosOh2ZKGvQAxw6pUuaKRNApqqD5z3YTadD3jPt37Joq79CYLW47mJqQSRAs6MQxoqQuyzBrFQwDESrPs+4FwLbvQ70opiXdf+2RRsMA82MysYWVjXh5kAGtOvlcuK6TviVw+7qaHvIZS1UyRAByMhbk5ycaf+OuW6deO469XVjy32TqXrTOywMsABkxPcjBpPgTR0mAcFqVdTqACWR82Lnf9einYOxquIOVJEUlc5Y5kQ8LZ4IkYRTBd1U8ispVAehZvA8KvY7wqh+Z9N+z6BNDk5N4NTQA2o6x0MaQT0KUHJNJh9z7KV2MfJNrslTqg4oZUM65TUWufx9izbqSXlIoIYSJaqSd+QdPlb7IHLzU/KPyAKQHOgbyKCBz72qTnutfHmXf2DQBvcBJB3AGOFwIG3c2LJWwwlcfXUAURIUW0wSs1EPUXL3wIYo5jBVze3O0v6hRRtxgb/J/csZIzpQgKluOQDU2Dd1LABcQSlGdUSBMiY4V9yto97d7lzGH1m0wddGpXZIOujIsNfYwLpGMDWVC/HsYBllJDQYALvH20AJTH1/idd2NVB/bO13pVLKQsMPyckNQOoAVoBBfFuovboogwY51LhUGY4pxg7nAl0QlVZZfOQ/MWjzDtsWJGoECcuQcwEEgDT4amQumkpGp8Bc52pyqr45XKNz07WGmMLri53/U4s2ugSnHjHTKZIWh1UwjDDfEs9PSSsB9B6EKepEWK8uiYXGSXRCO3ex659Z+x2aCC+QyOgKskNDH8eo45W4+uR08bkANMi5DKhHNAhA9ajZ0oDCIPDEKIvP9ufWfqvbiRKuXd30GsxY6QgW7ljdqKsA4Wqv5rQeDSZIEDe5lxJz0waSSp9p/4W1bh0ArpwXfobHOeQ64NQNYDBYCZ1oVb8WAApyTIDWqIeomn8sfY9yWdniv7T2mwwCSSP0Q6McjL+/ureH3UBQRkJsTDvbDJoO39QTNB2UQOI9EHHsYqm/svaESBrT3TeoPDKJLmI8UXZDo9hv9Nk4FXPCP6XKFvA4VMYAbgUEUGCPFz34byza4NMELwMIBEBVS0qmbINOPmPsOqdBIuQ1cMN1Mg2XSo2zI0YfqCJmxFULn/y1tSeADfiTuFdBZQpeOVDV5ahdVaET9aQXO1WAonKBgXB9ghqdsWeAlWQpZtp/Y64byshCp2r4kVgKrCqScA4gHJ3aS9RRPd9Ud6EzZQN2GqYseONBkemy339r0UYydM4Zzm2UZcFzEhe6oHmB2KFpEEKuYegkufU3hKwhbMjJw4Ru50P8nbUn6m/iFA/A5KgWjLEQH6eT8qRDFE/xRgZ1mMFRn/J/pQKBDldXLt1M+6UGbTJkCvc68ICcFA+KNFdDAmScSInUj8pN1PoCtsS/qnWQ2QtoIRjlde/Ou/5ba9096rMmGYpcoqQ9DiZZEvJZoEu5pquQLse3aHC4cDijynJx16ZeWqMykDPtv7f2u65UGEvcAcCPV09GeMwEosk44rjgHLZybZ2ANy94FpXbqjhF/uHu3NE/WLQzHZJHf+LfqTFaFQSmtYof2XNgPB0pJG+BePbAVYHcaOMmNgTLwj+caf9/1p6o382AwkZu0PYdPnMeezWJ0PkFgJ8AaoJnmNXku8AJdMSUDdIiKr+aV/nvrHcJjkG6VXUIPdhV49V7S4WNIHVRDUtK5ZEbWR9S0P04VbzKsIGVsawlJvn31p5Ugvx17DHX4RrQGbQ/3yPjE1RRM6rDjQbiuUHIJ+lXtlo9CZW5b3d95f7Rok24BWblI1awUl8Z4ik2AG4AvEP/KUuHsq64HQY+06kpD9MK+fSuLRfb8B+sPakUNVYjerQh866TQEC7zRScAT0KTCUIJA0lxzDoQBzeELdRboa4ZaH9H611Kzs/qmwag9Dr+HcrLGDqyyiMk5B4UO5x8MBiuYpnVM0BnKyz+vUuJ/CfLNo48Sp09V1f6GQXwaqOF+O/erVcIIIsiK/xa4WrNCjwiKbNgtMQUdUwzbT/s0E7ByLNCcBwsoc6Z6PBYlt1cAG8RIo6NY/EeqLcdWJPxybIAgGVk5lVLfBC+79YtPEvVXwLiqTz4r2AklLOGWlAIMySHerQwaSqRh3QdWrIPtZZVw0qANrVhf1Xc0/UBwtF26D8VQSrKREaXejUvXMs1OVDAxdxRgCaBOXlGmOPo5mR2qsXPfhP1rpHVTuUmi5FrE1gRqCeA6CEVt4kCRFNoCB1rxSDHg4+RxOA2/KYeMmL//3fDiwezApB/1mf6+QR3neTEc9qXgaaiJAW12jsKo2XViaX0HlEySOqgJMYzEUP/ndrTwgZIzxFOjXHAcwj+0mARz4ERwgLnZHwGVVsQlaC/K4aS6pPG+YJT67Y1fX+D4s2Sgq5JGvmdeJcHko5ic/U30QdQBHxjMg702hJUpG8fGA24nSdYtnVtvxPa79bQWzClEoSZoo2SDqrd2aeBY27zaRTSHQB3akTpgOjIYyuUIcNcrXTJ//Lok0eF1nDoVYYWDi8Ytfi+OHb+GkmOFbTqbMfiVcceuUzhZ6i3HklvJ6Z9v+29gTjVOIKNoSYOZkdnb3oyc7h+8HHstFTCpwdwsciJuzUHDTn5avjCpHXTPufLdqqKPGEfIrU1U2L6/Hd2gq5w3sjFMllzmqwXeI1jRBXJxOMqY4mlH7xIf6PtScqty6Fn+mcLtsIhoFPKzcTIJa0YtSgdHLGmp2KYsVVrzRgFIMkvbbEO//X3BPy/apSyababngia9CgsDWuMQpMBXm8D4mv2kyR19Cgdv7Pq+feLlf3/6x1q44PbAMfmZ3ADsMLbirh0EAHIE+dRcUEdypTqFQShm7gzfB3VX0tNu3+/9msG6gSjcaGkq7VMTGdQChVd1yRvHAVpgXjgIInt4jj1WCVCD5rdb0CMtqd+Thh0NYQVEUOcLIn+FVhs8pV3VR8OKjMclAnIsJ81AmGIigdrrMUapXbFouuusGgnalxkRLEYNUElqPaSsjgtj3KDxVDnmQqCyikD5Rib6TtCUVVsoSanWnfaO1JUIMF8ikOKGro1CywxUBkandZtzpxBJiP69fpVFmr+vhIiifD+8TzybKF9klrT3C/MzXYZA3IMXAiSSQ8V7IAnRrm14HUDsoW57WZOnIBogyqwlM4jymaaZ+yaPMSSdLpEGZRqRnnoOqfySqMatRIbDDqOBMmMqixgupsMHc64NS3K0zptLUnhY5UqR9lxZsnRwJUUmKSnbBlwGV8inrAZdMhnBZFX2Y6PK/TSvwahp9pP8p6l66oNHYQjwFvnYxRyRLxt1X5R8JrxE/piDV7Fa62meYutSOco4IUkk3Nsu6bLNqoN3IVxElqUCq9h8z1crAAZhpEBw3V4SuA+apRnhL5ToUFOqddNbvehmesPem9CppQHMpY4HRgyngS1RF6ZbgIq3BTwCicOpeMWOE2AgJ3YDaEWDtM6ay17kkGyeLkdYdaqlQ2DuoFKBuUl3JTfTPsWOvQUaO+jdNY5GnoOjDXsu6bTT5RUTf2IaqeBX4ryT07L71H2hbT1qLGp+KoDgdQvVBaHS9XswVVYSzrvsXaE7STjhuoQZMDTepG1SCqMwY+SFADh15jcaRIuBIvZkC0cIecDsMCJM60b7XW3eWKary+jZmRzPTCW/EyFd/URTmpViVholpRAbBG8I6GnVE/40V2bjPXDThZIiFk5zqZQ76OGSbHiPHyGgWWl/IOVUxMeE8eE/kc1I1vIN05LHrwnMknhb5ZTF1lCp1BGKPsQAUbK9Cu1Jq50eF3pzLHqO6UVYuChG/7bNdj6ry1J7BBVMudXolKta4hUq3GRi2ZcsAmOKJRDw34UB0elJnW2RslIcm8d4uuerRFuyTKLnTwG7d0UEkB6CNh09Ap0aDOpXjxSrSqzgD/FTfd1apoU4XbuMun3W7qQWyhOrT0hNLI5eBV46TG1ji2cpB7gJuIgmlavMJRg9YQIv7pNFR1V3t7h6lPCDimLBYSU8ZGB+kwVaKKGRpqMpaEqZiZXgd4eb+9cAnCN1wPWHTxTx5jvUuAmJocgEK6WikWXCunwHJEpnnFKn4GXlGvbq9ysQZUhsBeaWMdKlhs2mOtPRmVOCR8AuVBYTiv+E5DY4DFC/A/4imSRiiTvASfBTlVY088FmVg0cULfz/OWndFSlLGvB/kyma5mqXKO8AWg9OReemE8BY69qF6Z5W15mLPEUuShwWjfry131GlVIIzur5RCyUUh/oikoPAJDulUdR8Qs0bZG9GgAOdtQvSY7jXi656grUnAVcDs6VMEW9Uhbs4xAHN4tQwGyBJktkrfh3x8LmwUaG1FFrUWfiZ9hNNPUg6IWZqtYHrLkgAm9OihIQCgpiSilLzYbRUo2PnAd4AGybQURYi7s5LPcnaEzU55t0LDAVzi6iLQm0yVHaBH6EqNhIQKvIdgSEI6DsdGUKWB0wm6m2m/WRzTwqQqiAxaJXPncprx8DuTgYtI5jwKJUC7LBWLhr3kBiwU6dqXP16eZdPMfm7rCp1tMROEgrgF+LL63CojnEi8A4kFiOPoe9LvGhEKGKG1cOfuKfYnRt9BWvdmcYytIFsP047755NbARrIucaRkbeSgdixqlxKCKrChIvqFloSr7r1fRUizaOAyatUYNSgjC1VZrC6hyvOUbMVqYBbuC8uFtwklyKUR6pV1EJSaCZ9tOsPQEBJFpt1UpKrWEzHNmSxJ9aqHZRNQ+gXzqRigHFnybpqN5lo45SlDLeM+0LplxGcWuFCux1RGAQjOfULAO95XSmIdNoBLasUFfMbmq7pBwsXgsqdFn3RVOfRAW6A66BGvPqrAGpcnXtGpza9pEjJrfo1GUc3wsQVCeU8OsKuSpoxpn2nSZttXwB0L2/hSGENZJqxIpWZB9VkhnBvUY1XMh0XKPVJA31ywNdyotd/5O7zHfZNqr/n85FS2+NoPj45MQ1QigIhnBydFAajSXUR62oI86SqlNxaBYevNv0q3SuQIkSnCs1SdS0LmUvyukYWfA6Sprr6KdqOIV+EgWp6a1agAw7jPoeizaRqHQDYLc6w/B9p6J+dZnPYHiw5Vwzf6tiLNU/SSWsGH8UGKZP2ciZ9tMN2iBz5LIw3FJYwlLI9CnxAISGq1qATSP3/CNXY8ppSESP6VEnaJW4dYuP/AxT5tlUp8YsU/Km12mA0fEQmBvVOauEA75R4/hQwR7VoIEdrGRUpqRZ9OAzTZ+NGEMjFNCxqKtMf+/v79yX1YGb6tZkt0d5RlN1L8lC0lTcCYS1XvyTZ1n77eElkBZQ3Qo1Qnyjsnq1z8BfIRMDbac0G1vfqRdKp2x+qSAc6zzs+oI+26KN2JAJHXTgtcHmKC2pEEoIYxN4CKAYEGwpd9W3B3XOUD3liA9GtLHr0W3GrqVOy4Fu8ToBtTXMHdUP97BCYATlYQQL5QTCjYrpcgX2RanzvLzaxTa8kvUuuXkkIJWWRVK8GiF3gWSGMqY8EXiSTDNYPqmGGIVC4Hhj3Yh1gCuW/X5la90SQrnpCPoAwIVQy9NRSQBK8f5K06pwsm5OXeJxhYocjxA1k0vJz7RfxbTFhJWgIXLetScC5IN0KEGKaspruVT4uXAeKEir4mQy89yGHBnZn4X2q5rxPN8b1M6/0bk8Tz6007ESdXZrBZsSOanBLba06vHiMH6NpmBmOOGomV2PbmtP8BuUU8gLmDrvdE5ZSf2oc9WE8OoOBtwNGERuQbNywamc9ooQi4h7V2uRmzGJGojilJBvBzeJQeeUY6Xbebk6QSN2dbCW+E1CCUoBWoF9APYI+Q57LEz/hARIpxMIaiKFdR8IJBpNBkaXYDAzjTZUkZKmBU3FYziOwt1V3uF3/WNLk791HHqQm1OSQJdwwnU6FglIhb/fqTcwuQ7AuKie9Og/HV3mSUcdfVhsWmXtCZyndFzE6cU8kCfqAXWUqZTp17CjWKgZbUO4DIhYKRc41Gre1OYqu55pO1PmEToQY/X/agTNT11CcMkazVUilwMwQH4n5FGHJlCRGeJbqMUazn65w31qEz8hgA9CE2u1IFNxHe42xo2gT55ho3kWJFnRO4j8yMucmlqiC7i82GHrjUVbxWNq4Kx2V6CuJNM6rLyGbqh1WlACgPCTLWPZZJLAYGGpQif6NPZ1Wbc3Y0AyRIP6lpHFGnC4AQabUcXBGlCt5AOhoHBTp2yu6ohyFf9rPm5Jpn7hwdbab6yqvFPAl0ato4gXdGgJ5U/YpiZFakGI+VTfUQ2qztQLRAUBZatyi4X2qx3C38QtcBzQMVtJQKP0l9p2Fa26jMPqupvaXqhLh2rPS4JaIjmVpS4+xHNMXJNkBZEa+iJ06neLrWqVZQjyZOFs0AiVAYSW3LwGubTkz9XciR/imMWHeHWLNr4jPkxANlo4BQsnGI80PM41WprsS956rw4GKvytgk4soLtVhDqM+a4/22uYukrtpwcks1TPFMk02RtwJlVUqDkKwVl9f3vrwP/zFolt1SKuVVZv1xP9uRZtYgQNC8AKkmcoh5JnVRpEbmWuI9iCeBwoFXljlLfas0ph4dfz6rPd3KDXNHkQYBfghwQgITW5gOmMUKO8d6PzbyRLYBKwMowkSXbcbhwJfKIo2Kzd9e6811o3sqhzbANB5sgmZ4Vm2kAJf6TRQZugc0nqVsvfRp1b85kGngNihRJtNdN+nmmLCZ15Kzr9iyeRkVHMpm7dJOiEDcZOjeQ6WRr8NVBgtfojDJxmpZLZmGm/lo3hEUyTGiLb1EaNDRuUaIEbG/KfxBSk/gFAdDjT6ZhuqTKLodGEkkznE2bar23RbqfOEAGcrdJ4DVKwOmmDBW6VrSdKmRoAqEACxlE9r5DClm0k0Ch28fzrmNgMkC7qW5NnRx0MxOz2qsFDrpVt0YAPNa0lU6qYVUebdVScvErA3+wW7PF1TR07deQleUjAVlZtUMNCQAEFkoVKRDVJG3g2n4q6Rq52jc4KVTpoteqH93pm7Ar2NUok1D5PwQD6vBcMq8b2fkqAq9qqctNY7V5zdPBOpR+AhHa56Ne31o1PQ14C1YGX0Kn8Fm3ryMfh2qLqVBXv4xRACZJQzlW9aUC5yNOhnZc9eQMzJmHFozqdYWVgYdAHPNZMhx68WkKAefDyyj6oHZf6D5byeUoCRuWSdnbn+Sb2SO5axyCbcSQ/VetIE2lH7HE5AKOge7tRDY2dkg6aaF5PZ9h4t2Rlx92M4je08SoNxwHh51WOKjWrNZoFN6ECo1KwnSnFX+KS4rzIocsHteQMeMzKuM+038had6WRVDoEjbmqoioiVDXoa14cz1PqpK+mHvRET2o5AI4dkF+1syI1u6u1eGPThwDzIrOP/ZqOUeuwK26J5qrj93RqB96rZVhZkrnSUA0dRwqKVtRHenf+8k0s2rK1Pf5lAc6qCSQ4Tr0SZiOBQaMz+2RYNU+gVQkg2XTgO6HjmkxIGmLhkzc1dayfEp5ebZpYktcB5YFoikRvgRuI70IogUcrCw2fgo+3OsjRAChrdPRM+wXWu4TryO/grudeZRqdIA0kJZuGjQF4Y+MEkPfq0kZUNahnv0ojS6+zOQufvNDaE+VHQKUJ2/FC8NUCaIHOa6t3Dm+rwBFSYA8irNLvtpoStIo2eqVkFoz6zcz9BoYaKrgEaFG8pYOjbEWmGYa4iYAGvVLcDnsKHqHW2qWG0GGc+eYux/jm1p4QA6KKcWNaNeJXyaN6xrakkfBXNS5MY6tgj7pWO2qSWNj6JkzDy/J+51e9hWmL1SCg05Q07AiZ4T7T4VRs8Qgs2qkdTYWC8nWvxuC1cmkqtsh1GrEZdljBW5r8DbahEY+DQkHBr3UNGBGxQgLYAfRUHAG0XDfKLKPi5XdqgKDO2OzmNL2VqQfDoGLaXme/ycAhFBpTMDVrUeWTalp5tKKsiXIEEQJ2IGhcm+cE+suevMjkwWIUSkwk6FS8D17fqBZh0FAmHwUaqqNBqwk6AOA1eSWsCOob0BnTt+zJW5uYUkNyX01yYC7pP0J1PGB2kqUVtegCgJA01/nFQu8UXELd53GYCHgXe/k2llySaaryXo1vgBg8qlS7jKBkAlEDu6VdYV8wpDp8iBqQ6iEI0DClnY/8tmY8j7HFljXqmq0K7UEHt8ni9Dqgwv4oZ9kJS/GjKobJ8wJMkDqtghpFLPrk7Uw/Ft9ODQHLQQdbKuWnQKXVSled2AaNIMYjIitFkluls473UEwd3glVdrjm25s8GIP0JmtXX0DCf5xvwtk+53UVyk4RbVY+yuwTCgPxkawRDg5mRhZpWfc7mDat1WOq4zISmMsjyXWPrJfa0/hiuM+Tu0MGSPmrThfScTIiYES7Ht22P0jgpdbKameR1f0URml0JFAMIZRO7hPOt4XqfOCXYnoRajLsg6DamfY7mZip05kq9CxvRgGUGj6CRZCHB/mWu49fX6i9FxAwngD3g68BEnBVAOaWdb+ziQ+SvCCiJxmYqSutSgZ5q/jcMdOxSYAjnLaBHK8YvZBY4WAVAYALiN8ttF9s4shsppLO6B6QryIToMuyB3zkUdAPMqljiKiAqNE/ZGmjxv6QZVaTqcX/DuaeACMPuQo3NK5Z5ys7ZSfVYwmAkWCy6qe6ObKP8KnOq+VqgtKqYVjc9VPqTB+i5+64wEQbKrFyQN29mgE4Us6jGvOjZB2xiY5LkInq1ZqsVYuIesRw7Hp0m3gV2BxwpmZ79ESp4PxqD4snDEPARHC4sskKBTWNocJvZjtqB0/GYdUHqjf97yDEshs05xK8jpQ60TWGBUtGPhBOzAqUbafu2YU+cGrolalhf63DEzPtwdqTRjl4cvq9TLdwSB1NUYG5ap8IglSzxbsN6gunzDmehvJ6uODTxMqZ9mjaYqGxQ643JXgRW6sOqR7nEoC5lFuCO65iGlJGo9oDk7kKHogFqGzY+VXvYu731E1hOvHc40NJZ2EhXKFGFpkKfgpwMWJEgRDE4Dg+eLKyR8pX79b9rhbtQce48VgH1GY9oQ+8SayCyj0BB9RAjSQuUi5oRRElICIAOEBCKe9ipv1upk3TbmgIVNaqIpmgDfCIyEZtitTAnm0lgu+IuytSNBoDW6iRrLr1ECkvMeC/MvWgpuJIZjQ8D2SpVM/2UfWxgyZw4XkTagETADyRZJvwiEYHoEaFtrs+w+9uxlJ4ZeoMJIkGOQHtVTvxoZSnklXTwVZ1pFaf4ZrcmiZCgM+OwakjzO4czHuY+gQHjZVW5IRwySbXU01q1Gm8FL1a3jMOOpijI3TrVCZB5ABwoJhg8Qff06IdpiPzLnQ4ySBIoHi1TrfpcBq5EyQd9Qr4htmtByAJtT6TAoJdOyH7M+2XmBgezp+HDQvlO9FE8ISGcOEoq2WReu2NHrdcXbCJ1jQLRJX4IBcaCdctPsR7mT4yDirshcJzOuRAnFTfX49DoKoiTRUR+EaeXR1RMKhBzOegBr8DfvSy7vc28dhG2bhRp3PJv+DYNF3Xq0OE/B8d1cVNawStCKzH7VLDEbS6G0ZSvDvb8D4mDsFeAps3IJg6jCcQr8zBHVohGcI+0B1qGcjm+kbpVoyC3F0cZ6U0Z9rva/rIYMXyF9xYaj4k4TYIMYETzjNZKOV4BpVKIKHoeQRHNUU5CLbmmTa7uOH9TN9eU+mcTr+AmeNyqul+CWqCBYaBa+VjnI68e/Jn6ggJ4tbimZdqVpTvanLe39SxeKWgaOKMfOrpqkEChU5gakz52HkNNVVEURGPkLjCLmsWqRpUq0pxpv0B5rvUUVES9BqLU2pQS9a10xEyUAnuBtsPtXJfo+aBqgwZLwZnRY2DUVXLfn+gaYs1RAlUMZevRP5GlbvdlDnT4WqdXcxVEOWlTnQAmGy+sA+d1yIbvPhsH2St2+U67S80IJIo0SQHdhdsI1ezIqLXXjkNPP8Wj1GdaFqNBsyUGiCM2M1J/WBr3ZqmkGlwjVcJAQmchmyoTsDV5PtGQE+iWY2/Lnud3hkauVO8SWxQhv5e4p0PsXiQl6SDRJ3qj5zGPUGVnG2uHE9dqv05CU0NOmyV7UCtqI0GiQFVpnY7f/BDTR+5Vq64keHVeBN8EnJfgFO1U6iGb1XJcWvUoV7Yr8baoWKcjtCjBBb/+8PMuCFXryOy5QgKGa0+0zCziPCTgcIpA5kiSBjUI5Qt0qHuRjXGypOMpN2XdX+46WuW6ndDRIY18ZrB3dbTSAxNDwPxbtWBlf8hxnJ6LaMKcjCEuHqaILbowY8wMdNes4gQZKAXhdEksB0oF8kR4kCsuSYtZaoxLZoIO2qqS1Wp+1Sr08bLuj/S9CGIuMngqhYLXF5HaXRO32vuagX8EyaxJTuSATGTQOu5ra8xOIWQ4d0Mv4+ydRWpEd4P/qTODsaROF5t8bwaPtcAo8SRg6qrQE5D0GBtNcbKhFOgVxZ9cp9FOyiz6hT2ItcqfVItqZqv1zriq2NXalNEVFTraDe2gR/MGWhVp74lM+2PtvYERJEMTkmedVD9MAEhACN+Ffiim+rD4GT0bmRPYMta8INmsnbYbVTYIvMfY9r5VjMBvTBpZeHx3pBG9CEut0JlTT4gCQNurZ7avHNNqQXdAKdR79FlTz7Woq1zmwDwLBD/gdhSHVJBwMieZRpGTYI4Cq92U4/jQuMykQawH0whpmHZk4+z9kSHyEaNBFUXtVxjVVCdJZ4EAV6l+S0qJwYF0aBBHaciKUUAU+k/tPuiqz7e1FWgdKoX13mMVuW2moMFGAE2iyObqX5Jx/FZLyEfQUbQsXSV1AkV2+W8PsFad6+REAqkCUJAjpSEBSLsBSOrq4DSVWBKvWY6ZxpU36iRfKM2XaisXQ+HTzR9ZOFRUho6Ic4ddNwcKaozGTYyob5T0xX8FnBasnfIqg5Q9zpen61q+T/JjNNgC3IqrVqSaA6rFx5Ichy76NVXn9yFbCk622vMuroUBJIlpXRCu5uz98mH6MGBbcTVvH8iAbmdTt5vqelYOuUpvarCjkqsp6ILHYSoACyngqyZ9qdYtElN4kQBBBQgKWr72GAQdVIFXA9imivVE4KqmRh6DRXJe0Yv1BqyR058pv2pZgyIKcnwt3NVtCinDe+x6blAgbFyIGUxYoaU/VcPB3ZEBR29MurqsT/T/jQzTpObCsaDY0Cwxj52oDB1r6l+Kjirsc6yzY2GhZbTsSPlsTLgR9V4LP7gp5v6mwCbPJYO+3jUBlEOlgAyU9M7VK+qgNgsNZiTNdXxk0JsS5xUt7t6ts8w9SAZFo16VPGURhdKLon5cDgjrjBYZ3NpQowvdKTXA7xpvqG6fIZhV+v8mRZ/E1VizbHABGIk5HB9EKRC4wJhc8yDGgqTW+gyHabVkGccoAk76IGjdr1SP8uO00gBofbFX0gKIOw4DXrRVHf1nVIqVrORVV41gJiqfx+WFX2Jeg8L7c82bbHm2OZYLXJzQ1S/5q7DF1PmRX8CF5A2I3KTIJKhbngTgmnUVBePZdf/29rvBrCMiK9WrKC+3mryNWryLV6c+n0XmmLRVpo/hRrh/oXK3iK2uiZlvPDJ55i2gb2Qp+1V+FSoHUnUMKkBE4wMEdbUhY4/1HoerAFYOyp+BGgjX9zszpB9rqlj8+n8I8qp1wH0UE5AkM5ywhwaSIIHoLhKfiOwmFrdaNqk0sBkORZ/8PNsny3TUMFeRaGZBi4HIeiZCuTV/00Ze5XcifNz5GnQ+Cc8XLAn1OfOr/p80z9pEPZewxRwLp2OjRN+EJSFaa5bXwIn4dOhKwk3R7IlOhCswtRW4yvrJW74Alt28JCmKq2u1SAMsJSyFZpPSEjAkGmE5HSSrPLq3h5VKq66GqJ/MncL7S80dayO9eFzDNN00EbtC4Iakqv3SaE+eESbwE2TBeONNipvH9WzXqf2i8Uf/CLbt9fAaEGyOiPZT92Wa037bHgOHPqGjyudJxO+rEEZajWr5GGuyUoLf3+xGafVAIvTFAHBI+qK7lQkHQkdClwTHArNcx3UtjFqXmXQbCSEttGxdLfwyZeYfKLmV7hiWY2P0ql936AWHDpw47ExspYsWX0nyA0G58sO8EetI3jd1e4MwpeaOhaRAXAd9Koynfxjj7CFjQ7ko0NRIl41AbkaTdQ1/pfy4pqa02la94IVfJkp8zprqbnEnYqywa0q5b1CT2xaqJvCNNBBPUaCJoq1Gs8xCCMCzGL7Fnv55RZ/A+KosRYAY0aAI++71dQ3DCU6BIeNLGUFGKnXiF7kt2qK206NvTVZdqb9FSY24xvNLgXNnuqaFOIpyK5Vbcr+O9XhIU+NSgJI2OGfE+ZWaiPWkoVY+Psrrf0GfcBbdZ1mbpENAngGh1Bd1HR2yo3Sssq1yd2OxdT8aUAmedmDPKCZ9leZdqdriiIgzaoA7/ElAnKI6la3Sh0m1tEdnP1+Ol3WaU4e6gDcHmikXPU8+moTeyRKrHVehSULcgQk4P0RKyCJCCK54UaNS/APgZD5WAlR9UkK4HhxxydfY+KDyFimnkDllBpB/VVyPqJmN2g/1HJCZrJVM3m2JlcCYkrWoBrLhU++1vRjo/qydKp8i4So6j6k3ttqeQf+QTawUV2unwIFDRseyVXBT7Wqc1fn/r/O1LGo7EzjmCIBm9Au6f5Op1MadQBloV5nhAYdziaRAvaId5IRylcqIVv45OtNDA/7KDgas+bUJigHTRqljeADX03GSF0xkd5SXYb1cqbBwV642a5n9DeYukpnF3UiHEbrVEukLo9IPgGt8nga9NRP7cZDOcVB3K6UKgmqCNzlG77R9DXxBGDmMijuUBf4qOi+U39DfEByJxrSAWCK99MEwGlgdlIZyrOTg93N4vgm0/cBuAcv1RzKVueWg5Bip0TgdOw9hopwGd2oeSfCPNWjFE2MrtHYiUV/f7NJm+VWKpTTYblC4wzLRmM5iCo1rkQDUeUwa0g0oZNasQSNcapyqe+dPvkWe0+cpgNFnVbKdCTAq4tiq5RmAdv0Kk9nx1VFpHZ/RAuo88gWqkhkN7PlW03MdCT1QZKfrcR36pEZ0C+nAy+gRmomACilNhGatA4MkocWj9xrLEOGKlrW/W0mhhdxVDVHT330lPoA5UTsM9V2kDOD89UMAXxa8yycjq2oSanXWDU98Ez7280YsFWTdtAC4hpN2azUJgk0fNApRUlooVOkHqOnjmg5+iVq6mOhw+P5Ti6/w/QhehwbHO9ep1PJxClUhyM1hLrqRxIzKCr14sdD02zjqCVojouO2uE8zrS/08RmuFJzXshoZBrzqXHdGXKTKxGF9GEe1Mkl6v6CUXTcyauetVM13SI732ViBWSLSBZXleIPJRp7D8AIM3qpxQ5tnatmWdFnq643AEFV2xSaYtP5XTz/3aauGnhm4AJMApi6JqwSnKg+YlAB13QyC01V6CAmCVJ2PVekrM64mo20+N/fY9FGRED7QSw1jKBRk35BP2q4nEcAOxWx6NSYStiUjgL3VbvEzqu7yyou/l7zXd4fno9So16oNtyrqlV1r8R3BquTxQOODBpnAcMPytSr7g1FMS7r/j7TPwF0adTmX3mvUcMbhDzgGmusD5EgGTVcKi4YVBAEfthLjTmMPAvYrfv7rT3Jpxokwj91Z/Md+BUhGZGpXNYGB4MIEI+V5Kyq3XqV2ODK6BS8pg/uZkD9gOlDqFjXIYCuUkYOA9Gok6QOXaHxlItXClrVUK1KXoKOHNWjKxR8x10u+gdNuwMzYLDQJ2qAxxbiNCggVk/rdgIcgmqsCFUjPnQQiiNYTifhiDWW+PKHrHWr+SehIyhXrTyI2v0C/6OqpAE1NTCooJB0C7iQRHcERwA3VWF83u7qZn7Y5BOFrbw4/oNxvbqqwyE6yElmFUNEEAlePCgQ5sYVbjGhlptOLRCELrrqR0y/Ktd431jVpTL1QxmV1ECJDGynEEcSYrFReyIUO4a1l8Oimlq1QSWPPtP+UWtPNIfKa0AQqRI0Z9sCyHj1stdElMHBKmyCMto6gtyU3qupJ9EdglsPu778P2b6VVgrTXYEeNE8BZ25QqyjI8dHsINfWbVqHDTcfwKdVICDU9q60mmpaudX/bgp85ooSmZYh7hrDR9RBU3UyNtezeIBl2EiHYDH+9MEY3JfJKTACHkI1M9M+ydM29CraxyQgIqn1Jm4JCoGTyHq0PFF11Y4RqQcSiUjBkDqSvNGwIU1lmvX9/YnTZyt0RmBTqOnaw2WyJTZFqis6R6tjmOgUNViTk0ZwcnioKLHqHJFwNRFdn7Koo3LO3TqhOyKnMhmdJpsRJ6xBxXXxFHF+6OGhBLkqgghqmx9GlVbde2uXvOnTdsA5AoOj9DhJQN3kPNCRnBLUOpRYJpqZNQDikQ61zbqTeE1eAmIOdvN8/oZa92FpvZkgjJ1oA1AD4hjUKU8ekltv+WUNE5xTjGdflBJE4uZGinHXb7hZ811Zzh8KrodpibxQxhR04UgSSHewu0GGJMwRd5/lOgCy+WFmopodvpM++cs/lZ6X23ZeiCxFi3re1UPoM37qaGcRs3Dfbisbiozk5+MV1ji4GFPdz7Ez5uYUl3oJGvZaOC3TlHnGpaqpkGYTxzX+7u+gjiMag1FAIE3R6hPjAbr9Atu/wu2/tYQw4E76AiPBkb2moaOEwRy3E1jI5XUbtRETqeBfKVeIEQNCr935+p+0dRV5N/J1hE2kfFj6XhkqjGJQMC9DuUTaqq4Gi8LZ7OOcqPJmCgTOfq4m+H3S2bM3QjZUA5V7SEx956oTM0ogGw0ZBK8QN1u1SRLXhUMDqdrUqvS9jvb8MumvUTIwFpLp0EIgP0A06Szap1SHEodABnVNbVXe4hSoSe7nVWqyFNX0F3fll+x+FsjCp3KytVJxGmKMY48qKGqsfG4+lFxuM6UYGTwqGqVaBPujG3XyUzPtH/VjovhJywIKCUBJUm6YWp5qV57OGZAEHVD3pctwyJ4NeW/f+xNKT+r3eV3fs3iE6dpvEAFNVpLzdF1hES9fuCOOES1uB4UyoFhAdiCQ9x/co/36Emv7c4D/rrNgz1hgKafqPVIWWpkkHM6CKQBLQTHlQpTag330WEh+LFU31TUC17KLvf/GyZtVS+PmsWgVtegdo1aSmCUK5UI47K2qCrXeaWrwL/J9AR1zhLeRjZo8X1+04znVSjXNcL+NGJQRS2FSlnQ69g51eFoKD36RFMtWuJCwktoY0Bwznc+22+Z+OB0gJBYHbPO61QDe7VzzKfN9c105Guo1Il1VO/2UZPXkdliVFe3Xa3Fb9u+vWpadHSGYK3T8W21Ohob73Ol0QcNnMjV7GuC1KsJbyJrj/kR+rHEab9j8bc6sQADZGqyp2MZmmSGfYs6J5RnMAxAMHl5VgxM1rDZbSPDmgOR60jZTPt3Tf726kNLnMPSievHQSV/TqePMqUFgVZyjcrLVVzVI7C5XniVqYnssMJ9fs+iPWqM+NhoXeRECVrxw9XoHoBK04SVAmjVmAMHo1e38rLS+EtQZPxpvzs///vWnmhmx5Qtc5KPSqcrSWWpsq8JrbS6ApIuwEe8aMFIKBOSXmoM51dnJP/AlEtNrMaVl5MZNLFKzUfURVcjMTCcuD4etaWOtH4qile/QrQCWgsvZrHzf2jiEL26bKGLcGQFMggYjFP71ZGMoEB6HmNU/wjNIQJhJS7mVVSFVzJj8WP/yPTtAcl7YaaluFlj/PDzGp5AY+1d1NC7GgdmmsbsyF1GBekkTdQkodnhJ39s+oOInpxINoV3OKgToQqnXVfmmoWuclUd7nRTV0XVAOGLq72PTjdh+mfaf2LtCc9FarEHXiWg0hhg9ltdZAshxV4zUZQjaAIOlVdZFVB1Ie+IpIzwvpn2n5r+YNuqp7+SLXhVdYQ3ApFwpmZ+OrysnjOASnI3Hf6nR0mpKopIAJuyy2X8mbknUzGIxj+MmiysrtNuKpBoRpWFaUAQCbZRU7cgVk89HzoZB6S1LZfY9c9Nmc/VLiOqfRwZHQS71nHiCvLBOaCP0Um/R/iF/DpaVqe8QGl0frfA35xp/4WpY1uNyRg1e4tXqfnSo9d0+VGTGUv8C81qILAVQq3CI/gaRDvXqVcCiuVd/qWtq1T0IGBN9Vg60Q1za2iuKqWd8J5Cs3/RJC1QBXnGsVObZyd1EHa45l+ZPgTwV6ly7AJAu2fvwUXJHY3CNmGgjhCT5ADqJoIIErrgrsMiElH1HN31/zZxn6kWS6PhEXx8WXgFn1zRPFnTlvxRpfRuqzP8OKBFEzW/yanFMGnBXV3vX1u0fa1meh7l77tCg6MKSQamgRzD0EIaeFbjcng0xKkThBI0PHBAgxe7+fN/Y+pYMjn4T/cX9LoJbwNjqzWyDoaXR8vdVdmDOlAOnLACJtXIQ9yPXc//vzX1YKmjlaWfnr4J0yE9wCtN1+xUaKGzhZqbVZcocsJlAaBqWT0Qma560/6diVfl6hupI14ag6WaQPWdDQKTsGo8B++BNHenVz5i1AaUVqnsEUmmxnW3XqL90hXt+a/zff/tid3vb1y/jwfyAxOe2Nzv4BL99e/W9z+7WWvS9WTZ1Gpifb95Pdv9ueHSn/Pe/f2JK9d63vhs/Wzrz9b3+XvjPhatMwlpnU1I6+aEtG5JSOu2hLTOJaR1PiGtRyeklZJXb09I646EtB6TkNZjE9J6XEJaj09I6wkJaT0xIa2UvPqkhLSenJDWUxLSeoWEtJ6akNbTEtK6kJDWxYS0UvLqnQlp3ZWQ1t0Jad2TkNbTE9J6RkJaz0xI61kJaaXk1WcnpPWKCWm9UkJar5yQ1qskpPWqCWllCWnlCWml5NUiIa0yIa0qIS2XkFadkFaTkJZPSKtNSCslr75aQlrPSUjr1RPSeo2EtJ6bkNZrJqR1b0Jaz0tIKyWvvlZCWq+dkNbrJKT1uglpvV5CWq+fkNYbJKT1/IS0UvLqGyak9UYJab1xQlpvkpDWmyak9YKEtF6YkNabJaSVklffPCGtt0hI6y0T0nqrhLRelJDWWyek9TYJab1tQlopefXtEtJ6+4S03iEhrXdMSOudEtJ654S0XpyQVkhIKyWvdglpxYS0+oS0hoS0xoS03jUhrXdLSOtfJaSVklffPSGt90hI6z0T0npJQlrvlZDWeyek9T4Jab1vQlopefX9EtJ6/4S0PiAhrQ9MSOuDEtL64IS0PiQhrQ9NSCslr35YQlofnpDWRySk9ZEJaX1UQlr3JaT10QlpfUxCWil59WMT0vq4hLQ+PiGtT0hI6xMT0vqkhLQ+OSGtT0lIKyWvfmpCWp+WkNanJ6T1GQlpfWZCWp+VkNZnJ6T1rxPSSsmrn5OQ1ucmpPV5CWl9fkJaX5CQ1hcmpPVFCWl9cUJaKXn1SxLS+tKEtL4sIa0vT0jrKxLS+sqEtL4qIa2vTkgrJa9+TUJaX5uQ1tclpPX1CWl9Q0Ja35iQ1jclpPXNCWml5NVvSUjrWxPS+raEtL49Ia3vSEjrOxPS+q6EtL47Ia2UvPo9CWl9b0Ja35eQ1vcnpPUDCWn9YEJaP5SQ1g8npJWSV38kIa0fTUjrxxLS+vGEtH4iIa2fTEjrpxLS+umEtFLy6s8kpPWzCWn9XEJaP5+Q1i8kpPWLCWn9UkJav5yQVkpe/ZWEtH41Ia1fS0jr1xPS+o2EtH4zIa3fSkjrtxPSSsmrv5OQ1u8mpPV7CWn9fkJaf5CQ1h8mpPVHCWn9cUJaKXn1TxLS+tOEtP4sIa0/T0jrLxLS+suEtP4qIa1/k5BWSl7964S0/iYhrb9NSOvvEtJ6aUJa/zYhrb9PSOsfEtJKyav/X0Ja/y4hrX+fkNY/JqT1HxLS+o8Jaf2nhLT+c0JaKXn1vySk9V8T0vqnhLT+W0Ja/z0hrf+RkNb/TEjrfyWklZJX/3dCWv+ckNb/SUjr/yak9f8S0jo4kY7WiYS0bkhIKyWv3phwXScT0jqVkNbphLQelZDWTQlpnUlI6+x1yqs3J1zXLQlp3ZqQ1m0JaZ1LSOt8QlqPTkjr9uuUV+9IuK7HJKT12IS0HpeQ1uMT0npCQlpPTEjrSdcprz454bqekpDWKySk9dSEtJ6WkNaFhLQuJqR153XKq3clXNfdCWndk5DW0xPSekZCWs9MSOtZCWk9+zrl1VdMuK5XSkjrlRPSepWEtF41Ia0sIa08Ia3iOuXVMuG6qoS0XEJadUJaTUJaPiGtNiGtV7tOefU5Cdf16glpvUZCWs9NSOs1E9K6NyGt5yWk9VrXKa++dsJ1vU5CWq+bkNbrJaT1+glpvUFCWs9PSOsNr1NefaOE63rjhLTeJCGtN01I6wUJab0wIa03S0jrza9TXn2LhOt6y4S03iohrRclpPXWCWm9TUJab5uQ1ttdp7z69gnX9Q4Jab1jQlrvlJDWOyek9eKEtEJCWt11yqsx4br6hLSGhLTGhLTeJSGtd01I690S0vpX1ymvvnvCdb1HQlrvmZDWSxLSeq+EtN47Ia33SUjrfa9TXn2/hOt6/4S0PiAhrQ9MSOuDEtL64IS0PiQhrQ+9Tnn1wxKu68MT0vqIhLQ+MiGtj0pI676EtD46Ia2PuU559WMTruvjEtL6+IS0PiEhrU9MSOuTEtL65IS0PuU65dVPTbiuT0tI69MT0vqMhLQ+MyGtz0pI67MT0vrX1ymvfk7CdX1uQlqfl5DW5yek9QUJaX1hQlpflJDWF1+nvPolCdf1pQlpfVlCWl+ekNZXJKT1lQlpfVVCWl99nfLq1yRc19cmpPV1CWl9fUJa35CQ1jcmpPVNCWl983XKq9+ScF3fmpDWtyWk9e0JaX1HQlrfmZDWdyWk9d3XKa9+T8J1fW9CWt+XkNb3J6T1Awlp/WBCWj+UkNYPX6e8+iMJ1/WjCWn9WEJaP56Q1k8kpPWTCWn9VEJaP32d8urPJFzXzyak9XMJaf18Qlq/kJDWLyak9UsJaf3ydcqrv5JwXb+akNavJaT16wlp/UZCWr+ZkNZvJaT129cpr/5OwnX9bkJav5eQ1u8npPUHCWn9YUJaf5SQ1h9fp7z6JwnX9acJaf1ZQlp/npDWXySk9ZcJaf1VQlr/5jrl1b9OuK6/SUjrbxPS+ruEtE4epKN1KiGt0wlpPerSZ2cOLuc3/dx76c/sAf7cenD5fs73Xt93vT83prv3fKz5YLUdl8nUweb+Zw+ufPcJ15Of2NxvXs92f+Z3Nu/daWOt543PtvritHGf08Z9Hu605n1ev5cTh/x5cHAlD1n3WfP0yc19Tia8z5ZX9XPuwNYV+pll7lGb79176d/ZA/yZ73XmEr2TB7v3sr7n6dXzrK9f/10/pza/e/eb7v9Tfzzx3OXPd628cMJYz63G97Z7d+Z49u7I+mq+/9kDm6fvTbOefPsur7av896dNdZ63vhsK8tnjfucNe7zcKc1y/eaD+f3ceaQ79176d/ZA/yZn+PmS/ROGs+xXtsNm+vXf9fPqc3vPmaPfFt8eGbP3p021mPJ8EG6/cnPGM+bkP7iT92yeu6tfrpt9ft0777Ij6qf5vuf3az1uPTTbZv1bPdnq5/OGWs9b3y25pH1Z+v7nDPuY9G6OSGt63Vdj9B6hNYjtB6h9QitR2g9QuvhTeucQXsboxyPn7qLUeZ1rWOU24y13mA8x/p5T21+91t7YpSbjb27ec/enTbWY8UQKffnjPG8Cek3M/3zq+dORHuJrx59PGt3M/3bj4f+sv470u9NNdN+zGrtJw7S881jj4d+OdN/3PHQX/b+8cfybutl/59wLPTzhf4Tj2V/yjjTf9KxrL9Y9v/Jx0N/4c+nHM/+tzP9VzgW+tlC/6nHQb/Il/f7tGNZv3MzvnLDiv5sw2TnXnrT5Xw75wNOHexs5fq751afr68/ccuO5j9conluRXf+/jbPcsOG3onNPqw/m6/97zfv7vWPm3ut1zrne85t7r2+7uWVe5lx2MNyL/Pabthcv/77ei/m3/3THr9nvdf7cprnjb17eeXH5s/OHVz53Nt39GD7pmdXz3MtvukMDlrv6FpzDzcY67n14ErZWcv4yTOX33Mtczca33305jnm6/9mJXePukTTkrttTPFgy9YNq728Ftm6dc97u2H1vRuN3+2LKbbY93rvZz9R1z96z3s7YXz3sZvP5+tftHpvj9nz3ma5PLdnzdfLO93mqo/6Tp+8551ea67a4vl9ueqXVV8elXfWMn9nIpl/nRXv3HMEmd+n46+25mclWvMrr9b8Sg9zfi8fRH4/5rz3kWsz5vu/vGozzh5xX+e9s3yM88Zn27oFK8d6m3GfhzutbQ3M/Ln158HB0XTymqe3snCYfnv+Rr/N3zuqfpuvv3Gl3954j37b8tJRdfLaB3nhNfogT9x8Pl//fmd3NN/izOX3XvtNW91xTLJ6ZN0x3//swZX7exy6w9LJll85751lI84f2DZr/vv6s/V9HmXc5+FO62ry0e+RaUs+tj76fP0fndnRfJeHiM9yCXo4ss9y0+qz+e/rvZh/95KHiY/+AYn83V9Y8c4HP0Af/V8yX913HfjCNx3P3h3Zns33f3n5wjcdcV/nvTtjrPW88dlW119rHerDldatm3/Pn1t/HhwcTfetrzmqL/z5iXzhL1vpvi/a6L719+c1WrrvxOazU8Znoj/nHawzQOtn+4rNs1k5ldN7nm2+/utWz/bVh+zXwYG9X3Ou3HoPp1dr/fzNnu3zpyz+s/yp+XorDt7Wya7vvdaNZ49A64Y9977FuN6K2c4Z67rlCLRu3XPvfbXP1r3X67pt89n6e/N110s+5JbV86+vX/9dP9t8yPftscO37Nm7+V76seLw7Xuzaqas3Mp8/Xnj+nObaw4O7Hez/u76PvPeWPx1cHClXB0mBzO/3Xjf7rP1WVH9nFx9ltK30Hqecm63jvUa9XNqdd/DZHV9/bXK6lY/r/d9e5ZprbNu2tCw4sG1Ht7qzPVn83fX+n2fj33i4MrnPoresnTs9jnW917r68P46Abj2kdtrt2eDTrMp74a3ZmOxa/rOEI/J1efHTe/rp93y6/HZdcsHbX1aS0eO3FwJZ9cq42fv7uOMy2e2eIJNxnreXmdX5vl+rDza1u+W+uBtQ45tfndX+6xN5Z8WrrKwojm6yydeOKQP+f7bH+3vY/1Hq7md740kd8ZVljtP+zhnS0vnzTW/C+Zr/7zMfOVhX2c2OzVCeMZrO89ekPDsoVPM9aw3cPTh1y/5rX19f9rtUfFRicfxsf/vOHjm1a0j8LH8/Wvv+Lj//cw14GnLxE5Ll619m6LGx7TmdNl724z9u6WPXu3jmVuM/Zu/t1tCffuBmM9x20/thjbYXL32LMHlz3bzHdHlbv5+ldYyd0TLv3dwpX32Y+tH73FVOf/5n8/bvOMJwxa63yN1RdhvRdP2+zFLcZenN2zF/P196z24s5D9vfg4NrjkbOrtT52s8cWz8/3tGJiK76er79aTLzFMtYydf4ItPb52XcY169pnt3ce72uO45Aax+G8xjj+jv23Hu9rsdsPlt/b77OOhdyHDpxPvew1omPMfbphs3167/r59Tmd26PTrxjz97N9zo42Mn9eWM9J4w1bHlgTWu+/onG9etn2vLr+n7r767vY+Fbd2yuPbf5tyUHVkw8y96DERNfZvNW9z1MVq26m6PK6jb3uN73c5vP1jrrts19roYVbXWmhQ+u9bvlt5w8wj334Vkp8N9997Zyodt7nz7k+rUdW1//gpU8F+dsmqcOeZ7HH0LzzVc03YamZYfeZfW7a7VD83r22aHttfO/rf23ZHV+5w+GrF5W43nf5Xtj8ds+nNva+/V+bWXV2mfLZ9titvtyv5asWr7hOh7ch0EcRV70cxyyerD53tVqdNffvVocdzW6+/j1wcwPXK/8ui/HmCo/8NINv66v29qWo8rIPt4/7nqm85v73GCsT9d/2Fn72Q47S/ik1efr6//9Kmb6yI2dtmzfvn225GJ9Pkk/J1efPZTyZvvkSH+f41mrNvpRm+9t/Yj1fuxb3/pc72G+yGEx82F+w6cl9Bssv3StH7Zx3HqPtj7+VoevefF69Rv25b0s/tlnK6+mh7f8Zu3zvlyBteYHqsf21bNYmPn6HPm2lukG41l1zZdv9J5Vy7T+7mG1TH+40ntfdQjNg4MDMy+8xffX+JB1/enNGubrv86IA66m97/hGvX+YXj9D6ye/5s3en/9/W1u6aGg9/fJoeUDXGv+ef1ut3JonaneJ4cnNteuf7eWw32Y6zr//MKNP7Qv1r5tz7MdHFy7TtrWNa/34twRaK3XuvXFbrtGWlZN9dZOnT7k+m3fhfn6n9oTt68xFsv23b5ZwxOMNdy+Zw3z9T+3WoM/xF6vdcF6XU/d0Jyv/8U9PoCFCb70xO532729YFy/xgTn9Vg48vq762utHNJhGOD877MGnYcSznCt9XRX8722umjNF9sesNeKM1i2yrJja5zhG/bkqra68Wo6+DBf/TB7vM61ra//s2vE5dZ789RDaP7lNfrX+2QrhX9t6eaTR7jPPt6zdMSav7Z2Yb3m9XfX93lZZN7K2Vm+6Rb33XcO8Go8vc53fvkenPv0VZ7TqgE8Yfx7Xt+6h9RR+H99zfzdLa/+lz22xeL/m45A879dI//vy49ejf+39REW/1trX/PR9ncWDriNmc5trj2MtsV75431b/9tycI2Pj57yJrWdCy86bj0+4xPXa0O4tTNl9//Za2ju3l1TvumDc1U5zeevwcb3+6jxdvXmn/fVw9v8fY+WvvqoK+mv7fYn6W/99HaF1NcMK4/ag75wuYzy888s7l21qH3Xvp39gB/5ue4eIneOvd/wdinGzbXr/+un1Ob3z35Ei9buf8n7Nm7+V76sXy+7Xu7aNCy6gjm6+80rr+4uUY/1rtZf3d9Hyv3v/UP9uX+9/n5D2Z+Zl/u35LVfbn/q8nqvO/nD67c923uf18uPFV+ZtbvFrZ08gj33Ke3rLjAqt+1Yoyj5KOeYNDa3vvUIffe4u3z9W4lz+4QH2u9hn14+9XwmC12Z+Ex22vnf1t7db2dM1nb9a1c7av3Ozi49vzOVq6sfT5KbWWqcybPuoZzUdd6nvOoe2H5QYfhMEc5F7XP5z57DXT35Yeu13NRqfNDW37dlx96eZyLuvMazgRYsdZDvS/pO+7x4yz5tPAWC8tY62ZLTqw/5/tsf7e9j/Uerpaf648Qz+3LT83X//YqnnuXjQ9hPf9RcixbfbPl1znHcuOe5z9xcLkcrHXWjZtnst7PYfv2ks2+Wf7Fvn2br//B1b69z2bfLMzPiifn6455TsIic7P/upa59T23dmHt7679522+5oP3yNy19rqzfGVr79Z5z+1aj2PvLhxcuXd37Nm7C6vP5r+v927+3X0J9+60sR4rNnqg+sp6D1eTu0/cyJ2VQ9snd/P1n7GSu0/ZE/Psy7Vszw6t92EdUz16c67m3CHP9lmbZ7vDeLZze55tvv7zV8/2OYfs18HBteOF51Zr/cTNnlk8PN/zonHPB4JVbPMTF1af3XkEWvtyI3cZ169pntvce72uu45Aa9+5mruN6+/ac+/1uu7efLb+3nzdmc21x6Xj7rlEb63j7jb26YbN9eu/6+fU5ndfv0fH3bVn7+Z76ee8sXfb93aPQetOg9Z8/dON69fPtOXX9f3W313fx8Id79pce3Hz7wsGHSumWmOt+jm5+uy4Y6oLqzWfWt33MFldX3+tsrp95+t9v7j5bK2zLmzuczWsf6sz15+ta1c+6wj+3b577tNbF4zrj5rTvXCEe1t1Q9t7nz7k+rUdW1//kyt53ubvL6y+Yz3P4w+h+TN78Lr5na+fax9edzU7tM3RX1h9dhhmPv/b2n9LVte+vX5Orj47blm9LD5e3fcwfltfv91La+8vrK7Zyqq1z5YPts257cPOLFldf7auC33JEWLYEwdXPneK3OFWVvfVXW9z2Yed219/92pYyNXoPhzyNheM6y19ev7gSl5+oHmbo/LrOsboryFv82Dgy/toPZCcyfbe+3ImW3k4DJeb7nXf7rPrFYPel087ODjaXu7LmViYzrXWRj8QDPrknp6lcx/SMwdX8nvCd1Kc2DzvYc+01dlr/OPkZq0nVrTundfpszDkdd32dTFmedvkbeaasq9CWbhu7Hzvx1hkeRzKvGhiF2IWqyY0Ifo8xMpv13HKWMeJzWfLe7rl8vWdPJ69zNb10tu9uflgf65h/vcWL1/XY23zp2s9MfOL5Xuc3TzvVr5OHfK9wzDdmy7t51F90H126Go+6IWDy595/SxHwUJO7Ln3UeOrfVjIdi0Hxjrn71m6d96b663e23qP14orWe/RilXv3Hy27sF82Nnp+d9rWTq/oXPyCN/b1ofq79t4br72Kas5l99/6e9HyVdcWH32YNR6bTH39XtZv+dtrdedKzk/jnzFcWPu2/rzi8Zn8ztay/1xvKOZ39fvaH3Pi6vn2crHWrZObX73ynvekSXDF/fs3WE6aytna0w/v+Xye16tDukwmzI7Y6JZbWRrva5tPuvC6rMHQ7a2+fejytar7Xlv15p/P6w2arv369k1z93z3k4Y393Orpmvf9/bdjSft+e9bXOUF4w1z+90vYfH8U5nuVu/U8tW3XBwpZyu7fypze/eYM87vbD63j7s15LF+ToLY36g+vLC6pp9vLOW+RckkvkXr3jnzffwzoXNmm97Gdb8okRrfv5qzW/7MOf3Fx8zv1t7t9X/D7bdvrB6nvX167+v927+3bsm3LvTxnqOW1ds6xkOk7v32sjdzHdHlbv5+qet5O59j0FXrG3jB16jbdzOPZyv/8xbdzQ/5GHg03zUg+zTfGwin+afVnHeJzzMdfynP0x8ms9N5B/89Yp3vuAB6ql/yXz1FY/4Dlfs3VF9h294mPgO357Id/ihlUx+10Ym19+/sFnzvjM1p/Z8ts0vzPf+/s3zpMqNvvSmy69by+d6P39kc/+ZF9f7uf7udj/n639qtZ8/fsg7Wj/To/Y80/qzi6u1fvvmPVlyM9/TqivcV892j3H9un5vm2dZy+U9R6C1Dye/Wi3dxc291+t6+hFo7au/fIZx/dP33Hu9rmdsPlt/b77uzOba49Krz7xEb61Xn2Hs0w2b69d/18+pze9+a49effqevZvvpZ/zxt5t39szDVr3GLTm659lXL9+pi2/ru+3/u76PvPeWPx1cHClXB0mB1ZOa5a9ByOndZndXN33MFldX3+tsrrV++t9v3vz2YXVZ3dt7nO1HOhWZ64/m7+71u/7/M1993wgdeNbHrxoPO92zVeLL9ffvZp/eTW6M53rrQZx/bxbft2XU52fc3391errt/y6lv1tDvbC6rOLm/tc7Zz7Phu/rkH83A2/Xlhdt42t12uYr3uo5+7+OWHu7oKxHovHThzy53yf7e+297Hew7aeQH9f+5033npw2bPN3zvqPJ35+o9Y4WmnL/3d4p2LmzVbte//kvnqtkt7c1x8ZWGGh51HXT/DvhqjLW+s7/M0Yw3bPTx9yPUzve0ePW61R8UhdTFbPn7Cho8vrmgfhY/n6+OKj5+8h48fDjrwzmPmVWvvtjjQXce8d3cbe3fXnr1b2+W7jb2bf/fshHt32ljPcduPLQ50mNzlG7mzcIt9cjdf367krtrInVX7sg+bPbH59/p3a1247ZN8mC805y5uPbhSttZ78ZzNXtxl7MWde/Zivv55q7147iH7e3Bg7+++OUvreCTf7LHF8/M9U8dmWwz9WnGUC3vufTUc5c7NvS0cZR+tfRiOhR08Y8+91+t65uYzCzM5s7n2uHTijEusdeIzjX26YXP9+u/6ObX53Zvt0YnP2LN38730Y8Xz2/dmYTIWHjRf/2zj+vUzbfl1fb/1d9f3mffG4q+Dgyvl6jA5sGLiWfYejJj4Mpu3uu9hsrq+/lpldduvZb3v92w+u7j67O7Nfa6Gj2x15vqztQ/7nI3OXN/ztiPc8+Lqd9eKD2x58M5rfN4LBq3tvU8fcv3ajq2vf3fDT9/SPHXI8zz+EJovWdHcnl+w7NC7rH53rXZoXs8+O7S9dv63tf+WrM7v/MGQ1ctyvPddvjep8zJbWbX22fLZ7tzc56Jxn6P6N/N31/HgPgziKPKin+OQ1YPN946Cod69ufawOO5qdPfx64VLv3uEX23bsuXXC8Z9jsqv83fXONw+rOHEwZXPbenr7TwUa/3HXUewnU1n7clUh3ON8eN2Nt2Sz1rVIH7xHjt94eDyz9Zr3tcLcr7uepOLfb6Nfq5Vd21nFK1l5uLmexdWnx2GMVrrW8+mu3DI+q7Vb/jGh4jfsObFfXr4wczTXlyt+Sh6eH39terhLb8d1W+Y73ncONiNm+dZ5zHn51nPpruwWddhuNkPJ8q7/NcVVvRjh9A8ONiPP21l9fTB/pq4LV71U0fE69d6/2cS4Ya/s3r+nz8CbvhQ0vtrnt7K4b66BP1ca43AVg4tf3afHJ7YXLv+3cuCuX7gnhqzrT90XL7hy1pjZmELlq04Cq0Lxrq2duqwuH2md2pz/Z/tidvX+Itl+7az6Z5hrOH2PWuYr/+r1Rr8IfZ6rQvW69rOz5qv/5s9PoCFNe2bn3U1LHdej4Ujr7+7vtbKIR2GAc7/vsug83Cu69rqon11XWs9cdfmPqnyKD/zAHGGO41n2+q1w+zxYbjc/3wAuNxTD6H5z9foX++TrRT+taWbbzvCffbx3lHx6H25o+0zvCwyf8GgcxSc+4Kx/pcFi/jhDU9bPuBhz2nhVyeMf8/rW8+mOwr/r6/ZzpFb+tBeYgTLtlj8f+cRaN6+onkU/t83m+5q/L/NE1r8b619zUfb31mY4cXNtdv643245Zb3zhvr3/7bkoXDcMvtmtZ0Xta63ZdFv8/41NXOb1y8zb7/tZ7feMYKx7p7Q/Oi8Uwvy/mN93rk/MahcrWP1k177v3I+Y395zealf585PzGI+c3HmrnN2b9vu+s+T49vU9vXW2NWx68YKxx372fYNA6qp3a4u3z9W+2xx+y4px9ePvVchJb3bnPL7m4+feF1d/Xua/pXvftPnswz5lcWK15K1f7cn36uVacbytX1j4fpS99qnMmL3rkXNShdGc6j5yLun7ORb3gYX4u6kP2+HHr97zv3T8UzkXdt4m95u9da37uH1fx3MdufIgLq+9fi+6d/73+nZVjuXHP8584uDxPb+U1H22s72r79imHxKzXeg7nd1f79umbfVs/z1bmLB6/Xs6S7MNB9p0l+dw9MmfZRCs+31fLZO3d6c3e3X3Me3ePsXd379m7daxwj7F38+++NOHenTbWY9XoPFB9Zb2Hq8nd12zkbp0bOIrczdd/80ruvn5PzLO1vUft5XZhtebnbs7V3HXIs33r5tmulsPYPtt8/Xevnu07Dtmvg4NrxwvvWq31azZ7ZvHwfM/jqpd/Wc+2XNxz76vlQ7c5G+tsyz5a+87VXA2j2d57va5nbT6zzrGc2Vx7XDru2ZforXXcs4x9umFz/frv+jm1+d1P79Fxz9yzd/O99GOdsdi+N+ucjHVGZ77+FY3r18+05df1/dbfXd9n3huLvw4OrpSrw+TAiqlm2XswYqrLbNjqvofJ6j5M82qyus2hr/f96ZvP1jpri89fLXbb6sz1Z+vc3rcewb/bd8+Lq98dZ63PvlzImtb23ofl79d2bH39n67kuThCbcz6eR5/CM2/2IPXWXZoH153NTu05GEPDpe/7bXzv4+Kg8/v/JF6l6PVu1w07vOynKv5lCPEsCcOrnzuo2CXj5yreeRczYmDK/nkWvl1/u4ax7ne8zYWrX06+Diw7YODw2X6oZQzsd7j+vqj7KX1Ho8yH+nlkTPJVzPT9HPyvt11qfa98ffHLdNaL9GffY7tz8nV5+vrn3Dpna1lbv7z5ANY59iEfCzDGFzo+yqG7Ww3/czv+OZjuH9oSh+LKjadK0NZX/X+l7bh4PR9u8/XcqSfR1369xwbbq+f6Z3aXH/hEnHxxZ0rGZmuNe438c+e604c8udEw/jdyfsu/92Z+668/sb7rrx+vvfZ+65c4/zZzavP1jKun1su/Xu9X2ta8zpOba5/lUvPPr+Tm1bfmb9/3rj/TZv7X7Zu43drHbOldaPxu/l6vZ9nbORm/ewJ9Wo+r+30hv76d9u1zbxzHHJVudDE0OR5W+VDlbuXt1xHV3eRRWRDrn8WL+/7F97XbdFlVdPHsa/Kq93//weH7ARpmckCAA==", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index c5aa7590813..cad807f87e2 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -44,8 +44,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZdNbuMwDIXv4rUXIinqp1cpgiJN3UGAIAnSZIBBkbsPaYpuu8hgIG/yvtR+z5REqfHn8Da93n697I/vp4/h6flzeL3sD4f9r5fDabe97k9H+evnEPQj4vAE4xDJJJqwSTLJJsWkzsLBBEwshS2FLYUthS2FLYUthS0liQFF5BYSkVuiSDGps+RgAiZoQibiY5FsUkzEl8ahBBMwQRMyiSZsIilZRHxlHCrOtVS5VkWSSTYpJlp8GAcIwQEc0IEcogM72Ggh5KalaTWF0BSaYlNqGk1Rk2dgh+SQHYpDbUDBARy05qhADtGBHZJDdigNouagAjqQQ3Rgh+SQHUoDXTBgBXBAB3LQwKTADskhO2hgVqgNanDQe2SNcV64qiDPwqCADuQgz0JQYAd5FqKC5CApFIfaQBcPo4Ims0JsDwXNSQrJITsUB82RUhGDAzhohZqD5KAV6ii0AUhr1gYw0N7SmrUBDGoDbQDSUWgDGKADOUQHdkgOmqwj1QYwqA2iJuvYtSVIxz63hFY4t8QMOhv1fh8HP4terpdp0qPo2+EkR9Z5e5mO1+HpeDscxuH39nCbb/o4b4+zXrcXuSpjnY5vohL4vj9MSvfxyx0eW2vhZq4lLXb+b7/sbA+QrUw9CdJRnoCMPQmkvWYJlKAnAWAZhezXtQncNZOoDd7mgUpXDaUuNdSueUBeRoEF1o6CexJSDdASUoW8JED5kQDwOKLIBmsRBRM+ivhHEZlKC8g5dAwiV/eXrqWUU6T55Rjp8Sd0f+7ZUljdT6HHT+hrSNhzKDD4+DnmHn/1BkiB1/khdvlp8dcef8mr/Il8/VLs6d+EaZU/gvsj9qxfDGXxl3V+6nu+z3+M2OWHdX5e5i917Z9l/Ziwa/+VxU/r/LHv+fnB/t/It+1uf/nxFnfXpMt++3qY2tf323H37er1z9mv+Fvg+XLaTW+3y6RJX6+C8vEMnEfIZTMO8oPtWX5cUNzoq4leksLkf5x+hflaHjHWzV0L+ws=", + "bytecode": "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", + "debug_symbols": "pZdNbuMwDIXv4rUXIinqp1cpgiJN3UGAIAnSZIBBkbsPaYpuu8hgIG/yvtR+z5REqfHn8Da93n697I/vp4/h6flzeL3sD4f9r5fDabe97k9H+evnEPQj4vAE4xDJJJqwSTLJJsWkzsLBBEwshS2FLYUthS2FLYUthS0liQFF5BYSkVuiSDGps+RgAiZoQibiY5FsUkzEl8ahBBMwQRMyiSZsIilZRHxlHCrOtVS5VkWSSTYpJlp8GAcIwQEc0IEcogM72Ggh5KalaTWF0BSaYlNqGk1Rk2dgh+SQHYpDbUDBARy05qhADtGBHZJDdigNouagAjqQQ3Rgh+SQHUoDXTBgBXBAB3LQwKTADskhO2hgVqgNanDQe2SNcV64qiDPwqCADuQgz0JQYAd5FqKC5CApFIfaQBcPo4Ims0JsDwXNSQrJITsUB82RUhGDAzhohZqD5KAV6ii0AUhr1gYw0N7SmrUBDGoDbQDSUWgDGKADOUQHdkgOmqwj1QYwqA2iJuvYtSVIxz63hFY4t8QMOhv1fh8HP4terpdp0qPo2+EkR9Z5e5mO1+HpeDscxuH39nCbb/o4b4+zXrcXuSpjnY5vohL4vj9MSvfxyx0eW2vhZq4lLXb+b7/sbA+QrUw9CdJRnoCMPQmkvWYJlKAnAWAZhezXtQncNZOoDd7mgUpXDaUuNVRYWwP3JfAyD1h6ElIN0BJShbwkQPmRAPA4osgGaxEFEz6K+EcRmUoLyDl0DCJX95eupZRTpPnlGOnxJ3R/7tlSWN1PocdP6GtI2HMoMPj4OeYef/UGSIHX+SF2+Wnx1x5/yav8iXz9Uuzp34RplT+C+yP2rF8MZfGXdX7qe77Pf4zY5Yd1fl7mL3Xtn2X9mLBr/5XFT+v8se/5+cH+38i37W5/+fEWd9eky377epja1/fbcfft6vXP2a/4W+D5ctpNb7fLpElfr4Ly8QycR8hlMw7yg+1ZflxQ3OiriV6SwuS/pH6F+VoeMdbNXQv7Cw==", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_0.snap index 4c43a3f6dcd..ef2f6832476 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_0.snap @@ -44,8 +44,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZfdbuJADIXfJddcjO358fRVVqiiNK2QIkAprLSqePe14zhtL8KuhhvOF5JzMp54GPLZvfYv1/fnw/Ht9NE9/frsXsbDMBzen4fTfnc5nI7y7WcX9IO4e4JNR3WSGEzABE3IJJokk2xSTCwlWkqylGQpyVKSpSRLSZaS5UsUkTASkbAkwiZ1khJMwARNyCSaSFgRySbFhE0khTcdBxMwQRNJqSLRJE1SdbhBVEcoQ6xaqIyxlll5Vq1VBg0hOGi9UUEjkgI5RAdNzQoaWxTY7gdBA2VUAMEBHNBBA6tCdEgOEoiaA8VBkhEUJBllyIDBQZJRx4zoQA6SjFoFJofsUBzYoc5AwUGTtVJCB3LQZK2dNFlrp2xzDFQceAZtQdSStQkNyEFyaLomOWSH4sAOdQZtSgNwkGTS2dBmJK098dSHkPUSrSajAzlEBzVpWVPzTlAc2KHOoE1sAA5ot9JOnjTOmmbNs5ZZ56FpP6tqQ9Pttul8ST9fxr7XFf1tjcvKP+/G/njpno7XYdh0v3fDdbro47w7TnrZjXJW2qU/vopK4Nth6JVumy93WLdWTrO5cl7s6b/9sjY8AEKhlgQM2RMwYUsCae9aAmVYS4jrCYV4DigltPir+5l4zZ/X/Rj9EWKEFn9G9xds8Vf3U2jxk/5QmR+pwZ/A60+xtPirN0AO6TE/xCY/Lf7a4ufykD+TP78cQ4sf80P+CO6P2PL8YuDFz4/5qe3+Pv8xYpMfHvOnZf5y0/pZnl8ibFp/vPjpMX9su3/59/q/twMALLuQ/MF4NCGt7oRY7yyiunRBrvBVBvCPCLozCsboP0Qsv+lrEXd3UyzLbrq+F92dCa7LTFRo2tHTMpfIbQnfqkg/E7ZytNsfxh9vQzfNGg+7l6GfD9+ux/23s5c/Zz/jb1Pn8bTvX69jr0lfr1Ty8QtkP0eoW3mzkiP5d0Fxq//x9RTTBpj1EKYrcQM1bm86sL8=", + "bytecode": "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", + "debug_symbols": "pZfdbqNADIXfhetcjO358fRVVlGVprSKhJKIJiutqrz72hjT9oLsanKT8xE4hzF4GPjsXvuX6/vz4fh2+uiefn12L+NhGA7vz8Npv7scTkf597ML+kPcPcGmozpJDCZggiZkEk2SSTYpJpYSLSVZSrKUZCnJUpKlJEvJ8ieKSBiJSFgSYZM6SQkmYIImZBJNJKyIZJNiwiaSwpuOgwmYoImkVJFokiapOtwgqiOUIVYtVMZYy6w8q9Yqg4YQHLTeqKARSYEcooOmZgWNLQps54OggTIqgOAADuiggVUhOiQHCUTNgeIgyQgKkowyZMDgIMmoY0Z0IAdJRq0Ck0N2KA7sUGeg4KDJWimhAzlostZOmqy1U7ZrDFQceAZtQdSStQkNyEFyaDomOWSH4sAOdQZtSgNwkGTSq6HNSFp74qkPIeshWk1GB3KIDmrSsqbmnaA4sEOdQZvYABzQTqWdPGmcNc2aZy2zzkPTflbVhqbbbdP5lH6+jH2vM/rbHJeZf96N/fHSPR2vw7Dpfu+G63TQx3l3nPSyG2WvtEt/fBWVwLfD0CvdNl/usG6tnGZz5bzY03/7ZW54AIRCLQkYsidgwpYE0t61BMqwlhDXEwrxHFBKaPFX9zPxmj+v+zH6LcQILf6M7i/Y4q/up9DiJ31QmR+pwZ/A60+xtPirN0AO6TE/xCY/Lf7a4ufykD+T378cQ4sf80P+CO6P2HL/YuDFz4/5qe38fv1jxCY/POZPy/XLTfNnuX+JsGn+8eKnx/yx7fzl3/P/3goAsKxC8oLxaEJaXQmx3plEdemCXOGrDOAfEXRnFIzRH0Qsz/S1iLurKZZlNV1fi+5eCa7LlajQtKJ/G0NqS0jL3UD+mbCVrd3+MP74Grpp1njYvQz9vPl2Pe6/7b38Ofse/5o6j6d9/3ode036+qSSn18g6zlC3cqXlWzJ2wXFrb7j6y6mDTDrJkxH4gZq3N50YH8B", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 4c43a3f6dcd..ef2f6832476 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/ram_blowup_regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -44,8 +44,8 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/9WdB5gkRRXHa3ZnZndmd3Zm9wgHRzjuODJc9+7s7R4GjuPMCXNCYW6DCRXM2TkwK4o5oMhhRFExYgA9QFExgRHFgDmTc37/pWvnzZua4eC6+b5/f/O+nu6ufvWr6urq6q6q93IuWXILv4Ul39rVWvsNc2xdso62bYlT1BVlxZgjYOwjYOwnYMwTMBYIGIsEjAMEjIMEjCUCxjIB4xAB4zABY4WAcYSAsUrAWCNgHCVgHCNgXELAuB0B4/YEjDsQMO5IwLiUgHEnAsadCRiXETDuQsC4KwHjbgSMuxMwLidg3IOAcQUB40oCxj0JGFcRMO5FwLg3AeM+BIz7EjDuR8C4PwHjAQSMBxIwHkTAuJqAMSJgjAkYxwkYJwgY6wSMkwSMawgYpwgYpwkY1xIwHkzAeB8CxvsSMN6PgPH+BIyHEDCuI2A8lIBxPQHjYQSMGwgYH0DA+EACxgcRMD6YgPEhBIwPJWB8GAHjwwkYH0HA+EgCxkcRMB5OwPhoAsbHEDA+loDxcQSMjydgfAIB4xMJGJ9EwPhkAsanEDA+lYDxCALGpxEwPp2A8UgCxqMIGBsEjBsJGGcIGGcJGOcIGOcJGJ9BwPhMAsZnETA+m4DxOQSMRxMwPpeA8XkEjM8nYDyGgPFYAsYXEDC+kIDxRQSMLyZgfAkB40sJGF9GwPhyAsZXEDC+koDxVQSMryZgfA0B42sJGJsEjJsIGI8jYDyegPF1BIyvJ2B8AwHjGwkY30TA+GYCxrcQML6VgPFtBIwnEDC+nYDxHQSMJxIwvpOA8V0EjO8mYHwPAeN7CRjfR8D4fgLGDxAwfpCA8UMEjCcRMH6YgPEjBIwnEzB+lIDxFALGzQSMpxIwfoyA8eMEjJ8gYPwkAeOnCBg/TcB4GgHjZwgYP0vAeDoB4+cIGD9PwPgFAsYzCBi/SMD4JQLGLxMwfoWA8asEjF8jYDyTgPHrBIzfIGD8JgHjtwgYzyJgPJuA8dsEjN8hYNxCwHgOAeO5BIznETB+l4DxewSM5xMwfp+A8QcEjD8kYLyAgPFHBIw/JmD8CQHjTwkYf0bAeCEB40UEjD8nYPwFAeMvCRh/RcD4awLG3xAwXkzA+FsCxt8RMF5CwPh7AsY/EDD+kYDxTwSMlxIw/pmA8S8EjH8lYPwbAePfCRj/QcD4TwLGfxEw/puA8T8EjP8lYPwfAeP/CRgvI2C8nIDxCgLGKwkYryJgvJqA8RoCxmsJGK8jYLyegPEGAsYbCRhvImC8mYDxFgLGWwkYbyNgvD1FRs/WBupy7fv6RPpF8iIFkaLIgMigSEmkLDIkMixSERkRqYrUREZFxkSWiGwnsr3IDiI7iiwV2UlkZ5FlIruI7Cqym8juIstF9hBZIbJSZE+RVSJ7iewtso/IviL7iewvcoDIgSIHiaxG5ojEIuMiEyJ1kUmRNSJTItMia0UOFoGTeziRh5N2OEH3TsYPFVkvAifPcKIMJ8VwAgwnu3BiCyexcMIKJ6dwIgonnXCCCSeTh4vASSKcEMLJH5zowUkdnMDByRqcmMFJGJxwwckVnEjBSROcIMHJ0FEiDZGNInDyAicqcFICJyBwsgEnFnASAScMcHIAJwIw0g8j+DAyf4wIjKTDCDmMfMOINoxUwwg0jCzDiDGMBMMIL4zcwogsjLTCCCqMjDZFNokcJwIjjzCiCCOFMAIII3swYgcjcTDCBiNnMCIGI10wggUjUyeKwEgSjBDByA+M6MBIDYzAwMgKjJjASAiMcMDIBYxIwEgDjCDAyMApIptFThXBJG9MosYkZUwCxiRbTGLFJFFMwsQkR0wixCQ9TILDJLMzRDBJCpOQMMkHk2gwSQWTQDDJApMYMEkAg/AxyB2DyDFIG4OgMch4i8g5IueKYJAnBlFikCIGAWKQHQaxYZAYBmFhkBMGEWGQDgbBYJDJhSIYJIFBCOjkRyc6OqnRCYxOVnRiopMQnXDo5EInEjpp0AmCToZLRfCRHB+h8ZEXH1HxkRIfAfGRDR+x8JEIH2HwkQMfEfCSjpdgvGTiJQ4vSXgJQSMfjWg0UtEIRCMLjRg0EvAQxkMODxFU0qgEUcn4pVu94BJmLKVk3aeOo85Yl2xH27bEJRNvmvqn4/pkybUvKfNPlFyrLk1dfxxFJaUzA/5oINGzodnSb9Piy0HOZXSdono903RKPlZM2pxKi487n03ccc7E50w6nYm/7DIsU9GdPDo+z2Pzx/+v+DDNFk/OHMs3O9PhjxWa7enAgjbGUhXOlq0+FW6l+r/K6N6wqZMpy3tS6pR6xvdkvMR1vw99GgeabnHxx/rVPp/nPp8GdXhzrKSO5Zvt8ZST7byKR+vyHAUTfkWyXU3WRXWOP78WiL9o4m/jDuzTeWR19Qf2+fBo6y5L/qON658ThzVb+tKsfxAHyu+Znsl1XtecS69e9/eUvsft/VFw6ad1PNr6+m6xzLgM619V3xUMj82fPpM/xWzyJ8oZ/ZqnGMgffy0HAse8rsFku6B06fBFlUYdXv/35+t9k8m6FtBpy+6A60yP3qfvvdUmbf0qXK7L2rnOcqT11gJc/vpm+oyPWu20Qib6x6Osy2TJdV5fl17+xF7/YDb5H9v2nb7WyLND1P6ca9X3+n7RbR//HCiY8CconeuT/1XX/Xndq3xneU3lqm51PezjL7ts2zW96r1Qu9PnTykDHl0PlwM8/QGeUdeqP/U103xe1/Jk3eu94+7Wb7a8OJfetam5zjJcNGkoppiGUvppiGqu+7XxaSinkIaa0aXjybLMyjLv9Q9loj+e8/qHXcrXR33LqGSTN3Oh90j9DDhC7dfH9DMgF7imBRP+aKXzyOR/NXC+Lx/Ztj3iqFf7K9QW8qy6rTLQ4zzdbq4G0mLrNr/d14PBufBzMRfQE7rf+g1P6HnWjSdUPmz8LsDu9Qy5cD6UjZ4Ro8fetznz378r6/KodRTUcR3+2GSNttXZRqd/x3au97PNhx8NhK+pMJ6nahj0uSH2qtIbOteWoZri66VLH/Pb+YCeUBnqdl5fgG/Y6Am1M6sBVv0ssjp9PlVMGP3f8xdduI5a/MZmwjeTNcrEli46dTnTXIUuOo9XOm05C5WbXuVsLBB+VIXxPFXXWQbHzHmaXZd3uy90Xe39b7dHAnpC7Qxd5qye0HXz70F395k11EOvT6MOPxwIr+sgH97ns74//Lm2TeDjW5eso21cKoG05Uzc2bQZtv4dycdfDuRhFu9IFcNj88e2p0eyyZ8I96StO7Ho76T62mgOXV70+X2u871P1zu+POg2tL4nTjJ6fTy6PisF9BZM+M1K58lGp34/CbHa+1cfKym99rvD1l5XH34kEL4SiKvqOvPcPqvtPXRX8YTeb+xzrNglvNdn2yqnJWvk33lddHZr/xS76Dxd6fTPpVCf1WJ/R7LOq2Npfv8Gx/mKQ7Mu8Dfb0x1qo+nw97SNVjPhdfkIfSutmnhCzw5dDuw9UArEo+/XLPN9aro16Mlfc1+O7JJXx3X4s5JtXY79Or8NnPNTjXh+ojHfmGzMztZnGmNGPxb9bpF2/DOTazbO1Ccb0VyMzfF7O/7x6ek1a8c3RvWp2Zn52frEvR2/JH1qpjEVx2vr8Vw9nryr+EN9lroeweL7PXW/qA7v9RVM+At8WHfnuCIstp9cx4dwl/QIl+uyXtAR2Jdvtu8L9ZfqfmQffrH90+xk9MeG1DFdx2EZTrZ1fmldnqNgwl+cbPtrovt+/fm1QPyDJv427sA+2488FAg/FAiP63OR15esddrTbhsuxGn0632WzZcdlOs7ADKjf7RFzgAA", - "debug_symbols": "pZfdbuJADIXfJddcjO358fRVVqiiNK2QIkAprLSqePe14zhtL8KuhhvOF5JzMp54GPLZvfYv1/fnw/Ht9NE9/frsXsbDMBzen4fTfnc5nI7y7WcX9IO4e4JNR3WSGEzABE3IJJokk2xSTCwlWkqylGQpyVKSpSRLSZaS5UsUkTASkbAkwiZ1khJMwARNyCSaSFgRySbFhE0khTcdBxMwQRNJqSLRJE1SdbhBVEcoQ6xaqIyxlll5Vq1VBg0hOGi9UUEjkgI5RAdNzQoaWxTY7gdBA2VUAMEBHNBBA6tCdEgOEoiaA8VBkhEUJBllyIDBQZJRx4zoQA6SjFoFJofsUBzYoc5AwUGTtVJCB3LQZK2dNFlrp2xzDFQceAZtQdSStQkNyEFyaLomOWSH4sAOdQZtSgNwkGTS2dBmJK098dSHkPUSrSajAzlEBzVpWVPzTlAc2KHOoE1sAA5ot9JOnjTOmmbNs5ZZ56FpP6tqQ9Pttul8ST9fxr7XFf1tjcvKP+/G/njpno7XYdh0v3fDdbro47w7TnrZjXJW2qU/vopK4Nth6JVumy93WLdWTrO5cl7s6b/9sjY8AEKhlgQM2RMwYUsCae9aAmVYS4jrCYV4DigltPir+5l4zZ/X/Rj9EWKEFn9G9xds8Vf3U2jxk/5QmR+pwZ/A60+xtPirN0AO6TE/xCY/Lf7a4ufykD+TP78cQ4sf80P+CO6P2PL8YuDFz4/5qe3+Pv8xYpMfHvOnZf5y0/pZnl8ibFp/vPjpMX9su3/59/q/twMALLuQ/MF4NCGt7oRY7yyiunRBrvBVBvCPCLozCsboP0Qsv+lrEXd3UyzLbrq+F92dCa7LTFRo2tHTMpfIbQnfqkg/E7ZytNsfxh9vQzfNGg+7l6GfD9+ux/23s5c/Zz/jb1Pn8bTvX69jr0lfr1Ty8QtkP0eoW3mzkiP5d0Fxq//x9RTTBpj1EKYrcQM1bm86sL8=", + "bytecode": "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", + "debug_symbols": "pZfdbqNADIXfhetcjO358fRVVlGVprSKhJKIJiutqrz72hjT9oLsanKT8xE4hzF4GPjsXvuX6/vz4fh2+uiefn12L+NhGA7vz8Npv7scTkf597ML+kPcPcGmozpJDCZggiZkEk2SSTYpJpYSLSVZSrKUZCnJUpKlJEvJ8ieKSBiJSFgSYZM6SQkmYIImZBJNJKyIZJNiwiaSwpuOgwmYoImkVJFokiapOtwgqiOUIVYtVMZYy6w8q9Yqg4YQHLTeqKARSYEcooOmZgWNLQps54OggTIqgOAADuiggVUhOiQHCUTNgeIgyQgKkowyZMDgIMmoY0Z0IAdJRq0Ck0N2KA7sUGeg4KDJWimhAzlostZOmqy1U7ZrDFQceAZtQdSStQkNyEFyaDomOWSH4sAOdQZtSgNwkGTSq6HNSFp74qkPIeshWk1GB3KIDmrSsqbmnaA4sEOdQZvYABzQTqWdPGmcNc2aZy2zzkPTflbVhqbbbdP5lH6+jH2vM/rbHJeZf96N/fHSPR2vw7Dpfu+G63TQx3l3nPSyG2WvtEt/fBWVwLfD0CvdNl/usG6tnGZz5bzY03/7ZW54AIRCLQkYsidgwpYE0t61BMqwlhDXEwrxHFBKaPFX9zPxmj+v+zH6LcQILf6M7i/Y4q/up9DiJ31QmR+pwZ/A60+xtPirN0AO6TE/xCY/Lf7a4ufykD+T378cQ4sf80P+CO6P2HL/YuDFz4/5qe38fv1jxCY/POZPy/XLTfNnuX+JsGn+8eKnx/yx7fzl3/P/3goAsKxC8oLxaEJaXQmx3plEdemCXOGrDOAfEXRnFIzRH0Qsz/S1iLurKZZlNV1fi+5eCa7LlajQtKJ/G0NqS0jL3UD+mbCVrd3+MP74Grpp1njYvQz9vPl2Pe6/7b38Ofse/5o6j6d9/3ode036+qSSn18g6zlC3cqXlWzJ2wXFrb7j6y6mDTDrJkxH4gZq3N50YH8B", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index cb7fb713469..dc23cb6a02a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -74,8 +74,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_0.snap index ed5e0edece0..a6568b3bb47 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_0.snap @@ -74,8 +74,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index c0ba5e10da0..cb738ba10d2 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -70,8 +70,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == std::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = std::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 0424f45a638..5e342101af4 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -71,8 +71,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_0.snap index da422377b67..a5e1d4d4f46 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_0.snap @@ -71,8 +71,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 6b81d5ad499..4db85161cca 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5252/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -67,8 +67,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "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", + "debug_symbols": "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", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n self.__assert_max_bit_size(BIT_SIZE);\n }\n\n #[builtin(apply_range_constraint)]\n fn __assert_max_bit_size(self, bit_size: u32) {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_le_bits)]\n fn _to_le_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n /// wrap around due to overflow when verifying the decomposition.\n #[builtin(to_be_bits)]\n fn _to_be_bits(self: Self) -> [u1; N] {}\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = self._to_le_bits();\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = self._to_be_bits();\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n // docs:start:to_le_radix\n pub fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n self.__to_le_radix(radix)\n }\n // docs:end:to_le_radix\n\n // docs:start:to_be_radix\n pub fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(radix);\n }\n self.__to_be_radix(radix)\n }\n // docs:end:to_be_radix\n\n // `_radix` must be less than 256\n #[builtin(to_le_radix)]\n fn __to_le_radix(self, radix: u32) -> [u8; N] {}\n\n // `_radix` must be less than 256\n #[builtin(to_be_radix)]\n fn __to_be_radix(self, radix: u32) -> [u8; N] {}\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index be6e69d2540..a3f7b286887 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -11,7 +11,7 @@ expression: artifact "error_types": {} }, "bytecode": "H4sIAAAAAAAA/5XDsQkAAADCMAv+f7PuTgaCFm19Arunwj5IAAAA", - "debug_symbols": "pZXbisMgEED/xec8ONZrf2VZik1tEcQEmxSW0n9fGzKmFBaW6ZPRyTljyDje2Skc58sh5vNwZfuvOzuWmFK8HNLQ+ykOua7eHx3D6WEqIdQl9hKv1OhLyBPb5zmljt18mpeXrqPPyzj5UqO8YyGf6liF55jC8+nRbTT/G5UCYSlFw9X/edt45wi8BrHyGnYUXinklabwxiFvOYV3sPKGSwJvuEEeFIUHi/wOPstP4q1A3gpL4aVGXhoKb7D+rCXtX7f8llL/1iHvOCW/E1i/TlLqH7jGAgBuKH8AgOMRBABBM8BmcCSDlM0gFclgN4Oj7aG1kiqj9AIQrZmCkEAyqF0zkOqxYmozaJJBb1/xdqa+68z3sbzfYjdfoj+msE7Pc+5fotPPiBG8Bccy9OE0l/A0LbHq/gU=", + "debug_symbols": "pZXbasMwDED/xc95sFxf+ytjFDd1i8E4wU0Ko/Tf54bI6QaDoT45tnKOBFHkOzuF43w5xHwermz/cWfHElOKl0Maej/FIdfT+6NjuD1MJYR6xF7ilRp9CXli+zyn1LGbT/Py0nX0eVknX2qUdyzkU12r8BxTeD49uo3mf6NSICylaLj6P28b7xyB1yBWXsOOwiuFvNIU3jjkLafwDlbecEngDTfIg6LwYJHfwXv5SbwVyFthKbzUyEtD4Q32n7Wk+nXLbyn9bx3yjlPyO4H96ySl/4FrbADghvIFADj+ggAgaAbYDI5kkLIZpCIZ7GZwtBraKKkyyiwA0YYpCAkkg9o1A6kfQeitBkurwarN8HOmftad72P5fYvdfIn+mMK6Pc+5f4lOXyNG8BYcy9CH01zC07TEqvsb", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap index 60ecc2194aa..14ef460e5fc 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_0.snap @@ -11,7 +11,7 @@ expression: artifact "error_types": {} }, "bytecode": "H4sIAAAAAAAA/5XDsQkAAADCMAv+f7PuTgaCFm19Arunwj5IAAAA", - "debug_symbols": "pZXNjsIgEIDfhXMPDPIz+CqbjcGKhoTQBluTjfHdF41Q16QeZk8Upt/H0IFyZQe/n0+7kI7DmW2/rmyfQ4zhtItD76YwpDJ6vXWsdndT9r4MsZd4oUaXfZrYNs0xduzi4vx46Ty69Ggnl0uUd8ynQ2mL8Biivz/duoXm66gUFZZSNFz95WGdR2GePAqk8FJXXhoKb2r+iEDhdZsfSeu3lbecMr8VqvJys8Z/qh+2+lm7xuM6D1zjUwDcIMUAXFQDgKAZYDGQVgFSNoNUJAMuBtqXBKWaATnFINphBCGBZMCWg0BNMuglB6TloDaLQRD2tIa6oTRQzoRuhdBKU3hjK79ex0+8rdvZcEngDa//VAOKwkM90mYD/5v/jf8uPdeH/H6LXVwObh/9s3ucU/8SnX7GGqm34JiH3h/m7O+mR6y4fwE=", + "debug_symbols": "pZXNjsIgEIDfhXMPDPLrq2w2BisaEkIbbE02xndfNA51Teph9kRh+n2UDgNXdgj7+bSL+Tic2fbryvYlphRPuzT0fopDrqPXW8ewu5tKCHWIvcQrNfoS8sS2eU6pYxef5sdL59HnRzv5UqO8YyEfaluFx5jC/enWLTRfR6VAWErRcPWXh3XeCvPkrbAUXmrkpaHwBr/fWqDwus1vSet3yDtOmd8JhbzcrPGf8mdb/pxb4+06D1zbpwC4sRQDcIEGAEEzwGIgrQKkbAapSAa7GGh/EpRqBsspBtGKEYQEkkEvBkszWLUYNMmgNotBEPa0BtxQGig1oVsitNIU3jjk1/P4iXe4nQ2XBN5wPFMNKAoPWNJmA/+b/43/rj3fx/J+i118iX6fwrN7nHP/Ep1+RozgLTiWoQ+HuYS76RGr7l8=", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 60ecc2194aa..14ef460e5fc 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -11,7 +11,7 @@ expression: artifact "error_types": {} }, "bytecode": "H4sIAAAAAAAA/5XDsQkAAADCMAv+f7PuTgaCFm19Arunwj5IAAAA", - "debug_symbols": "pZXNjsIgEIDfhXMPDPIz+CqbjcGKhoTQBluTjfHdF41Q16QeZk8Upt/H0IFyZQe/n0+7kI7DmW2/rmyfQ4zhtItD76YwpDJ6vXWsdndT9r4MsZd4oUaXfZrYNs0xduzi4vx46Ty69Ggnl0uUd8ynQ2mL8Biivz/duoXm66gUFZZSNFz95WGdR2GePAqk8FJXXhoKb2r+iEDhdZsfSeu3lbecMr8VqvJys8Z/qh+2+lm7xuM6D1zjUwDcIMUAXFQDgKAZYDGQVgFSNoNUJAMuBtqXBKWaATnFINphBCGBZMCWg0BNMuglB6TloDaLQRD2tIa6oTRQzoRuhdBKU3hjK79ex0+8rdvZcEngDa//VAOKwkM90mYD/5v/jf8uPdeH/H6LXVwObh/9s3ucU/8SnX7GGqm34JiH3h/m7O+mR6y4fwE=", + "debug_symbols": "pZXNjsIgEIDfhXMPDPLrq2w2BisaEkIbbE02xndfNA51Teph9kRh+n2UDgNXdgj7+bSL+Tic2fbryvYlphRPuzT0fopDrqPXW8ewu5tKCHWIvcQrNfoS8sS2eU6pYxef5sdL59HnRzv5UqO8YyEfaluFx5jC/enWLTRfR6VAWErRcPWXh3XeCvPkrbAUXmrkpaHwBr/fWqDwus1vSet3yDtOmd8JhbzcrPGf8mdb/pxb4+06D1zbpwC4sRQDcIEGAEEzwGIgrQKkbAapSAa7GGh/EpRqBsspBtGKEYQEkkEvBkszWLUYNMmgNotBEPa0BtxQGig1oVsitNIU3jjk1/P4iXe4nQ2XBN5wPFMNKAoPWNJmA/+b/43/rj3fx/J+i118iX6fwrN7nHP/Ep1+RozgLTiWoQ+HuYS76RGr7l8=", "file_map": {}, "names": [ "main" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 16d10a89a1e..19634ef17cd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -35,8 +35,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "pZjdbtpMEIbvhWMOPD87u9tbiaKIJKRCQiSi8EmfIu69Mx6/pq1Uqdqc8D4OzGPHflkDn5vX/fP1+9Ph9Pb+Y/Pt4XPzfD4cj4fvT8f3l93l8H7yv35upnhgf6TthimDMyRDM0qGZdSMltHnkLRIWiQtkhZJi6RF0iJpkbRIWjQtmhZ1C3tIhmaUDMuoGW4Rjz5HmTIogzMkQzNKhmXUjLSUtFhaLC2WFkuLpcXSYm5Rj5rRMvocdcqgDM5wS/HQDLeYh2XUjJbhlrrdtCnDLc2DMyRD5+i+1T00o2RYRs1oGX0OmuJkTwEEYIAAFFAABohL5leJaAIQgAECUEABGKACGgBmhplhZpgZZoaZYWaYGWaGeS6r94Xmus5AAAYIQAEFYIAKaACYFWaFWWFWmBVmhVlhVpgV5qgxSUBMaUC8uARUQAP0BaK9ZAEEYEAcRg1QQAEYoALastPo8wzR6AQCMEAAONTodoItEFWmFkAABsSLo5nNd8rRsdYX6BOAAAwQgAJiiYjLHfVPqIAw+1nl6DxLgAIKwAAV0AB9geh8AjzR+QQIo9isATFeAvoCUeyEGLcABgggPDWgAAxQAQ3QF4hiJxCAAQKAWWAWmAVmgVlgVpgVZoV5XqFbgAIKwAAV0AB9gVivEwgQ5h4gAAUUgAEqoAH6AvMaPgUQgAECMECs+/P9LV4cJYliS1zKKHaCAgrAABXQABBG5xMIwAABKKAADBBmut22G9y9ny7n/T5u3r/czv0m/7E770+XzbfT9Xjcbv7bHa/zi3587E5zXnZnf9b/1/3p1dOFb4fjPui2vU9Pfx+lOKvzsK+g63j593k1zFsdmOdYxed5f7+NzOs6X4f233mZl4m+OG8D88K4eML9a/OiA/O6zquOnH9t63wfOX4jnD8jGZkvBfNl5PxbRf+tjfTfOvpXp5HzX6eKeSoj83GfzXmhr+1/aL4x5hu3kfl1/Wg68v5tFf1rbej4bd1/G+l/65jvQ+tHZ/S360j//dM7CkBTHbkC/mkfb0H/vM9jBrob+pBBdTVoGTK0u6GPHcO6lLhs6F7I62LqX2JoyFBkNQz10cfK3WBDBrv/F3+8px59a/dyOP/2o8MtXOfD7vm4XzbfrqeXX569/P+BZ/Cjxcf5/WX/ej3vw3T/5cIfHrjLVkgf4wupbzbbdooN/6D1IP5NSKg+3uJQfgI=", + "bytecode": "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", + "debug_symbols": "pZjdbtpAEIXfhWsuPD87u9tXiaKIJKRCQiSiUKmKePfOeHxMe1Gp2txwPgfms2Mf1sDn5nX/fP3+dDi9vf/YfHv43DyfD8fj4fvT8f1ldzm8n/yvn5spHtgfabthyuAMydCMkmEZNaNl9DkkLZIWSYukRdIiaZG0SFokLZIWTYumRd3CHpKhGSXDMmqGW8Sjz1GmDMrgDMnQjJJhGTUjLSUtlhZLi6XF0mJpsbSYW9SjZrSMPkedMiiDM9xSPDTDLeZhGTWjZbilbjdtynBL8+AMydA5um91D80oGZZRM1pGn4OmONlTAAEYIAAFFIAB4pL5VSKaAARggAAUUAAGqIAGgJlhZpgZZoaZYWaYGWaGmWGey+p9obmuMxCAAQJQQAEYoAIaAGaFWWFWmBVmhVlhVpgVZoU5akwSEFMaEC8uARXQAH2BaC9ZAAEYEIdRAxRQAAaogLbsNPo8QzQ6gQAMEAAONbqdYAtElakFEIAB8eJoZvOdcnSs9QX6BCAAAwSggFgi4nJH/RMqIMx+Vjk6zxKggAIwQAU0QF8gOp8AT3Q+AcIoNmtAjJeAvkAUOyHGLYABAghPDSgAA1RAA/QFotgJBGCAAGAWmAVmgVlgFpgVZoVZYZ5X6BaggAIwQAU0QF8g1usEAoS5BwhAAQVggApogL7AvIZPAQRggAAMEOv+fH+LF0dJotgJAlBALP1xlaPYCRXQABBG5xMIwAABKKAADBBmut22G9y9ny7n/T5u3n/czv0m/7E770+XzbfT9Xjcbn7ujtf5RT8+dqc5L7uzP+v/6/706unCt8NxH3Tb3qenf49SnNV52FfQdbz8/7wa5q0OzHOs4vO8v99G5nWdr0P777zMy0RfnLeBeWFcPOH+tXnRgXld51VHzr+2db6PHL8Rzp+RjMyXgvkycv6tov/WRvpvHf2r08j5r1PFPJWR+bjP5rzQ1/Y/NN8Y843byPy6fjQdef+2iv61NnT8tu6/jfS/dcz3ofWjM/rbdaT//ukdBaCpjlwB/7SPt6B/3ucxA90Nfciguhq0DBna3dDHjmFdSlw2dC/kdTH1LzE0ZCiyGob66N+V7sfQxo6hlbvh7zX10bd2L4fzXz863MJ1Puyej/tl8+16evnj2cuvDzyDHy0+zu8v+9freR+m+y8X/vDAXbZC+hhfSH2z2bZTbPgHrQfxb0JC9fEWh/Ib", "file_map": { "50": { "source": "fn main() {\n let numerator =\n [790096867046896348, 1063071665130103641, 602707730209562162, 996751591622961462, 28650, 0];\n unsafe { __udiv_mod(numerator) };\n\n let denominator = [12, 0, 0, 0, 0, 0];\n let result = unsafe { __validate_gt_remainder(denominator) };\n assert(result[4] == 0);\n assert(result[5] == 0);\n}\n\nunconstrained fn __udiv_mod(remainder_u60: [u64; 6]) {\n let bit_difference = get_msb(remainder_u60);\n let accumulator_u60: [u64; 6] = shl(bit_difference);\n}\n\nunconstrained fn __validate_gt_remainder(a_u60: [u64; 6]) -> [u64; 6] {\n let mut addend_u60: [u64; 6] = [0; 6];\n let mut result_u60: [u64; 6] = [0; 6];\n\n for i in 0..6 {\n result_u60[i] = a_u60[i] + addend_u60[i];\n }\n\n result_u60\n}\n\nunconstrained fn get_msb(val: [u64; 6]) -> u32 {\n let mut count = 0;\n for i in 0..6 {\n let v = val[(6 - 1) - i];\n if (v > 0) {\n count = 60 * ((6 - 1) - i);\n break;\n }\n }\n count\n}\n\nunconstrained fn shl(shift: u32) -> [u64; 6] {\n let num_shifted_limbs = shift / 60;\n let limb_shift = (shift % 60) as u8;\n\n let mut result = [0; 6];\n result[num_shifted_limbs] = (1 << limb_shift);\n\n for i in 1..(6 - num_shifted_limbs) {\n result[i + num_shifted_limbs] = 0;\n }\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_0.snap index 2957bb36011..d3e5fae2091 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_0.snap @@ -35,8 +35,8 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1ay47rRBBtJ/YkzmMSgdghgcQHYMeOE68YIVaIn3D82CHxAQiZD0Nixwr2fAAbJPZsQHec2zU+rpQ7npv2aBbT0qhjd/WpR1dVl7vHUW1zdO+qGxqBfKF/+Pp5AuPTx78H/Rzc1kKf8bWJfwzi2Bf0syh/5GtMZxz8gPBHsn8w0zjf1C0+6kJ8549/S/i9Uq1/jKU/rd+Y+n9s0Hmpdf2X6YqyuLfIklVJlZdZmB2y067IfdDPCn6ZB3kW5EFW5GW0T33AtIJ/3BdRdcjz3eOPMtoRvmcLvyj2uzzOsqgqyjRKCP/OFj60pCozwp+NgN+0tcacq7Y5zLcwH1r084PD+CnV9TPF+C+YrLbzvsP4kTzcPhRrZLuFIOtWGMMYxTHksxD4SFhTi1iuRSzPItadRSyKH1qzCcxzenriw9/RXCk32twHtkreZ5C3Ow7vRMqbFvH3Ut5Uym4NN17uip72xcU49gnJT3kNo7TNvoT3zR/VQZ5qYwPnujCO9DvA/K4H0wFMHt/4ewVYkgwek4HoE903Ofb/HkzUa2nQi+hTwHScLuZatc2U34n+XqBfAw3Js2Ey4FzO29Oy8719xfQh+q9139j2K4a5FORDu5OPSj61BFzuU0Q3AVxfmOsLetvMgyQLrZEL8qwEeTxG/y3T6x5sNTXYhK8Z8sV19RnfNePbyOFqBlJOJ94YgxumgzRnIugxF+TisTSUnvTA9V8Z6KV8gfhr4N/nS45hPs/lEs5c0IHHN9nb75H7QT8Ht7XB9S3xf6n6VsoXpvpWirGtMIZ5DMeQz0rg84ZlD4vWDNfY6emJD3/H61vkY/HbM+R5ZqHaPVHKM5I8jjV54oDvDx7wwBzD92ii/173TSzNnK6MuEfQ2vIzG8Qk+h8Ak+qYpzxat/PnYKOmuTBmM6c1fBYgB8p6lr/u6i35NNIPqbVwvXkM4D68ZmOY1/lexXMsroEjyEXzsbYdsn4/6h5rW6kOWwD+Tz28+2r7eQ/vvwDzZ/3b+nlht+WkG33XKXW53460vw3eb4n/gsk61n47Z/Jw+/D9VqpntsJYn48iHynWJKzZG9YHYZnOk16rv491b2by94lg1+f6+5uPvh5/l76nhvijxEf6xh0SV6/tXmLsuJLWzxRXUv0j1UbcT6Tvw6XA5w3LHpZUS98aV1KtcO1c+Rd4j/OGnisT/R+A+av+vRHm87qcZFHKfIa8UXLMSViuar8rkX7GZCf633Q/8h1I8BHgKoHXEHu4z7CH80x7EP3vzB5j3XdJ9iBeyys2keppU3xy26geG/KzfZzHzxpXBj6SXNI9BD/bQN6YN9aMDvm4Bj24rHc99ITH71X+1H2j++dOVz6cT3EtnVXg+dJZ3rrL90G/D25r4lkF+oJXyzZRypzHn7t+W3W5ZlM2ZjoLnwh8MEZM9zs0F3P7ZgDP1RWefbbou/vru9f6W/foTxwT9x5+Filh/gOYpjMzPFdsmgtjY/sh+g73Q9N9Y9O47TcCPZ6Lkc22jB5zvlSb8Bwj1Z9D/RDPz+h8a0y7H47v7w3Psmp88iPeXBhH+v/0M97xU3/LmVl1yMIqyqpsnxVFnGd832sa/r+fbf674zFJd6cgPhR5VcTRS/PP98kpj/dZUIZncV6afxIn4fGYHfMkr9I4P724/mlSpVF0CqO0KNMwucaf4vWubscxjzVtpp/pjprTYx2P9PcaoInLLcuVnsCvofvMQOf09GcM4Z1bd9/59SX9tL6kf7ozqi9lpLEljGGObdpKP6O9EIvk8Bj9p1DzNG0Oc2j+VuA/Z/w7cgvvMMdzrKnwDvf5T/Qk8lvU3fa5xJknw8d3XDbynTHi6jGlHPLsEIZpHJZxuL8WV+8ArDE1jqkwAAA=", - "debug_symbols": "pZfRbtswDEX/xc95kCiJovorQ1GkbToECNIiSwYMRf59pKnrrA8OBvWl9zgpT2RZlODP6XX3fPn5tD++vf+aHn58Ts+n/eGw//l0eH/ZnvfvR/30cwr2J6bpIW6mmD2KB3tUD/Foc1DwiB7k4RZyC7mF3EJuIbeQW5JbkluSW5JbkluSW5Jaskb1EI82R9YPy2YqKmON6EEeySN7FA/20LqqIR5tDlaLaGhd02CP6iEebY4aPKIHeXhdzR5eXu3e9Saq3TxpNk8JPe3+kyb1TD1tCvQGpfTknrWn9GyeLfSMPaln6tl9rfta97Xua93Xui+GAIgAApizGGRAATCgAgTQOsQAiAAzs0ECZEABMKACBNA6zCuzGkQAARKAAValjzvOK3GGCCBAAmRAATCgAgQAc4Y5w5xhzjBnmDPMGWZb3BQMBNA62IJ3iAACJEAGFAADYC4wF5gZZoaZYWaYGWaGmWG2dqF5AxFA62BN4xABBEiADCgABsBcYa4wC8wCs8AsMAvMArPAbD1EZPubVSUDq7Klbm3jYFW2Vq1xHCpAAOZh2yADwMZTDQiQABlgQjGoAAG0DtYy1AwigAAqTMEgAwqAARUgfoNkLTODtYxDBBAgATKgABignjRv/+pJZBABBEiADCgABtgITWhN5NA6WBM5RAABEiADzJyu182Eg+7pfNrt7Jz75+TT8/Bje9odz9PD8XI4bKbf28Nl/qdfH9vjnOftSb/VOdsdXzVV+LY/7Iyum1t1WC+N9nTmYt1glvLy//WZUc91rZ7W6zNh8DnTWn1arxdbnHO9kIzUL+OXXEfqK8YvEkfqefl9Gbr/hvoWRn6/2Zbg9TmNPD9Znl9ra/Xx3gIKLFhBocqQQs98KPSQHlTEm2LsRvSMXBS5jCnkphicTj1GF4WEIQUtPRl1NxvYFChiMmn9cdyrz0t9XW3K2NYFHLEgOKYhwTKLXHhIULGv8p2ncE/QMAc15JE5bJiCFOI363mgPi2LKFH7Xn3KIxNYA06GGsuQIGJjqil+cwR3BHc7UZZmJuExBd+aWQZHUdJN8bWfH/Vq+7I/fXlhv5rrtN8+H3b98u1yfPnn2/OfD3yDF/6P0/vL7vVy2pnp9tavf36QHpEk9dFezuwyy0ZHZJfRLkvWS3682mD+Ag==", + "bytecode": "H4sIAAAAAAAA/+1ay47rRBBtJ/YkzmMSgdghgcQHYMeOE68YIVaIn3D82CHxAQiZD0Nixwr2fAALFuzZgO44t2t8XCl3PDft0SympVHH7upTj66qLnePo9rm6N5VNzQC+UL/8PXzBManj38P+jm4rYU+42sT/xjEsS/oZ1H+yNeYzjj4AeGPZP9gpnG+qVt81IX4zh//lvB7pVr/GEt/Wr8x9f/YoPNS6/ov0xVlcW+RJauSKi+zMDtkp12R+6CfFfwyD/IsyIOsyMton/qAaQX/uC+i6pDnu8cfZbQjfM8WflHsd3mcZVFVlGmUEP6dLXxoSVVmhD8bAb9pa405V21zmG9hPrTo5weH8VOq62eK8V8wWW3nfYfxI3m4fSjWyHYLQdatMIYximPIZyHwkbCmFrFci1ieRaw7i1gUP7RmE5jn9PTEh7+juVJutLkPbJW8zyBvdxzeiZQ3LeLvpbyplN0abrzcFT3ti4tx7BOSn/IaRmmbfQnvmz+qgzzVxgbOdWEc6XeA+V0PpgOYPL7x9wqwJBk8JgPRJ7pvcuz/PZio19KgF9GngOk4Xcy1apspvxP9vUC/BhqSZ8NkwLmct6dl53v7iulD9F/rvrHtVwxzKciHdicflXxqCbjcp4huAri+MNcX9LaZB0kWWiMX5FkJ8niM/lum1z3YamqwCV8z5Ivr6jO+a8a3kcPVDKScTrwxBjdMB2nORNBjLsjFY2koPemB678y0Ev5AvHXwL/PlxzDfJ7LJZy5oAOPb7K33yP3g34ObmuD61vi/1L1rZQvTPWtFGNbYQzzGI4hn5XA5w3LHhatGa6x09MTH/6O17fIx+K3Z8jzzEK1e6KUZyR5HGvyxAHfHzzggTmG79FE/73um1iaOV0ZcY+gteVnNohJ9D8AJtUxT3m0bufPwUZNc2HMZk5r+CxADpT1LH/d1VvyaaQfUmvhevMYwH14zcYwr/O9iudYXANHkIvmY207ZP1+1D3WtlIdtgD8n3p499X28x7efwHmz/q39fPCbstJN/quU+pyvx1pfxu83xL/BZN1rP12zuTh9uH7rVTPbIWxPh9FPlKsSVizN6wPwjKdJ71Wfx/r3szk7xPBrs/19zcffT3+Ln1PDfFHiY/0jTskrl7bvcTYcSWtnymupPpHqo24n0jfh0uBzxuWPSyplr41rqRa4dq58i/wHucNPVcm+j8A81f9eyPM53U5yaKU+Qx5o+SYk7Bc1X5XIv2MyU70v+l+5DuQ4CPAVQKvIfZwn2EP55n2IPrfmT3Guu+S7EG8lldsItXTpvjktlE9NuRn+ziPnzWuDHwkuaR7CH62gbwxb6wZHfJxDXpwWe966AmP36v8qftG98+drnw4n+JaOqvA86WzvHWX74N+H9zWxLMK9AWvlm2ilDmPP3f9tupyzaZszHQWPhH4YIyY7ndorpTb/Su4XN9r93v8HoTo/9a95DPS2TK3L+49aCe+9xD9P8DPdGaG/y/WNBfGxvZD9B3uh6b7xqbxddkI9NL91JbRY86XahOeY675i8kP8fyMzrfGtPvh+P7e8Cyrxic/4s2FcaT/Tz/jHT/1t5yZVYcsrKKsyvZZUcR5xve9puH/+9nmvzsek3R3CuJDkVdFHL00/3yfnPJ4nwVleBbnpfkncRIej9kxT/IqjfPTi+ufJlUaRacwSosyDZNr/Cle7+p2HPNY02b6me6oOT3W8Uh/rwGauNyyXOkJ/Bq6zwx0Tk9/xhDeuXX3nV9f0k/rS/qnO6P6UkYaW8IY5timrfQz2guxSA6P0X8K+1fT5jCH5m8F/nPGvyO38A5zPMeaCu9wn/9ETyK/Rd1tn0uceTJ8fMdlI98ZI64eU8ohzw5hmMZhGYf7a3H1DtKjsuKpMAAA", + "debug_symbols": "pZfRbtswDEX/xc95kCiJovorQ1GkbToECNIiSwYMRf59pKnrrA8OBvWl9zgpT2RZlODP6XX3fPn5tD++vf+aHn58Ts+n/eGw//l0eH/ZnvfvR/30cwr2J6bpIW6mmD2KB3tUD/Foc1DwiB7k4RZyC7mF3EJuIbeQW5JbkluSW5JbkluSW5Jaskb1EI82R9YPy2YqKmON6EEeySN7FA/20LqqIR5tDlaLaGhd02CP6iEebY4aPKIHeXhdzR5eXu3e9Saq3TxpNk8JPe3+kyb1TD1tCvQGpfTknrWn9GyeLfSMPaln6tl9rfta97Xua93Xui+GAIgAApizGGRAATCgAgTQOsQAiAAzs0ECZEABMKACBNA6zCuzGkQAARKAAValjzvOK3GGCCBAAmRAATCgAgQAc4Y5w5xhzjBnmDPMGWZb3BQMBNA62IJ3iAACJEAGFAADYC4wF5gZZoaZYWaYGWaGmWG2dqF5AxFA62BN4xABBEiADCgABsBcYa4wC8wCs8AsMAvMArPAbD1EZPubVSUDq7Klbm3jYFW2Vq1xHCpAAOZh2yADwMZTDQiQABlgQjGoAAG0DtYy1AwigAAqTMEgAwqAARUgfoNkLTODtYxDBBAgATKgABignjRv/wEQAQSwEZJBBhQAA2yEJrQmcmgdrIkcIoAACZABZk7X62bCQfd0Pu12ds79c/LpefixPe2O5+nheDkcNtPv7eEy/9Ovj+1xzvP2pN/qnO2Or5oqfNsfdkbXza06rJdGezpzsW4wS3n5//rMqOe6Vk/r9Zkw+JxprT6t14stzrleSEbql/FLriP1FeMXiSP1vPy+DN1/Q30LI7/fbEvw+pxGnp8sz6+1tfp4bwEFFqygUGVIoWc+FHpIDyriTTF2I3pGLopcxhRyUwxOpx6ji0LCkIKWnoy6mw1sChQxmbT+OO7V56W+rjZlbOsCjlgQHNOQYJlFLjwkqNhX+c5TuCdomIMa8sgcNkxBCvGb9TxQn5ZFlKh9rz7lkQmsASdDjWVIELEx1RS/OYI7grudyLdOlEGFlJuCxxQl3RRf+/lRr7Yv+9OXF/aruU777fNh1y/fLseXf749//nAN3jh/zi9v+xeL6edmW5v/frnB+kRSVIf7eXMLrNsdER2Ge2yZL3kx6sN5i8=", "file_map": { "50": { "source": "fn main() {\n let numerator =\n [790096867046896348, 1063071665130103641, 602707730209562162, 996751591622961462, 28650, 0];\n unsafe { __udiv_mod(numerator) };\n\n let denominator = [12, 0, 0, 0, 0, 0];\n let result = unsafe { __validate_gt_remainder(denominator) };\n assert(result[4] == 0);\n assert(result[5] == 0);\n}\n\nunconstrained fn __udiv_mod(remainder_u60: [u64; 6]) {\n let bit_difference = get_msb(remainder_u60);\n let accumulator_u60: [u64; 6] = shl(bit_difference);\n}\n\nunconstrained fn __validate_gt_remainder(a_u60: [u64; 6]) -> [u64; 6] {\n let mut addend_u60: [u64; 6] = [0; 6];\n let mut result_u60: [u64; 6] = [0; 6];\n\n for i in 0..6 {\n result_u60[i] = a_u60[i] + addend_u60[i];\n }\n\n result_u60\n}\n\nunconstrained fn get_msb(val: [u64; 6]) -> u32 {\n let mut count = 0;\n for i in 0..6 {\n let v = val[(6 - 1) - i];\n if (v > 0) {\n count = 60 * ((6 - 1) - i);\n break;\n }\n }\n count\n}\n\nunconstrained fn shl(shift: u32) -> [u64; 6] {\n let num_shifted_limbs = shift / 60;\n let limb_shift = (shift % 60) as u8;\n\n let mut result = [0; 6];\n result[num_shifted_limbs] = (1 << limb_shift);\n\n for i in 1..(6 - num_shifted_limbs) {\n result[i + num_shifted_limbs] = 0;\n }\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 2957bb36011..d3e5fae2091 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_bignum/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -35,8 +35,8 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1ay47rRBBtJ/YkzmMSgdghgcQHYMeOE68YIVaIn3D82CHxAQiZD0Nixwr2fAAbJPZsQHec2zU+rpQ7npv2aBbT0qhjd/WpR1dVl7vHUW1zdO+qGxqBfKF/+Pp5AuPTx78H/Rzc1kKf8bWJfwzi2Bf0syh/5GtMZxz8gPBHsn8w0zjf1C0+6kJ8549/S/i9Uq1/jKU/rd+Y+n9s0Hmpdf2X6YqyuLfIklVJlZdZmB2y067IfdDPCn6ZB3kW5EFW5GW0T33AtIJ/3BdRdcjz3eOPMtoRvmcLvyj2uzzOsqgqyjRKCP/OFj60pCozwp+NgN+0tcacq7Y5zLcwH1r084PD+CnV9TPF+C+YrLbzvsP4kTzcPhRrZLuFIOtWGMMYxTHksxD4SFhTi1iuRSzPItadRSyKH1qzCcxzenriw9/RXCk32twHtkreZ5C3Ow7vRMqbFvH3Ut5Uym4NN17uip72xcU49gnJT3kNo7TNvoT3zR/VQZ5qYwPnujCO9DvA/K4H0wFMHt/4ewVYkgwek4HoE903Ofb/HkzUa2nQi+hTwHScLuZatc2U34n+XqBfAw3Js2Ey4FzO29Oy8719xfQh+q9139j2K4a5FORDu5OPSj61BFzuU0Q3AVxfmOsLetvMgyQLrZEL8qwEeTxG/y3T6x5sNTXYhK8Z8sV19RnfNePbyOFqBlJOJ94YgxumgzRnIugxF+TisTSUnvTA9V8Z6KV8gfhr4N/nS45hPs/lEs5c0IHHN9nb75H7QT8Ht7XB9S3xf6n6VsoXpvpWirGtMIZ5DMeQz0rg84ZlD4vWDNfY6emJD3/H61vkY/HbM+R5ZqHaPVHKM5I8jjV54oDvDx7wwBzD92ii/173TSzNnK6MuEfQ2vIzG8Qk+h8Ak+qYpzxat/PnYKOmuTBmM6c1fBYgB8p6lr/u6i35NNIPqbVwvXkM4D68ZmOY1/lexXMsroEjyEXzsbYdsn4/6h5rW6kOWwD+Tz28+2r7eQ/vvwDzZ/3b+nlht+WkG33XKXW53460vw3eb4n/gsk61n47Z/Jw+/D9VqpntsJYn48iHynWJKzZG9YHYZnOk16rv491b2by94lg1+f6+5uPvh5/l76nhvijxEf6xh0SV6/tXmLsuJLWzxRXUv0j1UbcT6Tvw6XA5w3LHpZUS98aV1KtcO1c+Rd4j/OGnisT/R+A+av+vRHm87qcZFHKfIa8UXLMSViuar8rkX7GZCf633Q/8h1I8BHgKoHXEHu4z7CH80x7EP3vzB5j3XdJ9iBeyys2keppU3xy26geG/KzfZzHzxpXBj6SXNI9BD/bQN6YN9aMDvm4Bj24rHc99ITH71X+1H2j++dOVz6cT3EtnVXg+dJZ3rrL90G/D25r4lkF+oJXyzZRypzHn7t+W3W5ZlM2ZjoLnwh8MEZM9zs0F3P7ZgDP1RWefbbou/vru9f6W/foTxwT9x5+Filh/gOYpjMzPFdsmgtjY/sh+g73Q9N9Y9O47TcCPZ6Lkc22jB5zvlSb8Bwj1Z9D/RDPz+h8a0y7H47v7w3Psmp88iPeXBhH+v/0M97xU3/LmVl1yMIqyqpsnxVFnGd832sa/r+fbf674zFJd6cgPhR5VcTRS/PP98kpj/dZUIZncV6afxIn4fGYHfMkr9I4P724/mlSpVF0CqO0KNMwucaf4vWubscxjzVtpp/pjprTYx2P9PcaoInLLcuVnsCvofvMQOf09GcM4Z1bd9/59SX9tL6kf7ozqi9lpLEljGGObdpKP6O9EIvk8Bj9p1DzNG0Oc2j+VuA/Z/w7cgvvMMdzrKnwDvf5T/Qk8lvU3fa5xJknw8d3XDbynTHi6jGlHPLsEIZpHJZxuL8WV+8ArDE1jqkwAAA=", - "debug_symbols": "pZfRbtswDEX/xc95kCiJovorQ1GkbToECNIiSwYMRf59pKnrrA8OBvWl9zgpT2RZlODP6XX3fPn5tD++vf+aHn58Ts+n/eGw//l0eH/ZnvfvR/30cwr2J6bpIW6mmD2KB3tUD/Foc1DwiB7k4RZyC7mF3EJuIbeQW5JbkluSW5JbkluSW5Jaskb1EI82R9YPy2YqKmON6EEeySN7FA/20LqqIR5tDlaLaGhd02CP6iEebY4aPKIHeXhdzR5eXu3e9Saq3TxpNk8JPe3+kyb1TD1tCvQGpfTknrWn9GyeLfSMPaln6tl9rfta97Xua93Xui+GAIgAApizGGRAATCgAgTQOsQAiAAzs0ECZEABMKACBNA6zCuzGkQAARKAAValjzvOK3GGCCBAAmRAATCgAgQAc4Y5w5xhzjBnmDPMGWZb3BQMBNA62IJ3iAACJEAGFAADYC4wF5gZZoaZYWaYGWaGmWG2dqF5AxFA62BN4xABBEiADCgABsBcYa4wC8wCs8AsMAvMArPAbD1EZPubVSUDq7Klbm3jYFW2Vq1xHCpAAOZh2yADwMZTDQiQABlgQjGoAAG0DtYy1AwigAAqTMEgAwqAARUgfoNkLTODtYxDBBAgATKgABignjRv/+pJZBABBEiADCgABtgITWhN5NA6WBM5RAABEiADzJyu182Eg+7pfNrt7Jz75+TT8/Bje9odz9PD8XI4bKbf28Nl/qdfH9vjnOftSb/VOdsdXzVV+LY/7Iyum1t1WC+N9nTmYt1glvLy//WZUc91rZ7W6zNh8DnTWn1arxdbnHO9kIzUL+OXXEfqK8YvEkfqefl9Gbr/hvoWRn6/2Zbg9TmNPD9Znl9ra/Xx3gIKLFhBocqQQs98KPSQHlTEm2LsRvSMXBS5jCnkphicTj1GF4WEIQUtPRl1NxvYFChiMmn9cdyrz0t9XW3K2NYFHLEgOKYhwTKLXHhIULGv8p2ncE/QMAc15JE5bJiCFOI363mgPi2LKFH7Xn3KIxNYA06GGsuQIGJjqil+cwR3BHc7UZZmJuExBd+aWQZHUdJN8bWfH/Vq+7I/fXlhv5rrtN8+H3b98u1yfPnn2/OfD3yDF/6P0/vL7vVy2pnp9tavf36QHpEk9dFezuwyy0ZHZJfRLkvWS3682mD+Ag==", + "bytecode": "H4sIAAAAAAAA/+1ay47rRBBtJ/YkzmMSgdghgcQHYMeOE68YIVaIn3D82CHxAQiZD0Nixwr2fAALFuzZgO44t2t8XCl3PDft0SympVHH7upTj66qLnePo9rm6N5VNzQC+UL/8PXzBManj38P+jm4rYU+42sT/xjEsS/oZ1H+yNeYzjj4AeGPZP9gpnG+qVt81IX4zh//lvB7pVr/GEt/Wr8x9f/YoPNS6/ov0xVlcW+RJauSKi+zMDtkp12R+6CfFfwyD/IsyIOsyMton/qAaQX/uC+i6pDnu8cfZbQjfM8WflHsd3mcZVFVlGmUEP6dLXxoSVVmhD8bAb9pa405V21zmG9hPrTo5weH8VOq62eK8V8wWW3nfYfxI3m4fSjWyHYLQdatMIYximPIZyHwkbCmFrFci1ieRaw7i1gUP7RmE5jn9PTEh7+juVJutLkPbJW8zyBvdxzeiZQ3LeLvpbyplN0abrzcFT3ti4tx7BOSn/IaRmmbfQnvmz+qgzzVxgbOdWEc6XeA+V0PpgOYPL7x9wqwJBk8JgPRJ7pvcuz/PZio19KgF9GngOk4Xcy1apspvxP9vUC/BhqSZ8NkwLmct6dl53v7iulD9F/rvrHtVwxzKciHdicflXxqCbjcp4huAri+MNcX9LaZB0kWWiMX5FkJ8niM/lum1z3YamqwCV8z5Ivr6jO+a8a3kcPVDKScTrwxBjdMB2nORNBjLsjFY2koPemB678y0Ev5AvHXwL/PlxzDfJ7LJZy5oAOPb7K33yP3g34ObmuD61vi/1L1rZQvTPWtFGNbYQzzGI4hn5XA5w3LHhatGa6x09MTH/6O17fIx+K3Z8jzzEK1e6KUZyR5HGvyxAHfHzzggTmG79FE/73um1iaOV0ZcY+gteVnNohJ9D8AJtUxT3m0bufPwUZNc2HMZk5r+CxADpT1LH/d1VvyaaQfUmvhevMYwH14zcYwr/O9iudYXANHkIvmY207ZP1+1D3WtlIdtgD8n3p499X28x7efwHmz/q39fPCbstJN/quU+pyvx1pfxu83xL/BZN1rP12zuTh9uH7rVTPbIWxPh9FPlKsSVizN6wPwjKdJ71Wfx/r3szk7xPBrs/19zcffT3+Ln1PDfFHiY/0jTskrl7bvcTYcSWtnymupPpHqo24n0jfh0uBzxuWPSyplr41rqRa4dq58i/wHucNPVcm+j8A81f9eyPM53U5yaKU+Qx5o+SYk7Bc1X5XIv2MyU70v+l+5DuQ4CPAVQKvIfZwn2EP55n2IPrfmT3Guu+S7EG8lldsItXTpvjktlE9NuRn+ziPnzWuDHwkuaR7CH62gbwxb6wZHfJxDXpwWe966AmP36v8qftG98+drnw4n+JaOqvA86WzvHWX74N+H9zWxLMK9AWvlm2ilDmPP3f9tupyzaZszHQWPhH4YIyY7ndorpTb/Su4XN9r93v8HoTo/9a95DPS2TK3L+49aCe+9xD9P8DPdGaG/y/WNBfGxvZD9B3uh6b7xqbxddkI9NL91JbRY86XahOeY675i8kP8fyMzrfGtPvh+P7e8Cyrxic/4s2FcaT/Tz/jHT/1t5yZVYcsrKKsyvZZUcR5xve9puH/+9nmvzsek3R3CuJDkVdFHL00/3yfnPJ4nwVleBbnpfkncRIej9kxT/IqjfPTi+ufJlUaRacwSosyDZNr/Cle7+p2HPNY02b6me6oOT3W8Uh/rwGauNyyXOkJ/Bq6zwx0Tk9/xhDeuXX3nV9f0k/rS/qnO6P6UkYaW8IY5timrfQz2guxSA6P0X8K+1fT5jCH5m8F/nPGvyO38A5zPMeaCu9wn/9ETyK/Rd1tn0uceTJ8fMdlI98ZI64eU8ohzw5hmMZhGYf7a3H1DtKjsuKpMAAA", + "debug_symbols": "pZfRbtswDEX/xc95kCiJovorQ1GkbToECNIiSwYMRf59pKnrrA8OBvWl9zgpT2RZlODP6XX3fPn5tD++vf+aHn58Ts+n/eGw//l0eH/ZnvfvR/30cwr2J6bpIW6mmD2KB3tUD/Foc1DwiB7k4RZyC7mF3EJuIbeQW5JbkluSW5JbkluSW5Jaskb1EI82R9YPy2YqKmON6EEeySN7FA/20LqqIR5tDlaLaGhd02CP6iEebY4aPKIHeXhdzR5eXu3e9Saq3TxpNk8JPe3+kyb1TD1tCvQGpfTknrWn9GyeLfSMPaln6tl9rfta97Xua93Xui+GAIgAApizGGRAATCgAgTQOsQAiAAzs0ECZEABMKACBNA6zCuzGkQAARKAAValjzvOK3GGCCBAAmRAATCgAgQAc4Y5w5xhzjBnmDPMGWZb3BQMBNA62IJ3iAACJEAGFAADYC4wF5gZZoaZYWaYGWaGmWG2dqF5AxFA62BN4xABBEiADCgABsBcYa4wC8wCs8AsMAvMArPAbD1EZPubVSUDq7Klbm3jYFW2Vq1xHCpAAOZh2yADwMZTDQiQABlgQjGoAAG0DtYy1AwigAAqTMEgAwqAARUgfoNkLTODtYxDBBAgATKgABignjRv/wEQAQSwEZJBBhQAA2yEJrQmcmgdrIkcIoAACZABZk7X62bCQfd0Pu12ds79c/LpefixPe2O5+nheDkcNtPv7eEy/9Ovj+1xzvP2pN/qnO2Or5oqfNsfdkbXza06rJdGezpzsW4wS3n5//rMqOe6Vk/r9Zkw+JxprT6t14stzrleSEbql/FLriP1FeMXiSP1vPy+DN1/Q30LI7/fbEvw+pxGnp8sz6+1tfp4bwEFFqygUGVIoWc+FHpIDyriTTF2I3pGLopcxhRyUwxOpx6ji0LCkIKWnoy6mw1sChQxmbT+OO7V56W+rjZlbOsCjlgQHNOQYJlFLjwkqNhX+c5TuCdomIMa8sgcNkxBCvGb9TxQn5ZFlKh9rz7lkQmsASdDjWVIELEx1RS/OYI7grudyLdOlEGFlJuCxxQl3RRf+/lRr7Yv+9OXF/aruU777fNh1y/fLseXf749//nAN3jh/zi9v+xeL6edmW5v/frnB+kRSVIf7eXMLrNsdER2Ge2yZL3kx6sN5i8=", "file_map": { "50": { "source": "fn main() {\n let numerator =\n [790096867046896348, 1063071665130103641, 602707730209562162, 996751591622961462, 28650, 0];\n unsafe { __udiv_mod(numerator) };\n\n let denominator = [12, 0, 0, 0, 0, 0];\n let result = unsafe { __validate_gt_remainder(denominator) };\n assert(result[4] == 0);\n assert(result[5] == 0);\n}\n\nunconstrained fn __udiv_mod(remainder_u60: [u64; 6]) {\n let bit_difference = get_msb(remainder_u60);\n let accumulator_u60: [u64; 6] = shl(bit_difference);\n}\n\nunconstrained fn __validate_gt_remainder(a_u60: [u64; 6]) -> [u64; 6] {\n let mut addend_u60: [u64; 6] = [0; 6];\n let mut result_u60: [u64; 6] = [0; 6];\n\n for i in 0..6 {\n result_u60[i] = a_u60[i] + addend_u60[i];\n }\n\n result_u60\n}\n\nunconstrained fn get_msb(val: [u64; 6]) -> u32 {\n let mut count = 0;\n for i in 0..6 {\n let v = val[(6 - 1) - i];\n if (v > 0) {\n count = 60 * ((6 - 1) - i);\n break;\n }\n }\n count\n}\n\nunconstrained fn shl(shift: u32) -> [u64; 6] {\n let num_shifted_limbs = shift / 60;\n let limb_shift = (shift % 60) as u8;\n\n let mut result = [0; 6];\n result[num_shifted_limbs] = (1 << limb_shift);\n\n for i in 1..(6 - num_shifted_limbs) {\n result[i + num_shifted_limbs] = 0;\n }\n result\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 30a5ca5422f..a9913942b43 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/9Va23LaMBBdY9LcmjRtyI06xLSQtikPFhgwb/mOvsEEXvqb7W/0WyqBNtUIkWnw2Rm8MzuLbbGcPbtaWcYRraSn9cF+jrXWtF7Y48gem/N1rXta32jd13qg9VDrkdZjrW+1nmg91fpO65nW91o/aD3X2nD8ulKz9tHaQTbK8/m4P1cDNc36k1kxzPLhbFSoQg2L4VO/GAzmRV6MJ7PJOJuofDBXi+FksMhW4vrKyomKcL6yuhevK5HHQVZOFNBXFoBb1rfiDy4Xl9ZeMSGxtebCH++cGZR6oGJBErcsyr4tSnVJuAK/IpnkoiciMubrQMzb+nTr6NrWVt0eR7QukSAviFhYbiQB3wQKpCz4G8JN1iZhVxAJDpu0udNv679J2GaAjvvKxr2pdl4r7BeZ749ADt3mYvy2adVciP5v5d+BxYFX52kArsjKn1h7y4QwgQn968p8zgxKPVCxIIllV/4EiOsWmNyq3Y4uljJXAbgiRdmy9o4J4QJs0XpRmkGpB2qXb0dbhCvKO3By0cWXODkjYNwt2u2V1/hIhOswKydTZHNMAb7mq0Icm0YQaoyguJ+3XehaTyuAsY3EGNsCdx8sST2wkmhMbcLtu1fFO3lCTqpPsHhHOefFFxSfUnlKafcnFS5P3gM/9Kr0GQhUuKDEkoXkQApjB4mxonuNGeGLK7jX6Fp7z4TwvqJL63sNMyj1QO3yXqNLuO5xD04uurslTjKB+QjuD7JyssxxIsDBF8J2+CrehyM5kML4FY1RYjIZkNjmNsoTIRLLxvuNKjNxxO61qzBxkHmiqna4KtzDPghgXAr6n3Lkjv07YWc56o871ycyXuOrI4CzA8TYAxciOlbDIXCyKFODPZJ5pI3i0WDjfank626hN0rchn/xfO7s9Mevn7/dce0N1/j7B9YeWnvkxBHjuOqz/2MZ/9k+rcuR8/mYwvzVA9+LNhzXPPvS2JfeAjoJXGOf59a6eDmOQ8+6NQfkUrH/hoz/YK7cp+QNL06X70cQBvbHO4M9Wpead43H+nMmwuNb+486DvwWC9dMwznHfP4F9G5wVqMrAAA=", - "debug_symbols": "pZTbisMgEED/xec8eNf0V5al2NSWgJhgk8JS+u87cbTbPiwU+zInUc/IeLuRoz+s5/0YT9OF7L5u5JDGEMbzPkyDW8YpQuvt3pH6u1+S99BEnvrBml3ycSG7uIbQkasLax50mV3MXFyCXtoRH49ASHgag9++7t2fTf9XhZBFFtI+dPW+b1j1e9ngS26KL3nL/JLJh99/5kvW4Guliq8N/dBXLX7fF98w3uJb/fBFg2903T/TVL+RvPq65fwYW+u3TL/43/DnhjG93DhCyQ4mZDCkIxzK74jIUeaoctQ5mhxtjn2OjCIYAnUGPiwBkwiF0AjIYQEW0WdwimAIyAIVcIGQCIXQCIOwCMjCYEEELWSFvFAUQioGd1OoQl1oCm1hj5S0cMu3naSrS6M7BF8eqtMah6d3a/mZa0992eY0Df64Jr+teO6DPfgF", + "debug_symbols": "pZTbjoMgEED/hWcfGO72VzabhlramBA1VJtsmv77jjD28rDJhr7MUeEMMlxu7BgOy3nfD6fxwnZfN3ZIfYz9eR/Hzs/9OODX271h2+t+TiHgJ/bSjtbkUxhmthuWGBt29XHJnS6THzJnn7CVNywMRyQmPPUxrE/35mnzv1UpFclSuYeu/+9b2PxWVfhKWPKVqBlfgXr47We+ggrfaE2+sfxDX9f4bUu+BVHhWzAPv6Z+xj19WTO+2dbfVtXPKrH5pmb/WbfVz4F587/xzXd9ejuxjLMdDgjYpWECp98wmaPKUedocrQ5uhzbHIEXQEHRAX0sAagCXWAKMAf+HriCNkPwAijALIDzE5KoiJpoiJboiJgM8OhKTgSiIErimg9nLDXREC3REdtCxYlrvnVDXH3q/SEGuu9Oy9C9XH/zz7S1bBfklMYuHJcU1sLnNlyKXw==", "file_map": { "50": { "source": "// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631\n// for context.\n// We were not accurately accounting for situations where the slice capacity tracker\n// was expecting a capacity from slice intrinsic results.\nfn main(expected: pub Field, first: Field, input: [Field; 20]) {\n let mut hasher_slice = input.as_slice();\n hasher_slice = hasher_slice.push_front(first);\n assert(hasher_slice[0] == expected);\n // We need a conditional based upon witnesses\n // to force a store of the slice.\n // If this successfully compiles it means we have stored\n // the results of the slice intrinsics used above.\n if expected as u32 > 10 {\n hasher_slice[expected - 10] = 100;\n } else {\n hasher_slice[expected] = 100;\n }\n assert(hasher_slice[0] == expected);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_0.snap index 30a5ca5422f..a9913942b43 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_0.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/9Va23LaMBBdY9LcmjRtyI06xLSQtikPFhgwb/mOvsEEXvqb7W/0WyqBNtUIkWnw2Rm8MzuLbbGcPbtaWcYRraSn9cF+jrXWtF7Y48gem/N1rXta32jd13qg9VDrkdZjrW+1nmg91fpO65nW91o/aD3X2nD8ulKz9tHaQTbK8/m4P1cDNc36k1kxzPLhbFSoQg2L4VO/GAzmRV6MJ7PJOJuofDBXi+FksMhW4vrKyomKcL6yuhevK5HHQVZOFNBXFoBb1rfiDy4Xl9ZeMSGxtebCH++cGZR6oGJBErcsyr4tSnVJuAK/IpnkoiciMubrQMzb+nTr6NrWVt0eR7QukSAviFhYbiQB3wQKpCz4G8JN1iZhVxAJDpu0udNv679J2GaAjvvKxr2pdl4r7BeZ749ADt3mYvy2adVciP5v5d+BxYFX52kArsjKn1h7y4QwgQn968p8zgxKPVCxIIllV/4EiOsWmNyq3Y4uljJXAbgiRdmy9o4J4QJs0XpRmkGpB2qXb0dbhCvKO3By0cWXODkjYNwt2u2V1/hIhOswKydTZHNMAb7mq0Icm0YQaoyguJ+3XehaTyuAsY3EGNsCdx8sST2wkmhMbcLtu1fFO3lCTqpPsHhHOefFFxSfUnlKafcnFS5P3gM/9Kr0GQhUuKDEkoXkQApjB4mxonuNGeGLK7jX6Fp7z4TwvqJL63sNMyj1QO3yXqNLuO5xD04uurslTjKB+QjuD7JyssxxIsDBF8J2+CrehyM5kML4FY1RYjIZkNjmNsoTIRLLxvuNKjNxxO61qzBxkHmiqna4KtzDPghgXAr6n3Lkjv07YWc56o871ycyXuOrI4CzA8TYAxciOlbDIXCyKFODPZJ5pI3i0WDjfank626hN0rchn/xfO7s9Mevn7/dce0N1/j7B9YeWnvkxBHjuOqz/2MZ/9k+rcuR8/mYwvzVA9+LNhzXPPvS2JfeAjoJXGOf59a6eDmOQ8+6NQfkUrH/hoz/YK7cp+QNL06X70cQBvbHO4M9Wpead43H+nMmwuNb+486DvwWC9dMwznHfP4F9G5wVqMrAAA=", - "debug_symbols": "pZTbisMgEED/xec8eNf0V5al2NSWgJhgk8JS+u87cbTbPiwU+zInUc/IeLuRoz+s5/0YT9OF7L5u5JDGEMbzPkyDW8YpQuvt3pH6u1+S99BEnvrBml3ycSG7uIbQkasLax50mV3MXFyCXtoRH49ASHgag9++7t2fTf9XhZBFFtI+dPW+b1j1e9ngS26KL3nL/JLJh99/5kvW4Guliq8N/dBXLX7fF98w3uJb/fBFg2903T/TVL+RvPq65fwYW+u3TL/43/DnhjG93DhCyQ4mZDCkIxzK74jIUeaoctQ5mhxtjn2OjCIYAnUGPiwBkwiF0AjIYQEW0WdwimAIyAIVcIGQCIXQCIOwCMjCYEEELWSFvFAUQioGd1OoQl1oCm1hj5S0cMu3naSrS6M7BF8eqtMah6d3a/mZa0992eY0Df64Jr+teO6DPfgF", + "debug_symbols": "pZTbjoMgEED/hWcfGO72VzabhlramBA1VJtsmv77jjD28rDJhr7MUeEMMlxu7BgOy3nfD6fxwnZfN3ZIfYz9eR/Hzs/9OODX271h2+t+TiHgJ/bSjtbkUxhmthuWGBt29XHJnS6THzJnn7CVNywMRyQmPPUxrE/35mnzv1UpFclSuYeu/+9b2PxWVfhKWPKVqBlfgXr47We+ggrfaE2+sfxDX9f4bUu+BVHhWzAPv6Z+xj19WTO+2dbfVtXPKrH5pmb/WbfVz4F587/xzXd9ejuxjLMdDgjYpWECp98wmaPKUedocrQ5uhzbHIEXQEHRAX0sAagCXWAKMAf+HriCNkPwAijALIDzE5KoiJpoiJboiJgM8OhKTgSiIErimg9nLDXREC3REdtCxYlrvnVDXH3q/SEGuu9Oy9C9XH/zz7S1bBfklMYuHJcU1sLnNlyKXw==", "file_map": { "50": { "source": "// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631\n// for context.\n// We were not accurately accounting for situations where the slice capacity tracker\n// was expecting a capacity from slice intrinsic results.\nfn main(expected: pub Field, first: Field, input: [Field; 20]) {\n let mut hasher_slice = input.as_slice();\n hasher_slice = hasher_slice.push_front(first);\n assert(hasher_slice[0] == expected);\n // We need a conditional based upon witnesses\n // to force a store of the slice.\n // If this successfully compiles it means we have stored\n // the results of the slice intrinsics used above.\n if expected as u32 > 10 {\n hasher_slice[expected - 10] = 100;\n } else {\n hasher_slice[expected] = 100;\n }\n assert(hasher_slice[0] == expected);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 30a5ca5422f..a9913942b43 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -42,7 +42,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/9Va23LaMBBdY9LcmjRtyI06xLSQtikPFhgwb/mOvsEEXvqb7W/0WyqBNtUIkWnw2Rm8MzuLbbGcPbtaWcYRraSn9cF+jrXWtF7Y48gem/N1rXta32jd13qg9VDrkdZjrW+1nmg91fpO65nW91o/aD3X2nD8ulKz9tHaQTbK8/m4P1cDNc36k1kxzPLhbFSoQg2L4VO/GAzmRV6MJ7PJOJuofDBXi+FksMhW4vrKyomKcL6yuhevK5HHQVZOFNBXFoBb1rfiDy4Xl9ZeMSGxtebCH++cGZR6oGJBErcsyr4tSnVJuAK/IpnkoiciMubrQMzb+nTr6NrWVt0eR7QukSAviFhYbiQB3wQKpCz4G8JN1iZhVxAJDpu0udNv679J2GaAjvvKxr2pdl4r7BeZ749ADt3mYvy2adVciP5v5d+BxYFX52kArsjKn1h7y4QwgQn968p8zgxKPVCxIIllV/4EiOsWmNyq3Y4uljJXAbgiRdmy9o4J4QJs0XpRmkGpB2qXb0dbhCvKO3By0cWXODkjYNwt2u2V1/hIhOswKydTZHNMAb7mq0Icm0YQaoyguJ+3XehaTyuAsY3EGNsCdx8sST2wkmhMbcLtu1fFO3lCTqpPsHhHOefFFxSfUnlKafcnFS5P3gM/9Kr0GQhUuKDEkoXkQApjB4mxonuNGeGLK7jX6Fp7z4TwvqJL63sNMyj1QO3yXqNLuO5xD04uurslTjKB+QjuD7JyssxxIsDBF8J2+CrehyM5kML4FY1RYjIZkNjmNsoTIRLLxvuNKjNxxO61qzBxkHmiqna4KtzDPghgXAr6n3Lkjv07YWc56o871ycyXuOrI4CzA8TYAxciOlbDIXCyKFODPZJ5pI3i0WDjfank626hN0rchn/xfO7s9Mevn7/dce0N1/j7B9YeWnvkxBHjuOqz/2MZ/9k+rcuR8/mYwvzVA9+LNhzXPPvS2JfeAjoJXGOf59a6eDmOQ8+6NQfkUrH/hoz/YK7cp+QNL06X70cQBvbHO4M9Wpead43H+nMmwuNb+486DvwWC9dMwznHfP4F9G5wVqMrAAA=", - "debug_symbols": "pZTbisMgEED/xec8eNf0V5al2NSWgJhgk8JS+u87cbTbPiwU+zInUc/IeLuRoz+s5/0YT9OF7L5u5JDGEMbzPkyDW8YpQuvt3pH6u1+S99BEnvrBml3ycSG7uIbQkasLax50mV3MXFyCXtoRH49ASHgag9++7t2fTf9XhZBFFtI+dPW+b1j1e9ngS26KL3nL/JLJh99/5kvW4Guliq8N/dBXLX7fF98w3uJb/fBFg2903T/TVL+RvPq65fwYW+u3TL/43/DnhjG93DhCyQ4mZDCkIxzK74jIUeaoctQ5mhxtjn2OjCIYAnUGPiwBkwiF0AjIYQEW0WdwimAIyAIVcIGQCIXQCIOwCMjCYEEELWSFvFAUQioGd1OoQl1oCm1hj5S0cMu3naSrS6M7BF8eqtMah6d3a/mZa0992eY0Df64Jr+teO6DPfgF", + "debug_symbols": "pZTbjoMgEED/hWcfGO72VzabhlramBA1VJtsmv77jjD28rDJhr7MUeEMMlxu7BgOy3nfD6fxwnZfN3ZIfYz9eR/Hzs/9OODX271h2+t+TiHgJ/bSjtbkUxhmthuWGBt29XHJnS6THzJnn7CVNywMRyQmPPUxrE/35mnzv1UpFclSuYeu/+9b2PxWVfhKWPKVqBlfgXr47We+ggrfaE2+sfxDX9f4bUu+BVHhWzAPv6Z+xj19WTO+2dbfVtXPKrH5pmb/WbfVz4F587/xzXd9ejuxjLMdDgjYpWECp98wmaPKUedocrQ5uhzbHIEXQEHRAX0sAagCXWAKMAf+HriCNkPwAijALIDzE5KoiJpoiJboiJgM8OhKTgSiIErimg9nLDXREC3REdtCxYlrvnVDXH3q/SEGuu9Oy9C9XH/zz7S1bBfklMYuHJcU1sLnNlyKXw==", "file_map": { "50": { "source": "// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631\n// for context.\n// We were not accurately accounting for situations where the slice capacity tracker\n// was expecting a capacity from slice intrinsic results.\nfn main(expected: pub Field, first: Field, input: [Field; 20]) {\n let mut hasher_slice = input.as_slice();\n hasher_slice = hasher_slice.push_front(first);\n assert(hasher_slice[0] == expected);\n // We need a conditional based upon witnesses\n // to force a store of the slice.\n // If this successfully compiles it means we have stored\n // the results of the slice intrinsics used above.\n if expected as u32 > 10 {\n hasher_slice[expected - 10] = 100;\n } else {\n hasher_slice[expected] = 100;\n }\n assert(hasher_slice[0] == expected);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 550ecda59f2..eb82b4d70f0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -50,7 +50,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1aPY/bRhBdSkvxQ9aJZ98VAdIl6aWTdHflFUmfLmVAy7kqVdo0RNIkQPogRerkB6RKZxhwYbh2Z9g/xR7fzulxOKRke9fGAl7gsFzOcN7b2dnZIXWJuWmnr/8Sd21dPzbdxjpXrl+8X1t6tLUIyTPxyJNsnQT26yiAX31zHEfA0UbAMY2A4yQCjlkEHPMIOBYRcCwj4DiNgOOdCDjOIuB4FAHHeQQcqwg4HkfA8W4EHO9FwPEkAo6nATi+aadAmF5IqOCngpoKVioIqeCigoYKBjqQ6cCjA4USNiVESji0oWnDUEDSgp+Y9suq1lj20vWF60cg9/jysSwErk/7l4tNXSjz88h/VTibNoj95TnbT8PwX2TOztfNzj7OhXFnboyxw8+wbASyb5ysAM7+13cd2D/L9Uz4xIAPGHsSBnuTCDwj/GgEfmlCxuLNhxzEYz7SPxwHM9Zp2nxQZpvuPFiWgozXl3LeZ6AnY8uC3pdw/ZW75jULmW9wL/jer/cU/ohFLWvMbWPfjOEe+5X9nKO+kBUgs00bp3RjCzhoi3mkQv8LN567fgLP8POVgj8R+C3eyj3pl0LRLxR9isPP3fXU/VEM/crPmKD7fs3rix+Tx6a790aCTx6Ez2LFfDLT9p/0AePzvkxBP+np2ZaUMVZpgp5/y6G5pYqvK6EvfdBnK3tLWx9zTdHXuZhbruiPlblpuT8XMguyTMgw97NPhnI/62q9Md0YQ65z011H9kFhumvkM59Lv3Iu7YuLkemuC65JKu5duZ7Gv8Mzfee4ll8q040LGaehc2F+IFct7nAtqdkmBNebD8x/AI8EMKnhuUuyEmR8tlVChud7ZUyn3ilgbiHrjkT4MjW7dUDMfICP8ejrVPD51vWE/0hwCHR23OZQXMexWBfE1/IMPovj1OhnC8pY9zsx32mY+S7ugl0jsMamG7eyxh7vmb9mQ+aVsPlmUSdiXuke3pKP8cblfJ0KLj+6nrC+Fz6zA36XZ33a81wOctTfuh73lpZnC9B7DHqYB6jZpu27j1HjaDlr6KzBs5h9VinPT4QMczW+X/xs2j7A9+crP/OvjcJdxocV88R4kDXP+8bRT67/FEf+42hu9PMf+dg9/OU5pX1XkRzSHiyUse4vrg/7zVQ/pxhrasLWgReXN7XSGx83Oz9o/xBmQY76v7kxnoM4j6t35Hl9US+vV/V1vakfPFhva+knaiPwk2/8+mJ1uT1bby/ub1b16nwvPn8fan3PatrPTFEmdNAe28LvQ9MDbE0HbBUDtsoDbQ1hI1cr7N9x40mP/ULoz9wYv9VlCp9U2P/T7HD+FTps8y/Q+ZtlrNvsMOTaHaFM0cf3HqnPcyXMf9w93tdzwPF9DvTxxlhgfM0HSU+PtvAeY5XClue5LX2uyZCtowNtsT9xfen6P5a7PtBan8k58G+wOE/EZz5VGD63sTcHbM2njO8j9hjrQ8WeNreh2EN9GXuarfmBttifWrzNwvhgJfO66fEB4uMY9dGGFfpHgj+1od9MND8iJtqjVin65YA+j7FGQhslyFH/IfNz/TE8w89ra3vcwzfpwe/zB+prcUWx87+75r2Iv3PxGoWos7ab8/vb9aZe/LCk4dmhddbQWc3csX7Q9mYq9J/w+PXfU9P2h226eKT3wt27fQ8ELiFy/L7fSxlfq0f5OjDX1RDXTOGq+fht83/WtO9pv5+inzKB3aqBhQzPUCtweG9grKEt5iFr1edurNX6/Hyl4OOaSSwN/5DaXav1KbafsT3X22Zny+eZivuI9vgrkOi18K00AAA=", - "debug_symbols": "pZXNbuowEIXfJess/Ddjm1epEAoQqkhRQClc6Qrx7h3neGi7qFSFDd8ZzPkSgoXvzbHf3953w3Q6fzSbt3uzn4dxHN534/nQXYfzJO/eG1NefGo2tm18XhAMYAEHeCAABDAQAVgCLAQLwUKwECwEC8FCsBAsBAvBwrAwLAwLw8KwMCwsFieIQALygmgACzjAAwEQixcwEIEE5AVJLEFgAQeIhQQBIIABsbAgAXlBFksUWEAKScBABBIghdw21phKW+kqfWWopEquLE/SlJBrsEaD1eA0eA3lqdoSSANriBqShlyDMxqshnp3rvhcCaSh+HwJUUPSUHz+8Wgb3aS769z3ZY9+27Wyly/d3E/XZjPdxrFt/nXjbfnQx6WbFl67WVbl+/TTUSjC0zD2JT3ar7b5vep9qGUf0rNOf+9Hq/0cVvSDi7Uf3JrrBxue/fxaP9gVfSaqfY7mxT6t6EfW5xdXXT8Gp31e8/txztq3bk0/8bPv19x/0usnE17rW/7R38rUHYb5xznyKKZ56PZjX8fTbTp8W73+v+iKnkOX+Xzoj7e5L6avw0j+kd5sTq1zfitnkkyOWk+SqawE09octuVvrYzettZzGe0yRhnz9lFu8xM=", + "debug_symbols": "pZXRiuowFEX/pc99yElyThJ/ZRCpWodCqdLRCxfx3+9Jd6IzDxeG+uLase6Vmobm3hz7/e1zN0yn81ez+bg3+3kYx+FzN54P3XU4T/rtvTH5w8VmQ23j0gJvAAIs4AAPMCBAAGDxsDAsDAvDwrAwLAwLw8KwMCwMi8AisAgsAovAIrCIWqwiABFIC4IBCLCAAzygFqcQIAARSAuiWryCAAuohRUeYEAAtYgiAmlBUktQEKCFqBAgABHQQmobMqaQCm2hK/SFXCiFeSVNDqkEyqtJOVANtgZXQ15VmwPXIDWEGmINqQRraqAayt3Z7HM5cA3Z53MINcQass8/Hm1TN+nuOvd93qPfdq3u5Us399O12Uy3cWybP914W370demmhddu1qv6n/vpqFThaRj7nB7tq23+X3XOl7Lz8Vnn3/cD1X7yK/rehtL3ds38nvyzn97re1rRF+bSl2De7POKfpC6fmHV/MHb2pc1z09Sqn2ya+YnefbXPD+Jr75bM3+s9x+Nf69P8qO/1VF3GOYf59Ajm+ah2499GZ5u0+Hb1evfS71Sz7HLfD70x9vcZ9PrMNM32gel2Frrtnqm6chy61gz5yvetJT8Nr8W89BRS07ykJZh0GHaPvJt/gM=", "file_map": { "50": { "source": "// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631\n// for context.\n// We were not accurately accounting for situations where the slice capacity tracker\n// was expecting a capacity from slice intrinsic results.\nfn main(expected: pub Field, first: Field, input: [Field; 20]) {\n let mut hasher_slice = input.as_slice();\n hasher_slice = hasher_slice.push_front(first);\n assert(hasher_slice[0] == expected);\n // We need a conditional based upon witnesses\n // to force a store of the slice.\n // If this successfully compiles it means we have stored\n // the results of the slice intrinsics used above.\n if expected as u32 > 10 {\n hasher_slice[expected - 10] = 100;\n } else {\n hasher_slice[expected] = 100;\n }\n assert(hasher_slice[0] == expected);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_0.snap index 550ecda59f2..eb82b4d70f0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_0.snap @@ -50,7 +50,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1aPY/bRhBdSkvxQ9aJZ98VAdIl6aWTdHflFUmfLmVAy7kqVdo0RNIkQPogRerkB6RKZxhwYbh2Z9g/xR7fzulxOKRke9fGAl7gsFzOcN7b2dnZIXWJuWmnr/8Sd21dPzbdxjpXrl+8X1t6tLUIyTPxyJNsnQT26yiAX31zHEfA0UbAMY2A4yQCjlkEHPMIOBYRcCwj4DiNgOOdCDjOIuB4FAHHeQQcqwg4HkfA8W4EHO9FwPEkAo6nATi+aadAmF5IqOCngpoKVioIqeCigoYKBjqQ6cCjA4USNiVESji0oWnDUEDSgp+Y9suq1lj20vWF60cg9/jysSwErk/7l4tNXSjz88h/VTibNoj95TnbT8PwX2TOztfNzj7OhXFnboyxw8+wbASyb5ysAM7+13cd2D/L9Uz4xIAPGHsSBnuTCDwj/GgEfmlCxuLNhxzEYz7SPxwHM9Zp2nxQZpvuPFiWgozXl3LeZ6AnY8uC3pdw/ZW75jULmW9wL/jer/cU/ohFLWvMbWPfjOEe+5X9nKO+kBUgs00bp3RjCzhoi3mkQv8LN567fgLP8POVgj8R+C3eyj3pl0LRLxR9isPP3fXU/VEM/crPmKD7fs3rix+Tx6a790aCTx6Ez2LFfDLT9p/0AePzvkxBP+np2ZaUMVZpgp5/y6G5pYqvK6EvfdBnK3tLWx9zTdHXuZhbruiPlblpuT8XMguyTMgw97NPhnI/62q9Md0YQ65z011H9kFhumvkM59Lv3Iu7YuLkemuC65JKu5duZ7Gv8Mzfee4ll8q040LGaehc2F+IFct7nAtqdkmBNebD8x/AI8EMKnhuUuyEmR8tlVChud7ZUyn3ilgbiHrjkT4MjW7dUDMfICP8ejrVPD51vWE/0hwCHR23OZQXMexWBfE1/IMPovj1OhnC8pY9zsx32mY+S7ugl0jsMamG7eyxh7vmb9mQ+aVsPlmUSdiXuke3pKP8cblfJ0KLj+6nrC+Fz6zA36XZ33a81wOctTfuh73lpZnC9B7DHqYB6jZpu27j1HjaDlr6KzBs5h9VinPT4QMczW+X/xs2j7A9+crP/OvjcJdxocV88R4kDXP+8bRT67/FEf+42hu9PMf+dg9/OU5pX1XkRzSHiyUse4vrg/7zVQ/pxhrasLWgReXN7XSGx83Oz9o/xBmQY76v7kxnoM4j6t35Hl9US+vV/V1vakfPFhva+knaiPwk2/8+mJ1uT1bby/ub1b16nwvPn8fan3PatrPTFEmdNAe28LvQ9MDbE0HbBUDtsoDbQ1hI1cr7N9x40mP/ULoz9wYv9VlCp9U2P/T7HD+FTps8y/Q+ZtlrNvsMOTaHaFM0cf3HqnPcyXMf9w93tdzwPF9DvTxxlhgfM0HSU+PtvAeY5XClue5LX2uyZCtowNtsT9xfen6P5a7PtBan8k58G+wOE/EZz5VGD63sTcHbM2njO8j9hjrQ8WeNreh2EN9GXuarfmBttifWrzNwvhgJfO66fEB4uMY9dGGFfpHgj+1od9MND8iJtqjVin65YA+j7FGQhslyFH/IfNz/TE8w89ra3vcwzfpwe/zB+prcUWx87+75r2Iv3PxGoWos7ab8/vb9aZe/LCk4dmhddbQWc3csX7Q9mYq9J/w+PXfU9P2h226eKT3wt27fQ8ELiFy/L7fSxlfq0f5OjDX1RDXTOGq+fht83/WtO9pv5+inzKB3aqBhQzPUCtweG9grKEt5iFr1edurNX6/Hyl4OOaSSwN/5DaXav1KbafsT3X22Zny+eZivuI9vgrkOi18K00AAA=", - "debug_symbols": "pZXNbuowEIXfJess/Ddjm1epEAoQqkhRQClc6Qrx7h3neGi7qFSFDd8ZzPkSgoXvzbHf3953w3Q6fzSbt3uzn4dxHN534/nQXYfzJO/eG1NefGo2tm18XhAMYAEHeCAABDAQAVgCLAQLwUKwECwEC8FCsBAsBAvBwrAwLAwLw8KwMCwsFieIQALygmgACzjAAwEQixcwEIEE5AVJLEFgAQeIhQQBIIABsbAgAXlBFksUWEAKScBABBIghdw21phKW+kqfWWopEquLE/SlJBrsEaD1eA0eA3lqdoSSANriBqShlyDMxqshnp3rvhcCaSh+HwJUUPSUHz+8Wgb3aS769z3ZY9+27Wyly/d3E/XZjPdxrFt/nXjbfnQx6WbFl67WVbl+/TTUSjC0zD2JT3ar7b5vep9qGUf0rNOf+9Hq/0cVvSDi7Uf3JrrBxue/fxaP9gVfSaqfY7mxT6t6EfW5xdXXT8Gp31e8/txztq3bk0/8bPv19x/0usnE17rW/7R38rUHYb5xznyKKZ56PZjX8fTbTp8W73+v+iKnkOX+Xzoj7e5L6avw0j+kd5sTq1zfitnkkyOWk+SqawE09octuVvrYzettZzGe0yRhnz9lFu8xM=", + "debug_symbols": "pZXRiuowFEX/pc99yElyThJ/ZRCpWodCqdLRCxfx3+9Jd6IzDxeG+uLase6Vmobm3hz7/e1zN0yn81ez+bg3+3kYx+FzN54P3XU4T/rtvTH5w8VmQ23j0gJvAAIs4AAPMCBAAGDxsDAsDAvDwrAwLAwLw8KwMCwMi8AisAgsAovAIrCIWqwiABFIC4IBCLCAAzygFqcQIAARSAuiWryCAAuohRUeYEAAtYgiAmlBUktQEKCFqBAgABHQQmobMqaQCm2hK/SFXCiFeSVNDqkEyqtJOVANtgZXQ15VmwPXIDWEGmINqQRraqAayt3Z7HM5cA3Z53MINcQass8/Hm1TN+nuOvd93qPfdq3u5Us399O12Uy3cWybP914W370demmhddu1qv6n/vpqFThaRj7nB7tq23+X3XOl7Lz8Vnn3/cD1X7yK/rehtL3ds38nvyzn97re1rRF+bSl2De7POKfpC6fmHV/MHb2pc1z09Sqn2ya+YnefbXPD+Jr75bM3+s9x+Nf69P8qO/1VF3GOYf59Ajm+ah2499GZ5u0+Hb1evfS71Sz7HLfD70x9vcZ9PrMNM32gel2Frrtnqm6chy61gz5yvetJT8Nr8W89BRS07ykJZh0GHaPvJt/gM=", "file_map": { "50": { "source": "// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631\n// for context.\n// We were not accurately accounting for situations where the slice capacity tracker\n// was expecting a capacity from slice intrinsic results.\nfn main(expected: pub Field, first: Field, input: [Field; 20]) {\n let mut hasher_slice = input.as_slice();\n hasher_slice = hasher_slice.push_front(first);\n assert(hasher_slice[0] == expected);\n // We need a conditional based upon witnesses\n // to force a store of the slice.\n // If this successfully compiles it means we have stored\n // the results of the slice intrinsics used above.\n if expected as u32 > 10 {\n hasher_slice[expected - 10] = 100;\n } else {\n hasher_slice[expected] = 100;\n }\n assert(hasher_slice[0] == expected);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 550ecda59f2..eb82b4d70f0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_capacity_tracker/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -50,7 +50,7 @@ expression: artifact } }, "bytecode": "H4sIAAAAAAAA/+1aPY/bRhBdSkvxQ9aJZ98VAdIl6aWTdHflFUmfLmVAy7kqVdo0RNIkQPogRerkB6RKZxhwYbh2Z9g/xR7fzulxOKRke9fGAl7gsFzOcN7b2dnZIXWJuWmnr/8Sd21dPzbdxjpXrl+8X1t6tLUIyTPxyJNsnQT26yiAX31zHEfA0UbAMY2A4yQCjlkEHPMIOBYRcCwj4DiNgOOdCDjOIuB4FAHHeQQcqwg4HkfA8W4EHO9FwPEkAo6nATi+aadAmF5IqOCngpoKVioIqeCigoYKBjqQ6cCjA4USNiVESji0oWnDUEDSgp+Y9suq1lj20vWF60cg9/jysSwErk/7l4tNXSjz88h/VTibNoj95TnbT8PwX2TOztfNzj7OhXFnboyxw8+wbASyb5ysAM7+13cd2D/L9Uz4xIAPGHsSBnuTCDwj/GgEfmlCxuLNhxzEYz7SPxwHM9Zp2nxQZpvuPFiWgozXl3LeZ6AnY8uC3pdw/ZW75jULmW9wL/jer/cU/ohFLWvMbWPfjOEe+5X9nKO+kBUgs00bp3RjCzhoi3mkQv8LN567fgLP8POVgj8R+C3eyj3pl0LRLxR9isPP3fXU/VEM/crPmKD7fs3rix+Tx6a790aCTx6Ez2LFfDLT9p/0AePzvkxBP+np2ZaUMVZpgp5/y6G5pYqvK6EvfdBnK3tLWx9zTdHXuZhbruiPlblpuT8XMguyTMgw97NPhnI/62q9Md0YQ65z011H9kFhumvkM59Lv3Iu7YuLkemuC65JKu5duZ7Gv8Mzfee4ll8q040LGaehc2F+IFct7nAtqdkmBNebD8x/AI8EMKnhuUuyEmR8tlVChud7ZUyn3ilgbiHrjkT4MjW7dUDMfICP8ejrVPD51vWE/0hwCHR23OZQXMexWBfE1/IMPovj1OhnC8pY9zsx32mY+S7ugl0jsMamG7eyxh7vmb9mQ+aVsPlmUSdiXuke3pKP8cblfJ0KLj+6nrC+Fz6zA36XZ33a81wOctTfuh73lpZnC9B7DHqYB6jZpu27j1HjaDlr6KzBs5h9VinPT4QMczW+X/xs2j7A9+crP/OvjcJdxocV88R4kDXP+8bRT67/FEf+42hu9PMf+dg9/OU5pX1XkRzSHiyUse4vrg/7zVQ/pxhrasLWgReXN7XSGx83Oz9o/xBmQY76v7kxnoM4j6t35Hl9US+vV/V1vakfPFhva+knaiPwk2/8+mJ1uT1bby/ub1b16nwvPn8fan3PatrPTFEmdNAe28LvQ9MDbE0HbBUDtsoDbQ1hI1cr7N9x40mP/ULoz9wYv9VlCp9U2P/T7HD+FTps8y/Q+ZtlrNvsMOTaHaFM0cf3HqnPcyXMf9w93tdzwPF9DvTxxlhgfM0HSU+PtvAeY5XClue5LX2uyZCtowNtsT9xfen6P5a7PtBan8k58G+wOE/EZz5VGD63sTcHbM2njO8j9hjrQ8WeNreh2EN9GXuarfmBttifWrzNwvhgJfO66fEB4uMY9dGGFfpHgj+1od9MND8iJtqjVin65YA+j7FGQhslyFH/IfNz/TE8w89ra3vcwzfpwe/zB+prcUWx87+75r2Iv3PxGoWos7ab8/vb9aZe/LCk4dmhddbQWc3csX7Q9mYq9J/w+PXfU9P2h226eKT3wt27fQ8ELiFy/L7fSxlfq0f5OjDX1RDXTOGq+fht83/WtO9pv5+inzKB3aqBhQzPUCtweG9grKEt5iFr1edurNX6/Hyl4OOaSSwN/5DaXav1KbafsT3X22Zny+eZivuI9vgrkOi18K00AAA=", - "debug_symbols": "pZXNbuowEIXfJess/Ddjm1epEAoQqkhRQClc6Qrx7h3neGi7qFSFDd8ZzPkSgoXvzbHf3953w3Q6fzSbt3uzn4dxHN534/nQXYfzJO/eG1NefGo2tm18XhAMYAEHeCAABDAQAVgCLAQLwUKwECwEC8FCsBAsBAvBwrAwLAwLw8KwMCwsFieIQALygmgACzjAAwEQixcwEIEE5AVJLEFgAQeIhQQBIIABsbAgAXlBFksUWEAKScBABBIghdw21phKW+kqfWWopEquLE/SlJBrsEaD1eA0eA3lqdoSSANriBqShlyDMxqshnp3rvhcCaSh+HwJUUPSUHz+8Wgb3aS769z3ZY9+27Wyly/d3E/XZjPdxrFt/nXjbfnQx6WbFl67WVbl+/TTUSjC0zD2JT3ar7b5vep9qGUf0rNOf+9Hq/0cVvSDi7Uf3JrrBxue/fxaP9gVfSaqfY7mxT6t6EfW5xdXXT8Gp31e8/txztq3bk0/8bPv19x/0usnE17rW/7R38rUHYb5xznyKKZ56PZjX8fTbTp8W73+v+iKnkOX+Xzoj7e5L6avw0j+kd5sTq1zfitnkkyOWk+SqawE09octuVvrYzettZzGe0yRhnz9lFu8xM=", + "debug_symbols": "pZXRiuowFEX/pc99yElyThJ/ZRCpWodCqdLRCxfx3+9Jd6IzDxeG+uLase6Vmobm3hz7/e1zN0yn81ez+bg3+3kYx+FzN54P3XU4T/rtvTH5w8VmQ23j0gJvAAIs4AAPMCBAAGDxsDAsDAvDwrAwLAwLw8KwMCwMi8AisAgsAovAIrCIWqwiABFIC4IBCLCAAzygFqcQIAARSAuiWryCAAuohRUeYEAAtYgiAmlBUktQEKCFqBAgABHQQmobMqaQCm2hK/SFXCiFeSVNDqkEyqtJOVANtgZXQ15VmwPXIDWEGmINqQRraqAayt3Z7HM5cA3Z53MINcQass8/Hm1TN+nuOvd93qPfdq3u5Us399O12Uy3cWybP914W370demmhddu1qv6n/vpqFThaRj7nB7tq23+X3XOl7Lz8Vnn3/cD1X7yK/rehtL3ds38nvyzn97re1rRF+bSl2De7POKfpC6fmHV/MHb2pc1z09Sqn2ya+YnefbXPD+Jr75bM3+s9x+Nf69P8qO/1VF3GOYf59Ajm+ah2499GZ5u0+Hb1evfS71Sz7HLfD70x9vcZ9PrMNM32gel2Frrtnqm6chy61gz5yvetJT8Nr8W89BRS07ykJZh0GHaPvJt/gM=", "file_map": { "50": { "source": "// Reference https://github.com/noir-lang/noir/issues/4395#issuecomment-2018948631\n// for context.\n// We were not accurately accounting for situations where the slice capacity tracker\n// was expecting a capacity from slice intrinsic results.\nfn main(expected: pub Field, first: Field, input: [Field; 20]) {\n let mut hasher_slice = input.as_slice();\n hasher_slice = hasher_slice.push_front(first);\n assert(hasher_slice[0] == expected);\n // We need a conditional based upon witnesses\n // to force a store of the slice.\n // If this successfully compiles it means we have stored\n // the results of the slice intrinsics used above.\n if expected as u32 > 10 {\n hasher_slice[expected - 10] = 100;\n } else {\n hasher_slice[expected] = 100;\n }\n assert(hasher_slice[0] == expected);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 0e2a4677770..da1e2970ccd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -32,7 +32,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: Field) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: Field, y: Field) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: Field) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_0.snap index 0e2a4677770..da1e2970ccd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_0.snap @@ -32,7 +32,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: Field) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: Field, y: Field) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: Field) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 0e2a4677770..da1e2970ccd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -32,7 +32,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: Field) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: Field, y: Field) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: Field) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index a9ae4d6eee7..0e2795222e7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -36,7 +36,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: Field) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: Field, y: Field) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: Field) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap index 2c9fd541fa0..8fc123198fa 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap @@ -36,7 +36,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: Field) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: Field, y: Field) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: Field) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 2c9fd541fa0..8fc123198fa 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -36,7 +36,7 @@ expression: artifact } }, "bytecode": "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", - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: Field) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: Field, y: Field) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: Field) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: Field) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: Field, y: Field) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: Field) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: Field, y: Field) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y);\n slice = slice.push_back(x);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/arithmetic_generics/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/arithmetic_generics/execute__tests__expanded.snap index 7be42d2c7f5..fa10a45fb94 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/arithmetic_generics/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/arithmetic_generics/execute__tests__expanded.snap @@ -23,7 +23,10 @@ fn split_first(array: [T; N]) -> (T, [T; N - 1]) { fn push(array: [Field; N], element: Field) -> [Field; N + 1] { let mut result: [Field; N + 1] = std::mem::zeroed(); - result[array.len()] = element; + { + let i_3799: u32 = array.len(); + result[i_3799] = element; + }; for i in 0..array.len() { result[i] = array[i]; } diff --git a/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics/execute__tests__expanded.snap index 12985f81ad9..d3189d27e03 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics/execute__tests__expanded.snap @@ -26,7 +26,10 @@ struct MyStruct { impl MyStruct { fn insert(mut self, index: Field, elem: Field) -> Self { assert((index as u64) < (S as u64)); - self.data[index as u32] = elem; + { + let i_3782: u32 = index as u32; + self.data[i_3782] = elem; + }; self } } diff --git a/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics_explicit/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics_explicit/execute__tests__expanded.snap index f215e7bb891..65f1b778e15 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics_explicit/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/compile_success_empty/numeric_generics_explicit/execute__tests__expanded.snap @@ -35,7 +35,10 @@ struct MyStruct { impl MyStruct { fn insert(mut self, index: Field, elem: Field) -> Self { assert((index as u32) < S); - self.data[index as u32] = elem; + { + let i_3797: u32 = index as u32; + self.data[i_3797] = elem; + }; self } } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/aes128_encrypt/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/aes128_encrypt/execute__tests__expanded.snap index a06ed674558..fc1d93d567c 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/aes128_encrypt/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/aes128_encrypt/execute__tests__expanded.snap @@ -17,7 +17,10 @@ unconstrained fn decode_hex(s: str) -> [u8; M] { let as_bytes: [u8; N] = 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]); + { + let i_3783: u32 = i / 2; + result[i_3783] = (decode_ascii(as_bytes[i]) * 16) + decode_ascii(as_bytes[i + 1]); + } } result } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dedup_regression/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dedup_regression/execute__tests__expanded.snap index 3c1d2715a38..e6980f5b3e6 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dedup_regression/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dedup_regression/execute__tests__expanded.snap @@ -6,7 +6,10 @@ unconstrained fn main(x: u32) { let a1: [Field; 5] = [1, 2, 3, 4, 5]; for i in 0..5 { let mut a2: [Field; 5] = [1, 2, 3, 4, 5]; - a2[x + i] = 128; + { + let i_3770: u32 = x + i; + a2[i_3770] = 128; + }; println(a2); if i != 0 { assert(a2[(x + i) - 1] != 128); diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap index 81da07e7e3e..c8c1fc41349 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_blackbox_input/execute__tests__expanded.snap @@ -16,8 +16,14 @@ fn compute_root(leaf: [u8; 32], path: [u8; 64], _index: u32, root: [u8; 32]) { let a: u32 = if is_right { 32 } else { 0 }; let b: u32 = if is_right { 0 } else { 32 }; for j in 0..32 { - hash_input[j + a] = current[j]; - hash_input[j + b] = path[offset + j]; + { + let i_3784: u32 = j + a; + hash_input[i_3784] = current[j]; + }; + { + let i_3785: u32 = j + b; + hash_input[i_3785] = path[offset + j]; + } } current = std::hash::blake3(hash_input); index = index >> 1; diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_nested_blackbox_input/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_nested_blackbox_input/execute__tests__expanded.snap index 277c9e0fbd5..be5b89c0e70 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_nested_blackbox_input/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/array_dynamic_nested_blackbox_input/execute__tests__expanded.snap @@ -13,9 +13,15 @@ struct Foo { } fn main(mut x: [Foo; 3], y: pub Field, hash_result: pub [u8; 32]) { - x[y - 1].bar.inner = [106, 107, 10]; + { + let i_3769: Field = y - 1; + x[i_3769].bar.inner = [106, 107, 10]; + }; let mut hash_input: [u8; 3] = x[y - 1].bar.inner; - hash_input[y - 1] = 0; + { + let i_3771: Field = y - 1; + hash_input[i_3771] = 0; + }; let hash: [u8; 32] = std::hash::blake3(hash_input); assert(hash == hash_result); } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/assign_mutation_in_lvalue/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/assign_mutation_in_lvalue/execute__tests__expanded.snap new file mode 100644 index 00000000000..8bd5ee065a3 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/assign_mutation_in_lvalue/execute__tests__expanded.snap @@ -0,0 +1,20 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: expanded_code +--- +fn main() { + bug(); + () +} + +fn bug() { + let mut a: ([Field; 2], Field) = ([1, 2], 3); + { + let i_3768: Field = { + a = ([4, 5], 6); + 1 + }; + a.0[i_3768] = 7; + }; + assert(a == ([4, 7], 6)); +} diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow/execute__tests__expanded.snap index f200e825d32..bac37d1dc0f 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow/execute__tests__expanded.snap @@ -21,7 +21,10 @@ fn modify_in_inlined_constrained(original: [Field; 5], index: u64) -> ExecutionR let mut modified: [Field; 5] = original; modified[index] = 27; let modified_once: [Field; 5] = modified; - modified[index + 1] = 27; + { + let i_3781: u64 = index + 1; + modified[i_3781] = 27; + }; ExecutionResult { original: original, modified_once: modified_once, modified_twice: modified } } @@ -29,7 +32,10 @@ unconstrained fn modify_in_unconstrained(original: [Field; 5], index: u64) -> Ex let mut modified: [Field; 5] = original; modified[index] = 27; let modified_once: [Field; 5] = modified; - modified[index + 1] = 27; + { + let i_3784: u64 = index + 1; + modified[i_3784] = 27; + }; ExecutionResult { original: original, modified_once: modified_once, modified_twice: modified } } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow_regression/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow_regression/execute__tests__expanded.snap index 45d4c260253..b38df44b321 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow_regression/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/brillig_cow_regression/execute__tests__expanded.snap @@ -147,20 +147,35 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; 2] { let unencryptedLogsHash: [Field; 2] = kernel_data.unencrypted_logs_hash; let mut offset: u32 = 0; for j in 0..MAX_NOTE_HASHES_PER_TX { - tx_effects_hash_inputs[offset + j] = new_note_hashes[j]; + { + let i_3793: u32 = offset + j; + tx_effects_hash_inputs[i_3793] = new_note_hashes[j]; + } } offset = offset + MAX_NOTE_HASHES_PER_TX; for j in 0..MAX_NULLIFIERS_PER_TX { - tx_effects_hash_inputs[offset + j] = new_nullifiers[j]; + { + let i_3795: u32 = offset + j; + tx_effects_hash_inputs[i_3795] = new_nullifiers[j]; + } } offset = offset + MAX_NULLIFIERS_PER_TX; for j in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX { - tx_effects_hash_inputs[offset + (j * 2)] = public_data_update_requests[j].leaf_slot; - tx_effects_hash_inputs[(offset + (j * 2)) + 1] = public_data_update_requests[j].new_value; + { + let i_3797: u32 = offset + (j * 2); + tx_effects_hash_inputs[i_3797] = public_data_update_requests[j].leaf_slot; + }; + { + let i_3798: u32 = (offset + (j * 2)) + 1; + tx_effects_hash_inputs[i_3798] = public_data_update_requests[j].new_value; + } } offset = offset + (MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX * 2); for j in 0..MAX_L2_TO_L1_MSGS_PER_TX { - tx_effects_hash_inputs[offset + j] = l2ToL1Msgs[j]; + { + let i_3800: u32 = offset + j; + tx_effects_hash_inputs[i_3800] = l2ToL1Msgs[j]; + } } offset = offset + MAX_L2_TO_L1_MSGS_PER_TX; let contract_leaf: NewContractData = kernel_data.new_contracts[0]; @@ -168,14 +183,23 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; 2] { offset = offset + MAX_NEW_CONTRACTS_PER_TX; let new_contracts: [NewContractData; 1] = kernel_data.new_contracts; tx_effects_hash_inputs[offset] = new_contracts[0].contract_address; - tx_effects_hash_inputs[offset + 1] = new_contracts[0].portal_contract_address; + { + let i_3803: u32 = offset + 1; + tx_effects_hash_inputs[i_3803] = new_contracts[0].portal_contract_address; + }; offset = offset + (MAX_NEW_CONTRACTS_PER_TX * 2); for j in 0..NUM_FIELDS_PER_SHA256 { - tx_effects_hash_inputs[offset + j] = encryptedLogsHash[j]; + { + let i_3805: u32 = offset + j; + tx_effects_hash_inputs[i_3805] = encryptedLogsHash[j]; + } } offset = offset + (NUM_ENCRYPTED_LOGS_HASHES_PER_TX * NUM_FIELDS_PER_SHA256); for j in 0..NUM_FIELDS_PER_SHA256 { - tx_effects_hash_inputs[offset + j] = unencryptedLogsHash[j]; + { + let i_3807: u32 = offset + j; + tx_effects_hash_inputs[i_3807] = unencryptedLogsHash[j]; + } } offset = offset + (NUM_UNENCRYPTED_LOGS_HASHES_PER_TX * NUM_FIELDS_PER_SHA256); assert(offset == TX_EFFECT_HASH_INPUT_SIZE); @@ -183,15 +207,21 @@ unconstrained fn main(kernel_data: DataToHash) -> pub [Field; 2] { for offset in 0..TX_EFFECT_HASH_FULL_FIELDS { let input_as_bytes: [u8; 32] = tx_effects_hash_inputs[offset].to_be_bytes(); for byte_index in 0..32 { - hash_input_flattened[(offset * 32) + byte_index] = input_as_bytes[byte_index]; + { + let i_3812: u32 = (offset * 32) + byte_index; + hash_input_flattened[i_3812] = input_as_bytes[byte_index]; + } } } for log_field_index in 0..TX_EFFECT_HASH_LOG_FIELDS { let input_as_bytes: [u8; 16] = tx_effects_hash_inputs[TX_EFFECT_HASH_FULL_FIELDS + log_field_index].to_be_bytes(); for byte_index in 0..16 { - hash_input_flattened[((TX_EFFECT_HASH_FULL_FIELDS * 32) + (log_field_index * 16)) + byte_index] = - input_as_bytes[byte_index]; + { + let i_3816: u32 = + ((TX_EFFECT_HASH_FULL_FIELDS * 32) + (log_field_index * 16)) + byte_index; + hash_input_flattened[i_3816] = input_as_bytes[byte_index]; + } } } let blake3_digest: [u8; 32] = std::hash::blake3(hash_input_flattened); diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/conditional_1/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/conditional_1/execute__tests__expanded.snap index 3993f83c329..68e835eaa06 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/conditional_1/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/conditional_1/execute__tests__expanded.snap @@ -26,7 +26,10 @@ fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) { let i_u32: u32 = i as u32; if i_u32 == a { for j in 0..4 { - data[i + j] = c[(4 - 1) - j]; + { + let i_3782: u32 = i + j; + data[i_3782] = c[(4 - 1) - j]; + }; for k in 0..4 { ba = ba + data[k]; } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/databus_two_calldata/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/databus_two_calldata/execute__tests__expanded.snap index ad17f22c991..d7da6ad4cfd 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/databus_two_calldata/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/databus_two_calldata/execute__tests__expanded.snap @@ -8,6 +8,9 @@ fn main(mut x: [u32; 4], y: [u32; 3], z: [u32; 4]) -> return_data [u32; 4] { let idx: u32 = x[i]; result[idx] = y[idx] + z[idx]; } - result[x[3]] = z[x[3]]; + { + let i_3772: u32 = x[3]; + result[i_3772] = z[x[3]]; + }; result } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/encrypted_log_regression/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/encrypted_log_regression/execute__tests__expanded.snap index 76084f4f610..50000a3a66b 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/encrypted_log_regression/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/encrypted_log_regression/execute__tests__expanded.snap @@ -38,18 +38,27 @@ fn compute_encrypted_log( let mut offset: u32 = 0; if flag { for i in 0..EPH_PK_SIZE { - encrypted_bytes[offset + i] = eph_pk_bytes[i]; + { + let i_3785: u32 = offset + i; + encrypted_bytes[i_3785] = eph_pk_bytes[i]; + } } offset = offset + EPH_PK_SIZE; for i in 0..HEADER_SIZE { - encrypted_bytes[offset + i] = incoming_header_ciphertext[i]; + { + let i_3787: u32 = offset + i; + encrypted_bytes[i_3787] = incoming_header_ciphertext[i]; + } } offset = offset + HEADER_SIZE; offset = offset + OVERHEAD_PADDING; let size: u32 = M - offset; assert(size == incoming_body_ciphertext.len(), "ciphertext length mismatch"); for i in 0..size { - encrypted_bytes[offset + i] = incoming_body_ciphertext[i]; + { + let i_3790: u32 = offset + i; + encrypted_bytes[i_3790] = incoming_body_ciphertext[i]; + } } }; encrypted_bytes diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_dynamic/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_dynamic/execute__tests__expanded.snap index 3d60b3bbae9..7444b73f7a0 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_dynamic/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_dynamic/execute__tests__expanded.snap @@ -30,9 +30,15 @@ fn main(mut x: [Foo; 4], y: pub Field) { if y != 2 { x[y].a = 50; } else { x[y].a = 100; }; assert(x[3].a == 50); if y == 2 { - x[y - 1].b = [50, 51, 52]; + { + let i_3768: Field = y - 1; + x[i_3768].b = [50, 51, 52]; + } } else { - x[y - 1].b = [100, 101, 102]; + { + let i_3769: Field = y - 1; + x[i_3769].b = [100, 101, 102]; + } }; assert(x[2].b == [100, 101, 102]); assert(x[y - 3].bar.inner == [100, 101, 102]); @@ -49,18 +55,40 @@ fn main(mut x: [Foo; 4], y: pub Field) { assert(foo_parents[y - 3].foos[y].a == 50); assert(foo_parents[1].foos[1].b == [5, 6, 21]); if y == 2 { - foo_parents[y - 2].foos[y - 2].b = [10, 9, 8]; + { + let i_3773: Field = y - 2; + let i_3774: Field = y - 2; + foo_parents[i_3773].foos[i_3774].b = [10, 9, 8]; + } } else { - foo_parents[y - 2].foos[y - 2].b = [20, 19, 18]; + { + let i_3775: Field = y - 2; + let i_3776: Field = y - 2; + foo_parents[i_3775].foos[i_3776].b = [20, 19, 18]; + } }; assert(foo_parents[1].foos[1].b == [20, 19, 18]); assert(foo_parents[1].foos[1].b[2] == 18); if y == 3 { - foo_parents[y - 2].foos[y - 2].b[y - 1] = 5000; + { + let i_3777: Field = y - 2; + let i_3778: Field = y - 2; + let i_3779: Field = y - 1; + foo_parents[i_3777].foos[i_3778].b[i_3779] = 5000; + } } else { - foo_parents[y - 2].foos[y - 2].b[y - 1] = 1000; + { + let i_3780: Field = y - 2; + let i_3781: Field = y - 2; + let i_3782: Field = y - 1; + foo_parents[i_3780].foos[i_3781].b[i_3782] = 1000; + } }; assert(foo_parents[1].foos[1].b[2] == 5000); - foo_parents[y - 2].foos[y - 3].b = foo_parents[y - 2].foos[y - 2].b; + { + let i_3783: Field = y - 2; + let i_3784: Field = y - 3; + foo_parents[i_3783].foos[i_3784].b = foo_parents[y - 2].foos[y - 2].b; + }; assert(foo_parents[1].foos[0].b == [20, 19, 5000]); } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_in_slice/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_in_slice/execute__tests__expanded.snap index c2c1e32e750..662ced1536a 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_in_slice/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/nested_array_in_slice/execute__tests__expanded.snap @@ -31,15 +31,27 @@ fn main(y: Field) { assert(x[y].b == [11, 12, 23]); assert(x[y].bar.inner == [109, 110, 111]); if y != 2 { - x[y - 2].a = 50; + { + let i_3772: Field = y - 2; + x[i_3772].a = 50; + } } else { - x[y - 2].a = 100; + { + let i_3773: Field = y - 2; + x[i_3773].a = 100; + } }; assert(x[y - 2].a == 50); if y == 2 { - x[y - 1].b = [50, 51, 52]; + { + let i_3774: Field = y - 1; + x[i_3774].b = [50, 51, 52]; + } } else { - x[y - 1].b = [100, 101, 102]; + { + let i_3775: Field = y - 1; + x[i_3775].b = [100, 101, 102]; + } }; assert(x[2].b == [100, 101, 102]); assert(x[y - 3].bar.inner == [100, 101, 102]); diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/ram_blowup_regression/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/ram_blowup_regression/execute__tests__expanded.snap index a755c74bd68..bc636f575f8 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/ram_blowup_regression/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/ram_blowup_regression/execute__tests__expanded.snap @@ -28,7 +28,10 @@ fn main(tx_effects_hash_input: [Field; 256]) -> pub Field { for offset in 0..TX_EFFECTS_HASH_INPUT_FIELDS { let input_as_bytes: [u8; 32] = tx_effects_hash_input[offset].to_be_bytes(); for byte_index in 0..32 { - hash_input_flattened[(offset * 32) + byte_index] = input_as_bytes[byte_index]; + { + let i_3783: u32 = (offset * 32) + byte_index; + hash_input_flattened[i_3783] = input_as_bytes[byte_index]; + } } } let blake3_digest: Field = blake3_to_field(hash_input_flattened); diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression/execute__tests__expanded.snap index 04c39c1b4a4..b6196f70c8e 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression/execute__tests__expanded.snap @@ -35,16 +35,28 @@ fn compact_decode(input: [u8; N], length: Field) -> ([U4; 16], Field for i in 1..input.len() { if (i as u32) < (length as u32) { let x: u8 = input[i]; - nibble[(2 * i) - 1] = U4::from_u8(x >> 4); - nibble[2 * i] = U4::from_u8(x & 15); + { + let i_3794: u32 = (2 * i) - 1; + nibble[i_3794] = U4::from_u8(x >> 4); + }; + { + let i_3795: u32 = 2 * i; + nibble[i_3795] = U4::from_u8(x & 15); + } } } } else { for i in 0..2 { if (i as u32) < ((length as u32) - 1) { let x: u8 = input[i + 1]; - nibble[2 * i] = U4::from_u8(x >> 4); - nibble[(2 * i) + 1] = U4::from_u8(x & 15); + { + let i_3798: u32 = 2 * i; + nibble[i_3798] = U4::from_u8(x >> 4); + }; + { + let i_3799: u32 = (2 * i) + 1; + nibble[i_3799] = U4::from_u8(x & 15); + } } } }; diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_1/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_1/execute__tests__expanded.snap index 70905cf3e23..c81c6c45133 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_1/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_1/execute__tests__expanded.snap @@ -15,7 +15,10 @@ impl BoundedVec4 { } pub fn push(&mut self, elem: Field) { - self.storage[self.len] = elem; + { + let i_3788: u32 = self.len; + self.storage[i_3788] = elem; + }; self.len = self.len + 1; } } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_2/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_2/execute__tests__expanded.snap index 7b22764704e..14dfb95c1b4 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_2/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_6674_2/execute__tests__expanded.snap @@ -15,7 +15,10 @@ impl BoundedVec4 { } pub fn push(&mut self, elem: Field) { - self.storage[self.len] = elem; + { + let i_3788: u32 = self.len; + self.storage[i_3788] = elem; + }; self.len = self.len + 1; } } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_bignum/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_bignum/execute__tests__expanded.snap index 5234a6d437b..648d161ff21 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_bignum/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_bignum/execute__tests__expanded.snap @@ -46,7 +46,10 @@ unconstrained fn shl(shift: u32) -> [u64; 6] { let mut result: [u64; 6] = [0; 6]; result[num_shifted_limbs] = 1 << limb_shift; for i in 1..6 - num_shifted_limbs { - result[i + num_shifted_limbs] = 0; + { + let i_3789: u32 = i + num_shifted_limbs; + result[i_3789] = 0; + } } result } diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_capacity_tracker/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_capacity_tracker/execute__tests__expanded.snap index 132698aaf5f..ecb14fd5dd4 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_capacity_tracker/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/regression_capacity_tracker/execute__tests__expanded.snap @@ -7,7 +7,10 @@ fn main(expected: pub Field, first: Field, input: [Field; 20]) { hasher_slice = hasher_slice.push_front(first); assert(hasher_slice[0] == expected); if (expected as u32) > 10 { - hasher_slice[expected - 10] = 100; + { + let i_3770: Field = expected - 10; + hasher_slice[i_3770] = 100; + } } else { hasher_slice[expected] = 100; }; diff --git a/tooling/nargo_cli/tests/snapshots/expand/execution_success/slice_dynamic_index/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/expand/execution_success/slice_dynamic_index/execute__tests__expanded.snap index c28cce0ca77..1faae7e7d86 100644 --- a/tooling/nargo_cli/tests/snapshots/expand/execution_success/slice_dynamic_index/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/expand/execution_success/slice_dynamic_index/execute__tests__expanded.snap @@ -35,7 +35,10 @@ fn dynamic_slice_index_set_if(mut slice: [Field], x: Field, y: Field) { if (x as u32) < 10 { assert(slice[x] == 4); slice[x] = slice[x] - 2; - slice[x - 1] = slice[x]; + { + let i_3814: Field = x - 1; + slice[i_3814] = slice[x]; + } } else { slice[x] = 0; }; @@ -52,7 +55,10 @@ fn dynamic_slice_index_set_else(mut slice: [Field], x: Field, y: Field) { if (x as u32) > 10 { assert(slice[x] == 4); slice[x] = slice[x] - 2; - slice[x - 1] = slice[x]; + { + let i_3815: Field = x - 1; + slice[i_3815] = slice[x]; + } } else { slice[x] = 0; };