diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index 18ce32ea870..7e370e7ead7 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -715,7 +715,7 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> { BrilligBinaryOp::LessThan, ); } - Intrinsic::ArrayRefCount | Intrinsic::SliceRefCount => { + Intrinsic::ArrayRefCount => { let array = self.convert_ssa_value(arguments[0], dfg); let result = dfg.instruction_results(instruction_id)[0]; @@ -729,6 +729,20 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> { let array = array.extract_register(); self.brillig_context.load_instruction(destination, array); } + Intrinsic::SliceRefCount => { + let array = self.convert_ssa_value(arguments[1], dfg); + let result = dfg.instruction_results(instruction_id)[0]; + + let destination = self.variables.define_variable( + self.function_context, + self.brillig_context, + result, + dfg, + ); + let destination = destination.extract_register(); + let array = array.extract_register(); + self.brillig_context.load_instruction(destination, array); + } Intrinsic::IsUnconstrained | Intrinsic::DerivePedersenGenerators | Intrinsic::ApplyRangeConstraint diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs index 834a3b3ce37..fbb6d715a04 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/procedures/vector_pop_front.rs @@ -68,26 +68,60 @@ pub(super) fn compile_vector_pop_front_procedure( BrilligBinaryOp::Sub, ); - // FIXME: https://github.com/noir-lang/noir/issues/7976 - // There used to be a branch here for `if is_rc_one` but it was removed due to issues with - // mutating the reference count while popping from the front of the vector. - brillig_context.codegen_initialize_vector(target_vector, target_size, None); - - let target_vector_items_pointer = - brillig_context.codegen_make_vector_items_pointer(target_vector); - - let source_copy_pointer = brillig_context.allocate_register(); - brillig_context.memory_op_instruction( - source_items_pointer.address, - item_pop_count_arg, - source_copy_pointer, - BrilligBinaryOp::Add, + let is_rc_one = brillig_context.allocate_register(); + brillig_context.codegen_usize_op( + source_rc.address, + is_rc_one, + BrilligBinaryOp::Equals, + 1_usize, ); - // Now we copy the source vector starting at index removed_items.len() into the target vector - brillig_context.codegen_mem_copy(source_copy_pointer, target_vector_items_pointer, target_size); - brillig_context.deallocate_register(source_copy_pointer); - brillig_context.deallocate_register(target_vector_items_pointer); + brillig_context.codegen_branch(is_rc_one, |brillig_context, is_rc_one| { + if is_rc_one { + // We reuse the source vector, moving the metadata to the right (decreasing capacity) + brillig_context.memory_op_instruction( + source_vector.pointer, + item_pop_count_arg, + target_vector.pointer, + BrilligBinaryOp::Add, + ); + brillig_context.memory_op_instruction( + source_capacity.address, + item_pop_count_arg, + source_capacity.address, + BrilligBinaryOp::Sub, + ); + brillig_context.codegen_initialize_vector_metadata( + target_vector, + target_size, + Some(source_capacity), + ); + } else { + brillig_context.codegen_initialize_vector(target_vector, target_size, None); + + let target_vector_items_pointer = + brillig_context.codegen_make_vector_items_pointer(target_vector); + + let source_copy_pointer = brillig_context.allocate_register(); + brillig_context.memory_op_instruction( + source_items_pointer.address, + item_pop_count_arg, + source_copy_pointer, + BrilligBinaryOp::Add, + ); + // Now we copy the source vector starting at index removed_items.len() into the target vector + brillig_context.codegen_mem_copy( + source_copy_pointer, + target_vector_items_pointer, + target_size, + ); + + brillig_context.deallocate_register(source_copy_pointer); + brillig_context.deallocate_register(target_vector_items_pointer); + } + }); + + brillig_context.deallocate_register(is_rc_one); brillig_context.deallocate_single_addr(target_size); brillig_context.deallocate_single_addr(source_rc); diff --git a/test_programs/execution_success/reference_counts_slices_inliner_0/Nargo.toml b/test_programs/execution_success/reference_counts_slices_inliner_0/Nargo.toml new file mode 100644 index 00000000000..42777f170c2 --- /dev/null +++ b/test_programs/execution_success/reference_counts_slices_inliner_0/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "reference_counts_slices_inliner_0" +type = "bin" +authors = [""] + +[dependencies] \ No newline at end of file diff --git a/test_programs/execution_success/reference_counts_slices_inliner_0/src/main.nr b/test_programs/execution_success/reference_counts_slices_inliner_0/src/main.nr new file mode 100644 index 00000000000..cecb6ee76e9 --- /dev/null +++ b/test_programs/execution_success/reference_counts_slices_inliner_0/src/main.nr @@ -0,0 +1,122 @@ +// This test is exactly the same as `reference_counts_inliner_0` which uses +// arrays rather than slices. +// This test exists to make sure that our reference counting debug methods match +// between arrays and slices. +// We could most likely combine the code for these tests (e.g. using generics), +// but it is simpler to debug isolated tests. +// It should only be necessary to have a test at one inliner setting, as we +// are just checking for discrepancies between the array and slice debugging builtin functions. +// The actual functionality of reference counting is tested with the `reference_counts_*` tests. +// We went with testing at an inliner aggressiveness of zero, as this is generally +// the most useful inliner setting for unconstrained functions. +use std::mem::slice_refcount; + +fn main() { + let mut slice = &[0, 1, 2]; + assert_refcount(slice, 1, true); + + borrow(slice, slice_refcount(slice)); + borrow_mut(&mut slice, slice_refcount(slice)); + let _ = copy_mut(slice, slice_refcount(slice)); + + borrow_mut_two(&mut slice, &mut slice, slice_refcount(slice)); + + let mut u32_slice = &[0, 1, 2]; + let rc1 = slice_refcount(slice); + let rc2 = slice_refcount(u32_slice); + borrow_mut_two_separate(&mut slice, &mut u32_slice, rc1, rc2); + + // Safety: test + regression_7297(); +} + +fn borrow(slice: [Field], rc_before_call: u32) { + assert_refcount(slice, rc_before_call, true); + println(slice[0]); +} + +fn borrow_mut(slice: &mut [Field], rc_before_call: u32) { + assert_refcount(*slice, rc_before_call, true); + slice[0] = 3; + println(slice[0]); +} + +// Returns a new slice (a copy) to prevent SSA from optimizing away mutations. +fn copy_mut(mut slice: [Field], rc_before_call: u32) -> [Field] { + assert_refcount(slice, rc_before_call, true); + slice = &[4, slice[1], slice[2]]; + println(slice[0]); + slice +} + +fn borrow_mut_two(slice1: &mut [Field], slice2: &mut [Field], rc_before_call: u32) { + assert_refcount(*slice1, rc_before_call, true); + assert_refcount(*slice2, rc_before_call + 1, true); // should be a copy + slice1[0] = 5; + slice2[0] = 6; + println(slice1[0]); // slice1 & 2 alias, so this should also print 6 + println(slice2[0]); +} + +fn borrow_mut_two_separate( + slice1: &mut [Field], + slice2: &mut [u32], + rc_before_call1: u32, + rc_before_call2: u32, +) { + assert_refcount(*slice1, rc_before_call1, true); + assert_refcount(*slice2, rc_before_call2, true); + slice1[0] = 7; + slice2[0] = 8; + println(slice1[0]); + println(slice2[0]); +} + +fn assert_refcount(slice: [T], mut expected: u32, expect_copy: bool) { + let count = slice_refcount(slice); + + if expect_copy { + expected += 1; + } + + if std::runtime::is_unconstrained() { + if count != expected { + println(f"actual = {count}, expected = {expected}"); + } + assert_eq(count, expected); + } else { + assert_eq(count, 0); + } +} + +fn regression_7297() { + let mut slice: [Field] = &[0, 1, 2]; + + let refcount_0 = slice_refcount(slice); + borrow_mut_two(&mut slice, &mut slice, refcount_0); + + let refcount_1 = slice_refcount(slice); + let slice_2 = copy_mut(slice, refcount_1 + 1); + let refcount_2 = slice_refcount(slice); + + assert_eq(slice[0], 6, "the original should not be mutated by copy_mut, only borrow_mut_two"); + assert_eq(slice_2[0], 4, "the copy should have the expected content"); + + if std::runtime::is_unconstrained() { + assert( + refcount_1 != 0, + "borrow_mut_two should create a fresh slice and not decrease its RC", + ); + + assert_eq( + refcount_1, + 2, + "There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)", + ); + assert_eq( + refcount_2, + refcount_1 + 3, + "after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut", + ); + } +} diff --git a/test_programs/execution_success/reference_counts_slices_inliner_0/stdout.txt b/test_programs/execution_success/reference_counts_slices_inliner_0/stdout.txt new file mode 100644 index 00000000000..7e020b1074f --- /dev/null +++ b/test_programs/execution_success/reference_counts_slices_inliner_0/stdout.txt @@ -0,0 +1,10 @@ +0x00 +0x03 +0x04 +0x06 +0x06 +0x07 +8 +0x06 +0x06 +0x04 diff --git a/test_programs/gates_report_brillig_execution.sh b/test_programs/gates_report_brillig_execution.sh index c17733374c4..42575f11c45 100755 --- a/test_programs/gates_report_brillig_execution.sh +++ b/test_programs/gates_report_brillig_execution.sh @@ -19,6 +19,7 @@ excluded_dirs=( "reference_counts_inliner_min" "reference_counts_inliner_0" "reference_counts_inliner_max" + "reference_counts_slices_inliner_0" ) current_dir=$(pwd) diff --git a/tooling/debugger/ignored-tests.txt b/tooling/debugger/ignored-tests.txt index 224431f4c90..e020335fe90 100644 --- a/tooling/debugger/ignored-tests.txt +++ b/tooling/debugger/ignored-tests.txt @@ -5,6 +5,7 @@ macros reference_counts_inliner_0 reference_counts_inliner_min reference_counts_inliner_max +reference_counts_slices_inliner_0 references regression_4709 regression_7323 diff --git a/tooling/nargo_cli/build.rs b/tooling/nargo_cli/build.rs index 5917377ac1a..c818b543170 100644 --- a/tooling/nargo_cli/build.rs +++ b/tooling/nargo_cli/build.rs @@ -71,10 +71,11 @@ const INLINER_MIN_OVERRIDES: [(&str, i64); 1] = [ const INLINER_MAX_OVERRIDES: [(&str, i64); 0] = []; /// These tests should only be run on exactly 1 inliner setting (the one given here) -const INLINER_OVERRIDES: [(&str, i64); 3] = [ +const INLINER_OVERRIDES: [(&str, i64); 4] = [ ("reference_counts_inliner_0", 0), ("reference_counts_inliner_min", i64::MIN), ("reference_counts_inliner_max", i64::MAX), + ("reference_counts_slices_inliner_0", 0), ]; /// Some tests are expected to have warnings diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..aa6b2bdb776 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -0,0 +1,37 @@ +--- +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/+2ZS4/aMBDH7SU8El5Z2LZ8gb0HAoTeOCyH9lukS5F6qaqqUi+ttB+9jepJzHS2HPiPNtCMhPKw+c3D9sSZWFNJ5I6BO96Y52Xrjsl5MldkJyXwShxKr82h5bU5tG4cqrlD2ZFD9vId2hw5ZC7foWYN1d2hKm1bz6lTQk6/d8eQ3S9YLWAAQo+L5m+S5Tpk/oHtT0OPqcBfhGz8wPyk6zgPT8d8w/S2WD/+n0KG7tyav/tQm7+odq6t9/s3MtX52J2HjKcxN3yb0LGdCvaTrr7z9YH56sfewmzJPkjzCMdflPO0rcJfl/Z3dPhvid/V4X8kfk+HvyR+qMJPc+JHOvaXa7Gvw18Rf6DDfyT+UIWf7Sl/Up4kHcZUuWPs3cflsfncMn3GHOcpw/RHzFb0nsEyfWQPjw/lWopdLNgaC208B8eCnljQI7ECIKsNZHWArC6Q1QOykLEPa2pXBGQh50QfyBoAWXWdX/TckPaBhWzdMTlTLLPdt1XKnUXsKe98+frp8zfDxAdZz2C6vmFtgRcEv1/rGZ45wbcCq5BiAtKiDZ6O9Wzd/eQMyTZ/gllIy/HbpvLDl8Br9/u/c9f+IqZjcIadhyyfH9L8kK/y/X75mE8YvxD/ReSnO29e9v8pzcu+qcaO+uy8PjvGPacgQBu04pzW9/9QEPjOfG0KApI0BYET/AsvCGQr3YJAlioXBDLdgkBV0BjpxGcpFRWA/DI/xCr8RVmQudWxvxzfic74bog/VeGn5fy/0+GX4/tKJ/5lQey1qYSeq6T7jXcf9xxfrC3TZ4xcECP9EbMVva+2TB/Zw+PDC2IzwdZYaON7kJmgZybokVgBkNUGsjpAVhfI6gFZyNiHNbUrArKQ49gHspBzdQBkIeM1BLKQa6iueWIEZCFjj5xfSLvGQBYyf8U1tesWyEKuIeTaRq6hCZBV1+f2FMi6A7LoneMlP6ZI+261jyn3rN+pjynWM9QKOu+F/13CB5Uf7vqlP6j8AnIYlTqwMQAA", + "debug_symbols": "7dndaiIxGMbxe8nxHOR98+2tLEuxOi0DouLHwiLe+86Ujbu0g/LX4tEcRvPoU3/BxuRklu3r8f2lW79t9mb242RWm8X80G3W/ehk7MdD++18PYz2h/nuYGY5xca066WZFdFzY966VWtmwZ6bL1PFS/o7V7zz1yfnIvV11V2mqp5/NkbGihTJNRDdjSIh2Vok5HR/ER0tki5/pZVwo0nWUidnH+9v4saaiFW9VMk3PhQVqZIqj+j4b6iS66eiah/wCaNV1PpaReMNIPWlTtZwa4FfqxIfrxIuK1yDe2CtpPEq5QLkbLn+6s6G2tuJ9U9aWPnZvb9pFZbHe0usVZxa+5TvlH7wuutWq+795fN/gZOR0eV89Ts74UTGiUITanFCcEJxwuGEx4mAE9hcsblic8XmDps7bO6wucPmDps7bO6wucPmDps7bO6xucfmHpt7bO6xucfmHpt7bO6xucfmAZsHbB6wecDmAZsHbB6wecDmAZsHbB6xecTmEZtHbB5HzZOvvyxTtp8TASciS5w/fnifpp3ctJObdnLTTm7ayU07uWknN+3kpp3cHTu5qwlsHrF5xOYRm0dsnrB5wuYJmydsnrB5wuYJmydsnrB5wuYZm2dsnrF5xuYZm2dsnrF5xuYZm2dsXrB5weYFmxdsXrB5weYFmxdsXrB5weZiLY8IjyiPOB7xPBJ4hF+yWX42Y/nhjOX6wvWF6wvXF64vXF/w6ZxI5JEET/T60a/5rpu/rtrhbnd48rhe1Kvefnj4va3P1Mvg7W6zaJfHXTtcC/93IzwAx9wk9++gcHhIpDSivn+v/v3+AA==", + "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", + "path": "std/lib.nr" + }, + "50": { + "source": "// This test is exactly the same as `reference_counts_inliner_0` which uses\n// arrays rather than slices.\n// This test exists to make sure that our reference counting debug methods match\n// between arrays and slices.\n// We could most likely combine the code for these tests (e.g. using generics),\n// but it is simpler to debug isolated tests.\n// It should only be necessary to have a test at one inliner setting, as we\n// are just checking for discrepancies between the array and slice debugging builtin functions.\n// The actual functionality of reference counting is tested with the `reference_counts_*` tests.\n// We went with testing at an inliner aggressiveness of zero, as this is generally\n// the most useful inliner setting for unconstrained functions.\nuse std::mem::slice_refcount;\n\nfn main() {\n let mut slice = &[0, 1, 2];\n assert_refcount(slice, 1, true);\n\n borrow(slice, slice_refcount(slice));\n borrow_mut(&mut slice, slice_refcount(slice));\n let _ = copy_mut(slice, slice_refcount(slice));\n\n borrow_mut_two(&mut slice, &mut slice, slice_refcount(slice));\n\n let mut u32_slice = &[0, 1, 2];\n let rc1 = slice_refcount(slice);\n let rc2 = slice_refcount(u32_slice);\n borrow_mut_two_separate(&mut slice, &mut u32_slice, rc1, rc2);\n\n // Safety: test\n regression_7297();\n}\n\nfn borrow(slice: [Field], rc_before_call: u32) {\n assert_refcount(slice, rc_before_call, true);\n println(slice[0]);\n}\n\nfn borrow_mut(slice: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice, rc_before_call, true);\n slice[0] = 3;\n println(slice[0]);\n}\n\n// Returns a new slice (a copy) to prevent SSA from optimizing away mutations.\nfn copy_mut(mut slice: [Field], rc_before_call: u32) -> [Field] {\n assert_refcount(slice, rc_before_call, true);\n slice = &[4, slice[1], slice[2]];\n println(slice[0]);\n slice\n}\n\nfn borrow_mut_two(slice1: &mut [Field], slice2: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice1, rc_before_call, true);\n assert_refcount(*slice2, rc_before_call + 1, true); // should be a copy\n slice1[0] = 5;\n slice2[0] = 6;\n println(slice1[0]); // slice1 & 2 alias, so this should also print 6\n println(slice2[0]);\n}\n\nfn borrow_mut_two_separate(\n slice1: &mut [Field],\n slice2: &mut [u32],\n rc_before_call1: u32,\n rc_before_call2: u32,\n) {\n assert_refcount(*slice1, rc_before_call1, true);\n assert_refcount(*slice2, rc_before_call2, true);\n slice1[0] = 7;\n slice2[0] = 8;\n println(slice1[0]);\n println(slice2[0]);\n}\n\nfn assert_refcount(slice: [T], mut expected: u32, expect_copy: bool) {\n let count = slice_refcount(slice);\n\n if expect_copy {\n expected += 1;\n }\n\n if std::runtime::is_unconstrained() {\n if count != expected {\n println(f\"actual = {count}, expected = {expected}\");\n }\n assert_eq(count, expected);\n } else {\n assert_eq(count, 0);\n }\n}\n\nfn regression_7297() {\n let mut slice: [Field] = &[0, 1, 2];\n\n let refcount_0 = slice_refcount(slice);\n borrow_mut_two(&mut slice, &mut slice, refcount_0);\n\n let refcount_1 = slice_refcount(slice);\n let slice_2 = copy_mut(slice, refcount_1 + 1);\n let refcount_2 = slice_refcount(slice);\n\n assert_eq(slice[0], 6, \"the original should not be mutated by copy_mut, only borrow_mut_two\");\n assert_eq(slice_2[0], 4, \"the copy should have the expected content\");\n\n if std::runtime::is_unconstrained() {\n assert(\n refcount_1 != 0,\n \"borrow_mut_two should create a fresh slice and not decrease its RC\",\n );\n\n assert_eq(\n refcount_1,\n 2,\n \"There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)\",\n );\n assert_eq(\n refcount_2,\n refcount_1 + 3,\n \"after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut\",\n );\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "print_unconstrained", + "print_unconstrained" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_0.snap new file mode 100644 index 00000000000..aa6b2bdb776 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_0.snap @@ -0,0 +1,37 @@ +--- +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/+2ZS4/aMBDH7SU8El5Z2LZ8gb0HAoTeOCyH9lukS5F6qaqqUi+ttB+9jepJzHS2HPiPNtCMhPKw+c3D9sSZWFNJ5I6BO96Y52Xrjsl5MldkJyXwShxKr82h5bU5tG4cqrlD2ZFD9vId2hw5ZC7foWYN1d2hKm1bz6lTQk6/d8eQ3S9YLWAAQo+L5m+S5Tpk/oHtT0OPqcBfhGz8wPyk6zgPT8d8w/S2WD/+n0KG7tyav/tQm7+odq6t9/s3MtX52J2HjKcxN3yb0LGdCvaTrr7z9YH56sfewmzJPkjzCMdflPO0rcJfl/Z3dPhvid/V4X8kfk+HvyR+qMJPc+JHOvaXa7Gvw18Rf6DDfyT+UIWf7Sl/Up4kHcZUuWPs3cflsfncMn3GHOcpw/RHzFb0nsEyfWQPjw/lWopdLNgaC208B8eCnljQI7ECIKsNZHWArC6Q1QOykLEPa2pXBGQh50QfyBoAWXWdX/TckPaBhWzdMTlTLLPdt1XKnUXsKe98+frp8zfDxAdZz2C6vmFtgRcEv1/rGZ45wbcCq5BiAtKiDZ6O9Wzd/eQMyTZ/gllIy/HbpvLDl8Br9/u/c9f+IqZjcIadhyyfH9L8kK/y/X75mE8YvxD/ReSnO29e9v8pzcu+qcaO+uy8PjvGPacgQBu04pzW9/9QEPjOfG0KApI0BYET/AsvCGQr3YJAlioXBDLdgkBV0BjpxGcpFRWA/DI/xCr8RVmQudWxvxzfic74bog/VeGn5fy/0+GX4/tKJ/5lQey1qYSeq6T7jXcf9xxfrC3TZ4xcECP9EbMVva+2TB/Zw+PDC2IzwdZYaON7kJmgZybokVgBkNUGsjpAVhfI6gFZyNiHNbUrArKQ49gHspBzdQBkIeM1BLKQa6iueWIEZCFjj5xfSLvGQBYyf8U1tesWyEKuIeTaRq6hCZBV1+f2FMi6A7LoneMlP6ZI+261jyn3rN+pjynWM9QKOu+F/13CB5Uf7vqlP6j8AnIYlTqwMQAA", + "debug_symbols": "7dndaiIxGMbxe8nxHOR98+2tLEuxOi0DouLHwiLe+86Ujbu0g/LX4tEcRvPoU3/BxuRklu3r8f2lW79t9mb242RWm8X80G3W/ehk7MdD++18PYz2h/nuYGY5xca066WZFdFzY966VWtmwZ6bL1PFS/o7V7zz1yfnIvV11V2mqp5/NkbGihTJNRDdjSIh2Vok5HR/ER0tki5/pZVwo0nWUidnH+9v4saaiFW9VMk3PhQVqZIqj+j4b6iS66eiah/wCaNV1PpaReMNIPWlTtZwa4FfqxIfrxIuK1yDe2CtpPEq5QLkbLn+6s6G2tuJ9U9aWPnZvb9pFZbHe0usVZxa+5TvlH7wuutWq+795fN/gZOR0eV89Ts74UTGiUITanFCcEJxwuGEx4mAE9hcsblic8XmDps7bO6wucPmDps7bO6wucPmDps7bO6xucfmHpt7bO6xucfmHpt7bO6xucfmAZsHbB6wecDmAZsHbB6wecDmAZsHbB6xecTmEZtHbB5HzZOvvyxTtp8TASciS5w/fnifpp3ctJObdnLTTm7ayU07uWknN+3kpp3cHTu5qwlsHrF5xOYRm0dsnrB5wuYJmydsnrB5wuYJmydsnrB5wuYZm2dsnrF5xuYZm2dsnrF5xuYZm2dsXrB5weYFmxdsXrB5weYFmxdsXrB5weZiLY8IjyiPOB7xPBJ4hF+yWX42Y/nhjOX6wvWF6wvXF64vXF/w6ZxI5JEET/T60a/5rpu/rtrhbnd48rhe1Kvefnj4va3P1Mvg7W6zaJfHXTtcC/93IzwAx9wk9++gcHhIpDSivn+v/v3+AA==", + "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", + "path": "std/lib.nr" + }, + "50": { + "source": "// This test is exactly the same as `reference_counts_inliner_0` which uses\n// arrays rather than slices.\n// This test exists to make sure that our reference counting debug methods match\n// between arrays and slices.\n// We could most likely combine the code for these tests (e.g. using generics),\n// but it is simpler to debug isolated tests.\n// It should only be necessary to have a test at one inliner setting, as we\n// are just checking for discrepancies between the array and slice debugging builtin functions.\n// The actual functionality of reference counting is tested with the `reference_counts_*` tests.\n// We went with testing at an inliner aggressiveness of zero, as this is generally\n// the most useful inliner setting for unconstrained functions.\nuse std::mem::slice_refcount;\n\nfn main() {\n let mut slice = &[0, 1, 2];\n assert_refcount(slice, 1, true);\n\n borrow(slice, slice_refcount(slice));\n borrow_mut(&mut slice, slice_refcount(slice));\n let _ = copy_mut(slice, slice_refcount(slice));\n\n borrow_mut_two(&mut slice, &mut slice, slice_refcount(slice));\n\n let mut u32_slice = &[0, 1, 2];\n let rc1 = slice_refcount(slice);\n let rc2 = slice_refcount(u32_slice);\n borrow_mut_two_separate(&mut slice, &mut u32_slice, rc1, rc2);\n\n // Safety: test\n regression_7297();\n}\n\nfn borrow(slice: [Field], rc_before_call: u32) {\n assert_refcount(slice, rc_before_call, true);\n println(slice[0]);\n}\n\nfn borrow_mut(slice: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice, rc_before_call, true);\n slice[0] = 3;\n println(slice[0]);\n}\n\n// Returns a new slice (a copy) to prevent SSA from optimizing away mutations.\nfn copy_mut(mut slice: [Field], rc_before_call: u32) -> [Field] {\n assert_refcount(slice, rc_before_call, true);\n slice = &[4, slice[1], slice[2]];\n println(slice[0]);\n slice\n}\n\nfn borrow_mut_two(slice1: &mut [Field], slice2: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice1, rc_before_call, true);\n assert_refcount(*slice2, rc_before_call + 1, true); // should be a copy\n slice1[0] = 5;\n slice2[0] = 6;\n println(slice1[0]); // slice1 & 2 alias, so this should also print 6\n println(slice2[0]);\n}\n\nfn borrow_mut_two_separate(\n slice1: &mut [Field],\n slice2: &mut [u32],\n rc_before_call1: u32,\n rc_before_call2: u32,\n) {\n assert_refcount(*slice1, rc_before_call1, true);\n assert_refcount(*slice2, rc_before_call2, true);\n slice1[0] = 7;\n slice2[0] = 8;\n println(slice1[0]);\n println(slice2[0]);\n}\n\nfn assert_refcount(slice: [T], mut expected: u32, expect_copy: bool) {\n let count = slice_refcount(slice);\n\n if expect_copy {\n expected += 1;\n }\n\n if std::runtime::is_unconstrained() {\n if count != expected {\n println(f\"actual = {count}, expected = {expected}\");\n }\n assert_eq(count, expected);\n } else {\n assert_eq(count, 0);\n }\n}\n\nfn regression_7297() {\n let mut slice: [Field] = &[0, 1, 2];\n\n let refcount_0 = slice_refcount(slice);\n borrow_mut_two(&mut slice, &mut slice, refcount_0);\n\n let refcount_1 = slice_refcount(slice);\n let slice_2 = copy_mut(slice, refcount_1 + 1);\n let refcount_2 = slice_refcount(slice);\n\n assert_eq(slice[0], 6, \"the original should not be mutated by copy_mut, only borrow_mut_two\");\n assert_eq(slice_2[0], 4, \"the copy should have the expected content\");\n\n if std::runtime::is_unconstrained() {\n assert(\n refcount_1 != 0,\n \"borrow_mut_two should create a fresh slice and not decrease its RC\",\n );\n\n assert_eq(\n refcount_1,\n 2,\n \"There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)\",\n );\n assert_eq(\n refcount_2,\n refcount_1 + 3,\n \"after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut\",\n );\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "print_unconstrained", + "print_unconstrained" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_9223372036854775807.snap new file mode 100644 index 00000000000..aa6b2bdb776 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -0,0 +1,37 @@ +--- +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/+2ZS4/aMBDH7SU8El5Z2LZ8gb0HAoTeOCyH9lukS5F6qaqqUi+ttB+9jepJzHS2HPiPNtCMhPKw+c3D9sSZWFNJ5I6BO96Y52Xrjsl5MldkJyXwShxKr82h5bU5tG4cqrlD2ZFD9vId2hw5ZC7foWYN1d2hKm1bz6lTQk6/d8eQ3S9YLWAAQo+L5m+S5Tpk/oHtT0OPqcBfhGz8wPyk6zgPT8d8w/S2WD/+n0KG7tyav/tQm7+odq6t9/s3MtX52J2HjKcxN3yb0LGdCvaTrr7z9YH56sfewmzJPkjzCMdflPO0rcJfl/Z3dPhvid/V4X8kfk+HvyR+qMJPc+JHOvaXa7Gvw18Rf6DDfyT+UIWf7Sl/Up4kHcZUuWPs3cflsfncMn3GHOcpw/RHzFb0nsEyfWQPjw/lWopdLNgaC208B8eCnljQI7ECIKsNZHWArC6Q1QOykLEPa2pXBGQh50QfyBoAWXWdX/TckPaBhWzdMTlTLLPdt1XKnUXsKe98+frp8zfDxAdZz2C6vmFtgRcEv1/rGZ45wbcCq5BiAtKiDZ6O9Wzd/eQMyTZ/gllIy/HbpvLDl8Br9/u/c9f+IqZjcIadhyyfH9L8kK/y/X75mE8YvxD/ReSnO29e9v8pzcu+qcaO+uy8PjvGPacgQBu04pzW9/9QEPjOfG0KApI0BYET/AsvCGQr3YJAlioXBDLdgkBV0BjpxGcpFRWA/DI/xCr8RVmQudWxvxzfic74bog/VeGn5fy/0+GX4/tKJ/5lQey1qYSeq6T7jXcf9xxfrC3TZ4xcECP9EbMVva+2TB/Zw+PDC2IzwdZYaON7kJmgZybokVgBkNUGsjpAVhfI6gFZyNiHNbUrArKQ49gHspBzdQBkIeM1BLKQa6iueWIEZCFjj5xfSLvGQBYyf8U1tesWyEKuIeTaRq6hCZBV1+f2FMi6A7LoneMlP6ZI+261jyn3rN+pjynWM9QKOu+F/13CB5Uf7vqlP6j8AnIYlTqwMQAA", + "debug_symbols": "7dndaiIxGMbxe8nxHOR98+2tLEuxOi0DouLHwiLe+86Ujbu0g/LX4tEcRvPoU3/BxuRklu3r8f2lW79t9mb242RWm8X80G3W/ehk7MdD++18PYz2h/nuYGY5xca066WZFdFzY966VWtmwZ6bL1PFS/o7V7zz1yfnIvV11V2mqp5/NkbGihTJNRDdjSIh2Vok5HR/ER0tki5/pZVwo0nWUidnH+9v4saaiFW9VMk3PhQVqZIqj+j4b6iS66eiah/wCaNV1PpaReMNIPWlTtZwa4FfqxIfrxIuK1yDe2CtpPEq5QLkbLn+6s6G2tuJ9U9aWPnZvb9pFZbHe0usVZxa+5TvlH7wuutWq+795fN/gZOR0eV89Ts74UTGiUITanFCcEJxwuGEx4mAE9hcsblic8XmDps7bO6wucPmDps7bO6wucPmDps7bO6xucfmHpt7bO6xucfmHpt7bO6xucfmAZsHbB6wecDmAZsHbB6wecDmAZsHbB6xecTmEZtHbB5HzZOvvyxTtp8TASciS5w/fnifpp3ctJObdnLTTm7ayU07uWknN+3kpp3cHTu5qwlsHrF5xOYRm0dsnrB5wuYJmydsnrB5wuYJmydsnrB5wuYZm2dsnrF5xuYZm2dsnrF5xuYZm2dsXrB5weYFmxdsXrB5weYFmxdsXrB5weZiLY8IjyiPOB7xPBJ4hF+yWX42Y/nhjOX6wvWF6wvXF64vXF/w6ZxI5JEET/T60a/5rpu/rtrhbnd48rhe1Kvefnj4va3P1Mvg7W6zaJfHXTtcC/93IzwAx9wk9++gcHhIpDSivn+v/v3+AA==", + "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", + "path": "std/lib.nr" + }, + "50": { + "source": "// This test is exactly the same as `reference_counts_inliner_0` which uses\n// arrays rather than slices.\n// This test exists to make sure that our reference counting debug methods match\n// between arrays and slices.\n// We could most likely combine the code for these tests (e.g. using generics),\n// but it is simpler to debug isolated tests.\n// It should only be necessary to have a test at one inliner setting, as we\n// are just checking for discrepancies between the array and slice debugging builtin functions.\n// The actual functionality of reference counting is tested with the `reference_counts_*` tests.\n// We went with testing at an inliner aggressiveness of zero, as this is generally\n// the most useful inliner setting for unconstrained functions.\nuse std::mem::slice_refcount;\n\nfn main() {\n let mut slice = &[0, 1, 2];\n assert_refcount(slice, 1, true);\n\n borrow(slice, slice_refcount(slice));\n borrow_mut(&mut slice, slice_refcount(slice));\n let _ = copy_mut(slice, slice_refcount(slice));\n\n borrow_mut_two(&mut slice, &mut slice, slice_refcount(slice));\n\n let mut u32_slice = &[0, 1, 2];\n let rc1 = slice_refcount(slice);\n let rc2 = slice_refcount(u32_slice);\n borrow_mut_two_separate(&mut slice, &mut u32_slice, rc1, rc2);\n\n // Safety: test\n regression_7297();\n}\n\nfn borrow(slice: [Field], rc_before_call: u32) {\n assert_refcount(slice, rc_before_call, true);\n println(slice[0]);\n}\n\nfn borrow_mut(slice: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice, rc_before_call, true);\n slice[0] = 3;\n println(slice[0]);\n}\n\n// Returns a new slice (a copy) to prevent SSA from optimizing away mutations.\nfn copy_mut(mut slice: [Field], rc_before_call: u32) -> [Field] {\n assert_refcount(slice, rc_before_call, true);\n slice = &[4, slice[1], slice[2]];\n println(slice[0]);\n slice\n}\n\nfn borrow_mut_two(slice1: &mut [Field], slice2: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice1, rc_before_call, true);\n assert_refcount(*slice2, rc_before_call + 1, true); // should be a copy\n slice1[0] = 5;\n slice2[0] = 6;\n println(slice1[0]); // slice1 & 2 alias, so this should also print 6\n println(slice2[0]);\n}\n\nfn borrow_mut_two_separate(\n slice1: &mut [Field],\n slice2: &mut [u32],\n rc_before_call1: u32,\n rc_before_call2: u32,\n) {\n assert_refcount(*slice1, rc_before_call1, true);\n assert_refcount(*slice2, rc_before_call2, true);\n slice1[0] = 7;\n slice2[0] = 8;\n println(slice1[0]);\n println(slice2[0]);\n}\n\nfn assert_refcount(slice: [T], mut expected: u32, expect_copy: bool) {\n let count = slice_refcount(slice);\n\n if expect_copy {\n expected += 1;\n }\n\n if std::runtime::is_unconstrained() {\n if count != expected {\n println(f\"actual = {count}, expected = {expected}\");\n }\n assert_eq(count, expected);\n } else {\n assert_eq(count, 0);\n }\n}\n\nfn regression_7297() {\n let mut slice: [Field] = &[0, 1, 2];\n\n let refcount_0 = slice_refcount(slice);\n borrow_mut_two(&mut slice, &mut slice, refcount_0);\n\n let refcount_1 = slice_refcount(slice);\n let slice_2 = copy_mut(slice, refcount_1 + 1);\n let refcount_2 = slice_refcount(slice);\n\n assert_eq(slice[0], 6, \"the original should not be mutated by copy_mut, only borrow_mut_two\");\n assert_eq(slice_2[0], 4, \"the copy should have the expected content\");\n\n if std::runtime::is_unconstrained() {\n assert(\n refcount_1 != 0,\n \"borrow_mut_two should create a fresh slice and not decrease its RC\",\n );\n\n assert_eq(\n refcount_1,\n 2,\n \"There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)\",\n );\n assert_eq(\n refcount_2,\n refcount_1 + 3,\n \"after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut\",\n );\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "print_unconstrained", + "print_unconstrained" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap new file mode 100644 index 00000000000..71ba4868d57 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -0,0 +1,68 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "4717959987348973079": { + "error_kind": "string", + "string": "the original should not be mutated by copy_mut, only borrow_mut_two" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "8262467739384083083": { + "error_kind": "string", + "string": "There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)" + }, + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "12390149874551504741": { + "error_kind": "string", + "string": "after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut" + }, + "14225679739041873922": { + "error_kind": "string", + "string": "Index out of bounds" + }, + "15146802936675446448": { + "error_kind": "string", + "string": "borrow_mut_two should create a fresh slice and not decrease its RC" + }, + "15646392865860948187": { + "error_kind": "string", + "string": "the copy should have the expected content" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "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", + "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", + "path": "std/lib.nr" + }, + "50": { + "source": "// This test is exactly the same as `reference_counts_inliner_0` which uses\n// arrays rather than slices.\n// This test exists to make sure that our reference counting debug methods match\n// between arrays and slices.\n// We could most likely combine the code for these tests (e.g. using generics),\n// but it is simpler to debug isolated tests.\n// It should only be necessary to have a test at one inliner setting, as we\n// are just checking for discrepancies between the array and slice debugging builtin functions.\n// The actual functionality of reference counting is tested with the `reference_counts_*` tests.\n// We went with testing at an inliner aggressiveness of zero, as this is generally\n// the most useful inliner setting for unconstrained functions.\nuse std::mem::slice_refcount;\n\nfn main() {\n let mut slice = &[0, 1, 2];\n assert_refcount(slice, 1, true);\n\n borrow(slice, slice_refcount(slice));\n borrow_mut(&mut slice, slice_refcount(slice));\n let _ = copy_mut(slice, slice_refcount(slice));\n\n borrow_mut_two(&mut slice, &mut slice, slice_refcount(slice));\n\n let mut u32_slice = &[0, 1, 2];\n let rc1 = slice_refcount(slice);\n let rc2 = slice_refcount(u32_slice);\n borrow_mut_two_separate(&mut slice, &mut u32_slice, rc1, rc2);\n\n // Safety: test\n regression_7297();\n}\n\nfn borrow(slice: [Field], rc_before_call: u32) {\n assert_refcount(slice, rc_before_call, true);\n println(slice[0]);\n}\n\nfn borrow_mut(slice: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice, rc_before_call, true);\n slice[0] = 3;\n println(slice[0]);\n}\n\n// Returns a new slice (a copy) to prevent SSA from optimizing away mutations.\nfn copy_mut(mut slice: [Field], rc_before_call: u32) -> [Field] {\n assert_refcount(slice, rc_before_call, true);\n slice = &[4, slice[1], slice[2]];\n println(slice[0]);\n slice\n}\n\nfn borrow_mut_two(slice1: &mut [Field], slice2: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice1, rc_before_call, true);\n assert_refcount(*slice2, rc_before_call + 1, true); // should be a copy\n slice1[0] = 5;\n slice2[0] = 6;\n println(slice1[0]); // slice1 & 2 alias, so this should also print 6\n println(slice2[0]);\n}\n\nfn borrow_mut_two_separate(\n slice1: &mut [Field],\n slice2: &mut [u32],\n rc_before_call1: u32,\n rc_before_call2: u32,\n) {\n assert_refcount(*slice1, rc_before_call1, true);\n assert_refcount(*slice2, rc_before_call2, true);\n slice1[0] = 7;\n slice2[0] = 8;\n println(slice1[0]);\n println(slice2[0]);\n}\n\nfn assert_refcount(slice: [T], mut expected: u32, expect_copy: bool) {\n let count = slice_refcount(slice);\n\n if expect_copy {\n expected += 1;\n }\n\n if std::runtime::is_unconstrained() {\n if count != expected {\n println(f\"actual = {count}, expected = {expected}\");\n }\n assert_eq(count, expected);\n } else {\n assert_eq(count, 0);\n }\n}\n\nfn regression_7297() {\n let mut slice: [Field] = &[0, 1, 2];\n\n let refcount_0 = slice_refcount(slice);\n borrow_mut_two(&mut slice, &mut slice, refcount_0);\n\n let refcount_1 = slice_refcount(slice);\n let slice_2 = copy_mut(slice, refcount_1 + 1);\n let refcount_2 = slice_refcount(slice);\n\n assert_eq(slice[0], 6, \"the original should not be mutated by copy_mut, only borrow_mut_two\");\n assert_eq(slice_2[0], 4, \"the copy should have the expected content\");\n\n if std::runtime::is_unconstrained() {\n assert(\n refcount_1 != 0,\n \"borrow_mut_two should create a fresh slice and not decrease its RC\",\n );\n\n assert_eq(\n refcount_1,\n 2,\n \"There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)\",\n );\n assert_eq(\n refcount_2,\n refcount_1 + 3,\n \"after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut\",\n );\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_true_inliner_0.snap new file mode 100644 index 00000000000..83db864893a --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/execution_success/reference_counts_slices_inliner_0/execute__tests__force_brillig_true_inliner_0.snap @@ -0,0 +1,68 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: artifact +--- +{ + "noir_version": "[noir_version]", + "hash": "[hash]", + "abi": { + "parameters": [], + "return_type": null, + "error_types": { + "4717959987348973079": { + "error_kind": "string", + "string": "the original should not be mutated by copy_mut, only borrow_mut_two" + }, + "5019202896831570965": { + "error_kind": "string", + "string": "attempt to add with overflow" + }, + "8262467739384083083": { + "error_kind": "string", + "string": "There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)" + }, + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, + "12390149874551504741": { + "error_kind": "string", + "string": "after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut" + }, + "14225679739041873922": { + "error_kind": "string", + "string": "Index out of bounds" + }, + "15146802936675446448": { + "error_kind": "string", + "string": "borrow_mut_two should create a fresh slice and not decrease its RC" + }, + "15646392865860948187": { + "error_kind": "string", + "string": "the copy should have the expected content" + }, + "17843811134343075018": { + "error_kind": "string", + "string": "Stack too deep" + } + } + }, + "bytecode": "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", + "debug_symbols": "5Z3dbtxGEoXfRde+6O7668qrLBaG7TiBAMEObGeBRZB335E2w3FEcog6nlbK7htDsuarLk6dPlNssjl/3P38/u3vv76+//DLx893P/3rj7uHj+/efLn/+OH02x9/vrp7++n+4eH+19df//ddefxH2tPrP//25sPjr5+/vPn05e6nTuXV3fsPPz/+VE/8L/cP7+9+kvLnv1/dCYUJDhMSJjRMWJjoYcKjhJYwUcNEuOYarrmGa67hmmu45hquuYZrruGaW7jmFq65hWtu4ZpbuOYWrrmFa27hmlu45haueQ/XvIdr3ndq3s+E+nOCwgSHCQkTGiYsTPQw4VHCS5ioYSJccw/X3MM193DNPVxzD9fcwzX37Zr7eQ56fT4Ha9kuuumCtK+RV6uXVrFz+CrdVvHr4PhtcHwaHJ8Hx5fB8XVwfBscv39rfFI7x+eN+eVj49cyOH4dHL8Njk+D4/Pg+DI4vg6O/83zl+slPvH1F3ev57iNlpe29v9Uep5UPE0qreRJpeZJpeVJhfKkEjO7J0TiiMYRiyM9jngYoRJHahzZVKvzUkpdI5uq8toXhA5U1ZufVdVZV/F5cHwZHF8Hx7fB8fvg+D42PpfB8eu3xpdSl/OKjfhtcHwaHJ8Hx5fB8XVwfBscvw+O72PjyzfPX5G2xNeyil8Hx2+D49Pg+Dw4vgyOr4Pj2+D4fXB8HxtfB89fHTx/dfD81cHzVwfPXx08f3Xw/NXB81cHz18dPH9t8Py1b5+/u+vywVUJa3lSoTypcJ5UJE8qmicVy5NKzOyeEA8jvcSRGkdaHKE4wnFE4si2Wp3OZS+VV8y2rMwujKyYDjAeZ7bvMDlgKsA0gCGAYYARgFGAAXTggA48roNWCsBUgGkAQwDDALOpg1p0WVUpva0g3YZau0C0ggyBOgI5AG3fwXAEVQRqCEQIxAgkCLStiLp8rJx+9BVkCNQRyAFo+5L0EVQRqCEQIRAjkCAQooiGKKIhimiIIghRBCGKIEQRhCiCEEUQoghCFEGIIghRBCGKYEQRjCiCEUUwogjeUQTpAomtIEEgRSBDoI5ADkBSEKgiUEOgHUXYcjJ3ar9X0LYiTg3nGWr6t85yfeJPl+vg1HWdlgwfQYePYMNH6MNH8NEjbF/RuekIdfgI7ZtHOH2EnlfNTp886xFo+Ag8fAQZPoIOH8GGj9CHj+CjR7AyfIQ6fIThc9qGz2kbPqdt+Jy24XPahs9pGz6n7QZzmsu55zt17+XgxUrnBcFT4NWCYC8vnU7nJZ31u9NrrnRarnQoVzr8wumYnHu7kxXoKh156XSWS6Knt+JgD8Xu5dPYldbWdYaDtBkOss9wkD7BQXqZ4SDrDAfZZjhImuEgeYaDnKHj8Rk6Hp+h4/EZOh6foOOhMkHHQ2WCjofKBB0PlQk6Hio8w0FO0PFQmaDjoTJBx0Nlgo6HygwdT52h46kzdDx1ho6nztDx1Bk6njpDx1Nn6HjqDB1PnaHjqTN0PG2GjqfN0PG0GTqeNkPH02boeNoMHU+boeNpM3Q8bYaOp83Q8dAMHQ/N0PHQDB0PzdDx0AwdD83Q8dAMHQ/N0PHQDB0PzdDx8AwdD8/Q8fAMHQ/P0PHwDB0Pz9Dx8AwdD8/Q8fAMHQ/P0PHIDB2PzNDxyAwdj8zQ8dzgIVXfwUHO0PHIDB2PzNDxyAwdj8zQ8egMHY/O0PHoDB2PztDx3OIRfvkPcoaOR2foeHSGjkdn6Hh0ho7HZuh4bIaO5xaPxbzdE+bIJFc6misdy5VOz5WOp0rnxZ/7eZBOzZVOy5UO5Uonlyv3XK7cc7lyz+XKPZcr91yu7Llc2XO5sudyZc/lyp7LlT2XK3suV/Zcruy5XNlTuTKXVK7MJZUrc0nlylxSuTKXVK7MJZUrc0nlylxSuTKXVK7MJZcr11yuXHO5cs3lyjWXK9dcrlxzuXLN5co1lyvXXK5cc7lyy+XKLZcrt1yu3HK5csvlyi2XK7dcrtxyuXLL5cotlytTLlemXK5MuVyZcrky5XJlyuXKlMuVKZcrUy5XplyuzLlcmXO5MudyZc7lypzLlTmXK3MuV+Zcrsy5XJlzubLkcmXJ5cqSy5UllytLLleWXK4suVz5R9nHa2x/vdR6+fqlTwf5g+xquX6QP8iulqsH+aPs471+kC/98dKtLQfZ7blFvPhm1IN0OFc6kiudoR8vTyPY8BFuYdfalxHUVyP46BFusv3u+gi36IlFLyPIaoQ2fAQaPgIPH0GGj6DDR7DhI/ThI/joEW6yXez6CLeY035+cZOKdixPybRMyVCmZDhTMpIpGc2UjGVK5gYGKHVpCIT0Zicj1/P27zPvW+wi+0fyrt9p3u07zZu+07z5O81bvtO8NW3eVxeTbrHJ7h/JO+/n5fW8dz4v/bxqU6k8P5eXvc1116GKQA2BCIB27ufnen7zKhOvIEUgQ6BNfTWlZb1XpT2Htu+kbtqXJlHdVlBDIEIgRiBBoM23vFld1vWMZQVtv+VXL1DJ9m2SR1BDIEIgRiBBIEUgQyCoTg5A2zd/HUGIIhhRBCOKYEQRjCiCEUUwoghGFMGIIgRRhCCKEEQRgihCEEUIoghBFCGIIgRRhCCKUEQRiihCEUUooghFFKGIIhRRhCKKUEQRiijCEEUYoghDFGGIIgxRhCGKMEQRhijCEEUYooiOKKIjiuiIIjqiiI4ooiOK6IgiOqKIjiiiI4pwRBGOKMIRRTiiCEcU4YgiHFGEI4pwRBEOKEJLQaCKQA2BCIEYgQSBFIEMgToCIYqoiCIqooiKKKIiiqiIIuqOIl7+YddaNU8qlieVnicVT5NKK3lSqXlSaXlSoTypcJ5U8rhty+O2LY/btjxu2/K4LeVxW8rjtpTHbSmP21Iet6U8bkt53JbyuC3lcVvK47acx205j9tyHrflPG7LedyW87gt53FbzuO2nMdtOY/bSh63lTxuK3ncVvK4reRxW8njtpLHbSWP20oet5U8bqt53FbzuK3mcVvN47aax201j9tqHrfVPG6redxW87it5XFby+O2lsdtLY/bWh63tTxua3nc1vK4reVxW8vjtj2P2/Y8btvzuG3P47Y9j9v2PG7b87htz+O2PY/b9jxu63nc1vO4redxW8/jtp7HbT2P23oet/U8but53NbTuK2VNG5rJY3bWnlRt7327BErlCcVzpOK5EklanFP0LYZXX0OsO1siLkO7WyIOYAqAm3K4+o8296kch3ROGJxpMcRDyPbmx2uIzWOtDhCcSRe/RavfotXv8Wr3+LVb/HqU7z6FK8+xatP8epTvPoUrz7Fq0/x6lO8+hSvPserz/Hqc7z6HK8+x6vP8epzvPocrz7Hq8/x6ku8+hKv/vbNXle7me2bsq4j26ebtS/bU1tZNQs7N/QcQB2BHIB2bmc5gCoCNQQiBNqcpfVkK39B1bqsIEEgRSBDoI5ADkA7X/5wAFUEagi0/TjHXssZ6rWuIEYgQaBtRfTLkz97XZ0k7XyDwQHUEWhbEb1djqmtjmnnqwMOoIpAbectvxxTWx1TJwRiBBIEUgQyBOoI5AC083zyA6giEKIIRxThiCIcUYQjinBEEY4owgFF9FIQqCLQjiKaLxCjj0t+ik+D4/Pg+DI4vg6Ob4Pj97Hxa/hcpFeKIxxHJI5oHLE40uOIh5HtNcjrSI0j2+7ksrQ97s8fYdS3VyGPIEYgQSBFIEOgjkAOQNtrkkdQRSBEEYQoghBFEKIIQhRBiCIIUQQhimBEETvby0s7W0Qrq0fJ952N4AcQIRAj0PYlx1KWa2Jl9eUCfWfD8gFkCNQRyAFoZ2PtAVQRqCEQIdCOIrwskNcVJAikCLSjCFu+C6Wsrsf2ndXSA8gBaGe19ACqCNQQiBCIEUgQSBEIUYQiitjZ9lTLstZca3kO7WxQOoAqAu0owhcvr2X1+bSzPecAYgQSBFIEMgTqCOQAtLOJ4gCqCIQoYmcLQb18dVCl1afGzs3+B5Ag0M41tsYXiFaQIdDONbaqF+hvX7wUXAfYudP8ZvF3bh+/Xfw6OH4bHJ8Gx+fB8SUY/wlSBNqePpdvqzv9uDpL2LnL+ADyOOQ7d+7Wi821lc35zj22B1D0EnWspF5ocHweHF8Gx9fB8W1w/D42/vYaAJVyZk4/Pv9E9e01gCNIEEgRyBCoI5AD0PYawBFUEaghEKIIQRQhiCIEUYQgihBEEYIoQhFFKKIIRRShiCIUUYQiilBEEYooQhFFKKIIQxRhiCIMUYQhijBEEbajiGW5mQr3FbSjCDn3hFQLryBDoI5ADkC9IFBFoIZAhECMQIJAiCI6ooiOKKIjinBEEY4owhFFOKIIRxThiCK2T2uptr5A7CvIEKgjkMehWrbPaw+pClENogiiGKK2dVG7LJRvUApRBlEdona0oedzQjpdsVtRtUBUhagGUQRRDFECUQpRBlEdoiBtNEgbDdJGg7TRIG00SBsN0kaDtLF9TxO1RgvFvKa2tdF06Yqb9jXlCLV9W9MhVXeoeqHWzrZ9Y9MhRYeUtTXFECUQta0N0uXzi7aOyyCqQ5TvUGWhbK3e7RucDql6TNGaahBFELWtDfbzfTAkqz1iJ0ogSiHKIGpbG0pLp6yy1sbOKucBtbPMeURta+NyKzV1XR/XzkLnEUVR6s/Tb/958+n+zduH959PzOMff//w7sv9xw9//frlv7+d//L20/3Dw/2vr3/79PHd+59///T+9cPHd49/uyuP/zym7KeLaM71KZvTr1LkldTy+Ovj23DKUF6d/rHTuKex/wc=", + "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", + "path": "std/lib.nr" + }, + "50": { + "source": "// This test is exactly the same as `reference_counts_inliner_0` which uses\n// arrays rather than slices.\n// This test exists to make sure that our reference counting debug methods match\n// between arrays and slices.\n// We could most likely combine the code for these tests (e.g. using generics),\n// but it is simpler to debug isolated tests.\n// It should only be necessary to have a test at one inliner setting, as we\n// are just checking for discrepancies between the array and slice debugging builtin functions.\n// The actual functionality of reference counting is tested with the `reference_counts_*` tests.\n// We went with testing at an inliner aggressiveness of zero, as this is generally\n// the most useful inliner setting for unconstrained functions.\nuse std::mem::slice_refcount;\n\nfn main() {\n let mut slice = &[0, 1, 2];\n assert_refcount(slice, 1, true);\n\n borrow(slice, slice_refcount(slice));\n borrow_mut(&mut slice, slice_refcount(slice));\n let _ = copy_mut(slice, slice_refcount(slice));\n\n borrow_mut_two(&mut slice, &mut slice, slice_refcount(slice));\n\n let mut u32_slice = &[0, 1, 2];\n let rc1 = slice_refcount(slice);\n let rc2 = slice_refcount(u32_slice);\n borrow_mut_two_separate(&mut slice, &mut u32_slice, rc1, rc2);\n\n // Safety: test\n regression_7297();\n}\n\nfn borrow(slice: [Field], rc_before_call: u32) {\n assert_refcount(slice, rc_before_call, true);\n println(slice[0]);\n}\n\nfn borrow_mut(slice: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice, rc_before_call, true);\n slice[0] = 3;\n println(slice[0]);\n}\n\n// Returns a new slice (a copy) to prevent SSA from optimizing away mutations.\nfn copy_mut(mut slice: [Field], rc_before_call: u32) -> [Field] {\n assert_refcount(slice, rc_before_call, true);\n slice = &[4, slice[1], slice[2]];\n println(slice[0]);\n slice\n}\n\nfn borrow_mut_two(slice1: &mut [Field], slice2: &mut [Field], rc_before_call: u32) {\n assert_refcount(*slice1, rc_before_call, true);\n assert_refcount(*slice2, rc_before_call + 1, true); // should be a copy\n slice1[0] = 5;\n slice2[0] = 6;\n println(slice1[0]); // slice1 & 2 alias, so this should also print 6\n println(slice2[0]);\n}\n\nfn borrow_mut_two_separate(\n slice1: &mut [Field],\n slice2: &mut [u32],\n rc_before_call1: u32,\n rc_before_call2: u32,\n) {\n assert_refcount(*slice1, rc_before_call1, true);\n assert_refcount(*slice2, rc_before_call2, true);\n slice1[0] = 7;\n slice2[0] = 8;\n println(slice1[0]);\n println(slice2[0]);\n}\n\nfn assert_refcount(slice: [T], mut expected: u32, expect_copy: bool) {\n let count = slice_refcount(slice);\n\n if expect_copy {\n expected += 1;\n }\n\n if std::runtime::is_unconstrained() {\n if count != expected {\n println(f\"actual = {count}, expected = {expected}\");\n }\n assert_eq(count, expected);\n } else {\n assert_eq(count, 0);\n }\n}\n\nfn regression_7297() {\n let mut slice: [Field] = &[0, 1, 2];\n\n let refcount_0 = slice_refcount(slice);\n borrow_mut_two(&mut slice, &mut slice, refcount_0);\n\n let refcount_1 = slice_refcount(slice);\n let slice_2 = copy_mut(slice, refcount_1 + 1);\n let refcount_2 = slice_refcount(slice);\n\n assert_eq(slice[0], 6, \"the original should not be mutated by copy_mut, only borrow_mut_two\");\n assert_eq(slice_2[0], 4, \"the copy should have the expected content\");\n\n if std::runtime::is_unconstrained() {\n assert(\n refcount_1 != 0,\n \"borrow_mut_two should create a fresh slice and not decrease its RC\",\n );\n\n assert_eq(\n refcount_1,\n 2,\n \"There is 1 clone after `borrow_mut_two` and before `refcount_1` is defined (cloned before slice_refcount call)\",\n );\n assert_eq(\n refcount_2,\n refcount_1 + 3,\n \"after refcount_1 we clone once in passing slice to copy_mut, once to slice_refcount after, and once within copy_mut\",\n );\n }\n}\n", + "path": "" + } + }, + "names": [ + "main" + ], + "brillig_names": [ + "main" + ] +} 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 fda6602deca..00753fac6a2 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 @@ -35,8 +35,8 @@ expression: artifact } } }, - "bytecode": "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", - "debug_symbols": "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", + "bytecode": "H4sIAAAAAAAA/+1dfYxkWVV/9dXd1TM93bszy4qoBIQofpCa6dmd2UCkF1qWxd2Vlf2SgGFmdtcoXyEGcCPKC0SDaFBEQf5QiASIfCiaCAS/EGM0UYmigOgmwkrkI8QgfgQjLnJn36n6vV/93qn7ut59VTXTN+l01bvnnXvuOeeec+65H9XJJqVT/O/T90zA7BX/R/OVkw3iGklCvWIwt24+9H9YfO9Cfa/Bzg6p3Sbxnx1dc24o+tcg/bvDAmdK/hjOBPhH6wWeH8wn+LkvoWwV31GH7J2Nr/8dzSafv7X4PKR3Usg2Ie9HxwX9XehbKE/J07Rt+PcL/FkC3N8LtDeIfzymn5qGN2P8NzTPmzHup6Wh/ZThv7F52se4n56G9l3D/31p8J82/Dc1z5sx7pvT0H6N4b+ledrHuL8/De3XGv5npMF/xvDfmgb/WcP/A2nwX2f4n5kG/zhGua3AnyXAfXvzuO813Hc0jvvkeLze2Tzusb7f1Tzue45kD8VAj5+gnopROI5CP8axHsOabUwZW329nLZ4r59NF6sbiP5Z3VpFf7j06Dv2KfDxNOBlOCtHskk81s/L7e4Vz0dzlDNnRyNrr1fgH2TTtGP7A4LfLb5vEv3G470D0nnvmXMn7909d++5a87dfffpC+euJPyhdIFPqJumQyjHpmPYgHM9Df5d05U16GtP9MnaVzrdqfhvuLjO2tokXE3HuF7fkH6T7U42Pe6QB1W41mriGmZ6fO810++xTAdOv7H9LQFfR6aq34jL5nds15poB3nYp/70BA0B/kZ4B98ze8TvWrw7IPhHdSY4byqebWfT9npAdUoG29m0vhlcYn0ZGR9sjPezad1G2rrZtE2yz8gne3Zb8T/YzbOdyTtVOorPWN59QQ/jQvo9ORr8s4r/iW3tiP0KtqX0huWfysd48uc2Q6kr/+cW/5X8UT5KZp78e8SfRPm9M1uij1asbgOemZ5ZHeZn2UZhLNOhuiNQh7EvFxX/2bNA1xM6E7wMZyVG/1KNC+u78RD1j9vMson+bUAd8n9Az14MvFhB/TurdMwK61gorH+oY6x/qGOsf0ehbh79e0dD+rdB+PeK76M5i/V9PP/JJrrAbWbZRP9wXCP/B/TslcCLFdS/65SOWWEdC4X1D3WM9Q91jPVvC+rm0b/N7gQvw1mJ0b8h4d8rvo/mLNZ34yHqH7eZZRP9w3GN/B/Qs9cDL1LoX9X3Lny3/MxQ0N4gL8+zzmFhnQuFdRV1jnX1GNSxrm5Tf7IsXleNF0E+n29IVxPxd6yrxl/UVW4zlG42bQNQNgN69jbgxQraytb17yD28FxvgpfhrDCfQtkr/o/mK7uKRx1q9yjR3lDb1yq+qRyVtb+ZTetvihzVUaKH+cO54S1B6w7VhbKfT+C4rieedR1cNzSI68aGcPFYnpcuXhtIZCcuKFtgRcn4CNU1ZQveGGELYvxNovEx4vGB/obbDKWbTdsP5PGAnv0V8GIF/U0tPQqF/Q3qEfsbjGnm0bG/aEjHEvmEEdsN1DFuM5RuNj0+sW8DenY/8GIFdexupUdWWI9CYR1DPWId28nK/Miyg+nYsD/By3BWYnSM/cpe8X00Z7H+GZ9Qx5Qv62bT4xN5PKBnXwRerKCO3aP0yArrUSisY6hHrGNXZGV+ZNnBdOzNgwlehrMSo2PHCP9e8X00Z7H+GZ9Qx7jNULrZ9PhEHg/o2VeBFyuoY/cqPbLCehQK6xjqEesYru3Mo2Mn1yZ4Gc5KjI5xPmKv+D6as1j/jE+oYyoH0s2mxyfyeEDPjnYmvFg9HTs5UnpkhfUoFNYx1CPWseNZmR9YdwLq5smVDtYneBnOyiEPy4V5ePXGBC/DWQlzF7UfgPcK4PoX7xXAtQmDW5ZctdFWN1f9OGf84/pXTzzj8b8u6OH32IZw//AdtWfIZGx71FgWofTzclt7xfPRfOVk6MO/gK4F/KXcal6uwzniWlG3Q3XIG97Lg3xR+294LRH5pez1U4k+5c9wv07T+/7Ondk9e+HU6Qtnzl+ze2732lr7/prcM2W8qdrvafWoW4OK9zpQj/BPhnH1iEIxE9uKXW/con0dEv1DAY/jle3gusCV0XvMj1As18f7BZ7eaYU/cj/QkPqNfeN4hsfZoOI91gmDv+US0gneR9UXuLJM6wTaKctxs07csQQ6oXyN8SzQ+S3DCRz3q5+3Qr8rXyWTuvLdEfD7ebnO20OZaA/JLtvnqn5vUL8Vn7yYrytwMY8GBBsK2zqDvbfTCn+kXjMvukC/+T88/9ip6N+PCDsWI49Q7Bye4i++O4u/+3m5zmBftAT8VXrF8UVvRv8Vji7hqJIj43om8crgf6ogPuj8S4rPyuaZ/JTNQ5n0i3faOkOh8hOKn55uolxs7O8I+P28XKfOEYX3X5+Aj4uwocru1bWhOwLe1qGZJ0qmFhsoWdWJzXrUhtUj/GuETWvS/y/iPBHyKGYsqPmQGgsmQ8//41hQtp7PElh76IvwTDjLzWDe6PgiNR/GcWZnk738Ln/n9kMxfrBO/Rr5olTnCZQviuEvnomv4u9bHP569jcUO5u9TW3wu+zDEDYU5q/Bvp34m2gdQ/LX2lr1PMVvCfke5inKdQb7vk4r/Fl4nuKDl5BOpM5TfHgJdOIwT3GYp2g6T/HRTiv8SZqn+JgTuyw6T/FPS8DfRecpQsH7aar4+IWC+KDzny4+H+Yp5stTfC0BHw/zFNOyajpP8d/Cph3mKebLU9hYOGieImYe3SuQLnIevZ+X6wx2WHy4VOfRTd6DEuMz2f7Ezr8M/rjQlcTnDMfjU8XbOB74/gS1bwdjeJ5/bQhcGb3H/AiF41SDfUS3Ff5I3d2kfmPfquw+9lG9xzph8I90dCLRWaBdT8aoE7wP6YiAR7lYf7ezaX3hM4qbFfwIhefkBvtt3Vb4I3UCz41d7H8+qfN8Mvarn7dC/27sGD6ofHcE/H5ermP/inXo542etuzgxgyexNhBLw+lbGqWTfsNhA2lKjd5dgnsYCebjkHqzNef4MRInjxC8ebrnA/x+Lufl+sM9vol9TMx83VvHy/DevN1xlW1r+DW4kMYvzcUn5U9NPnVnWcmur8wer7Oc0Fv3y2O/R0Bv5+X62LtIc7l35KAx4uwr3XjTC8PjPDePDCGx1mm7UbM+sAPw1h4jiMnLzZAfewX77SVc5ml2zE5FzW/VzkXuze5rpyMHhwLGbWt1u3t3nOW5y+AzH70UGauzOz+b+V3rc3Edtu9TxHbNNq6BI+fQ+Fc/csgLuEzMl3BO3zWJd71BD0ero7ApXQReR1Kn+r2iuej+Yo8A1PiXV6uQ11Zy8u8wLrbqU7lrdXY57i6I+pS57V4HKH+qZxuN5seh8gL9iGvdvQP9cPTGXVGq5NpXEi/2i/FucXXUmyc6t5K7z7XoBO/TLbf4EyXMKd/Z0VfXk996bbYl67oi9JrPrOINPKen4Pmq9+0BPlq8y08v3jzEuSrMdZYlIze5sho1t5HlpFas+LvKoZiGRnsu5bAJqi+jdc8iN5FxSRGW92Y5Hccn6DGJz5jn6BiNsaF9OMYZZ9g8O9fIvkrG9tWTKDk78UEsfL/wwZjAo5D8bO35h6K/T6SF3/xd2XrLf7jfv4Z6dEi9snE6NGi7+pmPYqNLf+yJT1iXKGY7UBc3jx7EXObEu/ych3mn3lug3V3UF1sXoP1T+V0U58t6BBdVb9VwHNr7Aeuuw/o2f0Nzq2rctr4vcqPWTzEseYDZH9S/SaIsj9rFX1AfqB+2m/JefaKvytbfEcFLz63BLxY9fMWXxIx++F5i3KdwX6l2wp/GjtvcdD9Pl91dOJy3e/DZ77Gvr/XCn/cddi6awHYr37eCv27sWP4oPJV62z7ebkO4wOOV1LbuvUZ/Y6xdbHnLdjWHeS8xYleK/xxbR3HGZiPwt+W7lT07+oCOPa8BY6Lm/OH/qc6b/HNS8BfpVccX/Rm9F/h4PxNlRwZF569YL7G5CEN/3cXwGGMPKb4rGykyVvZSMMdSr94J3GOZpf5lGXTcwNuH78jvMrv7gj4/bxcp+aC4f07E/Axtc2dxccYm+vxEeFj9nRk2fQ4CN+9fRsGewvo9Nmejw/le1MFvicAvn1Htkb7pb4nimWL8LYvY9YZJuOjt/7CfuAGx0epPqIu8ZqJyptnmW8rsX88976ZfNSi1rXuPNRPVz+9fUqon3ceQD+ftcT6+dwl0M+q/A+vWar/Webnf9Q91nVyQyov6v1+NcOiTFE/egKXxW51clY9B6fSCaPhx8F3vaBXhjGcLxJ629aZQsz9efFzh74jvJKZWj/muYgXC+zn5TqDfRmNo1S5e+9eoNDHn++V+VJXPwz+Jy5T2Q8q+BEKx4EG+6peK/xx18Wb3Mu6CPkqmdSVb8x5YbVPA8eN8rNV58Tr7u35xZpxgLe3R/nRLNP2qwP1VfduvWGJ4wDun/qfZXFxAM/77T3WKY6zDEb9zkAVjjr3BCAujgM8ujrZtMwVTsvF8Xz5PRAHvJXiAMP5NkdvVcyt+G/PZ90VELPHLsv0OPNyhgb7btLzVHvFlJ7j/QQfIj9dV34G/94llQ3vL/Ty5Qb7fpLNItaivflx4r0q117cL+HMvwdE06z9oAeV746AZz+KdhTnxx9y5sdse2fNfb31gzpzX/Z5Bvvnh3Pfhc19Q8G1irUadLH+zJrb2Of1mvAbkfA8H/gy+NSPV8yt/8GZX6XO6c+aX8Xk9GPnV7yOepD51ad6rfDHXefjnN4Dl/n8WNlwtrM2fj4veLVKZy9n3d0Wc/Yy5o4y5YOr5qsPNpTn+a/DHN+Ufu3n5TqD/b8lyfE92EKuolsgWsZcxUZB2+UUt3WonUGD7aj8grJbVfGhOrtbhYPjug49n7Wvxeo2HLo8m8i22uqRhtMF48P3b+iXYQznN4rx0ZbdVDF4XbvpnUnw7OZapvkRyn5erjPYR/db4c/c5wZT5RtYDnheQc1zuoJP3rmxbwddbOPcIOLqCFzLdt6nibsM+LyPisuUPcWz7K8ZTJ4fxD4Z/BnH9qSeO86yPTFzx1jbw3NHz/bw3NFgn9RvhT+N3uXvzXUWIV8lk7ry9fb7xdwzk9o2j+1SRT+Mtq7gA/aJzzbc5NjmruCdyt9eyvfMlHiXl+vwHALbZqy7LS/zAu2msqtVc467hF2te/8a8rxfvNPWuRDPP3P7zEMvr+HxXNltazO1zeV+VP2OOsdVsb+jfk+DcVVH0NMR35UdeGpehjf61uBdhOlW9Od50J9bhhrnINO6UIXzhU4scpT6tVd8H81Xxvqu7qxFPmP7+B3h+R7eULazaT3BdxGW+REK359isC+lWGQRdxjHjNdU5+9Ybjheuc1QuoJPKPMBPXt5y+M19k4tg3/lEsi/yf3fqe+w9vKM3H6VPfD8GcLb/K5urN7Jlos/SuZN8Oeu/KH/KlZn+5EqH9shOqvu3+FYPfbelDc0GKt3BD1D8d5eM7w5z7wxOkOJvZMF5RhKH+qangfcSuOoZNfzch36Xp4HoI9nnbT+4NrHU/IJDN9fYPBvddY+vBgiFPt9W7X2wTHE0Yr2VbxlsL9JPmQL3kntQ6wt1TfjAet4Khtg/FA+GGnrZtN6gnJg/v62YwM68J43x2b7ybzC70g/jl2+u8bgf4/knyjGlvLneFqtc+NY8O4Rw3e9sRjKXcQLg/39JeBFzFhItD/BHQsqj1x3LPxJ4rEwFO/tNcObC1X2OhQbW0in8ocox1D6UJfaH25NSJzyh8egjv2h1SmbY/2p8ofsjwz+I44/RFp6gnb2h6gH+C5+H2TVOjMg2L8nG7AN76S2AdaW6pvxYJhNyyWFDTBa0AZgm0ZbV/DJPiN/7dk/OjZAzSfwGduALUEP40L6ceyaL2Hd+NQSyL/K1vBY4LvckAezYkM1F2N7/a8rMhZS+WlvLGCbBx0LX2x5LBh/QjH9R1zKZyGvQ+nnZVx7xfPRfOWiz3o1+awS7/Jy3RVQZz7LdGUH+mtw29k0n7ahbwibSo9Mz1GPsE2jrUvw+PkiL+jZ/zp6hPZC2RDWo21BD3+39negnnPUYz4XexSGok+pbYg9i5H9TiK6PNnvCN7Wlf16wd9UsmdcSD/aI55fGvzWEsjfs4MqdjdaT6ShdZxvPT5pesxTlIG1r/TX3lU2G3U7lH6epB8XbfZ7yGaXdDWffEa6pmxENh2PG+zDSX+OZ0n6IvXH2lJz8iuzMl2p8mZeDKL4VzcGeaRjPzrwXsycnMebwlVlP6p+N+axJP9FxuMdajv8x72AfP+h9Q/X1RGG7yg0+MeBTHhdnefcLBO2wwb/XYCT19UTjamTbOe6QDO2ybrCsW8osWsOV1JdH+qszfEZrDxNvwOPP+HEshavWt0JqFsv6nZE3R1AL9tMpV+oKwh/ndAFjlOybNonhcJnaJVN5O8qB8v3hxvsk5bA3nv8NT30+PvkOfjr3c9eh788pzfYpy2pP+V4PFWcyDYJ/ZHyX13BJ4zbBvTslgb9KfsfhSs2Hjf421ZE/qn2snjyV/nhuvJ/Vsvy72Q6FuE9fkZf1R6/9Yr+PNeJRdT5d+wP66DBX3BikURzrnEsYvgxFsE2mc/qvJo3Z7w6Df3jOePDJk3LOePVRL+CfxjA8BzzKqgzOG+OqeKsE8CTUAZ5Ep5cjLO+aXNCB49NzgsqW5R6XsF6h/ZGje9uNq2TGAMO6NlLGrQ3KiZX55P4fv8B1CH/EY/RfRXU35CX6wz2J8lHJbIJ0kfxePB0JhVdHeIV6oyyVd1seuwin5n3r0qsM4xL/R5ZKFVz/p9dghgFz9cpXbDxoPYvDqhO7SUcZtPjKoUODYQM1FnDbjY9lvFMON+h8kuODvXgvZi90by3S+Gq+9uSv0o6tIi7FTx+dOGZt68J38X3YuZ8BvvrxItU+2kP7zdY3P0GoeD9V+s16GI9HVS8x/Z9oyb8MBKez9zeXzA8fH/voAxjNP+uM6dIfU5u1hnmmHNy3u/V9wSuLJvWA7YXVWeYPzhohT/u72Px3ss/cOSX+j6mWfKLuY8pVn68T7Xqd75Dqfp9sz8VvFqlM+GKf8ijmDPhKBOej+D73m9yWZvLcl8HnzOJva/jb5xYrO45ExWrerg6AteynQlv4r6O26hO3YE5676Of4+4r8Pzhwb/z5e5rVS+bj8v1xnsZwet8Mf9bfBVuptw1n0dB5WvGlPeXfodeo/nb1lWHlMp5+ireo/T/yz5HP1rNDYXeY8X1rH8U82XPfkzj7OsvvwHhRI1kefjWAA/qzlsbH6D74PjdSikifeYjn+rpOjnIm18jB6l0m+2xSrfqvQo9hzz8Zb0iHGFErvvB3kdSh/qUseXJd7l5Tqcu3B8iXXefXCeL2T9U7HYsuSaeX4Tm2t+jKN/dec36t4mxlXlx3g92+C/g+zPInPNih+on97+InwXv8fs3zLY0RLw4jDXvPy55lS5Y/u8GQnP88UXFh/CvyevlWGM5n2wRzz/Tn1Hi5pvoR2LuaNF5c62s2kdwHdZZggbCueaDfamtVb4495RxPnTWxz5LSL3ifI7aO5TyQ/f5fdYfpxrtvFzu+BV3XwGttMv3mlrbUbxD3kUszaDMuF8Br7vxWLW5rLMBTgWi50LnG8wFlO5bw9XR+BSuoi8DqUPdaswFzhortnaDv1/1drkufLhsf7wxZe5rVS+bj8v1xnsfWut8KfRu6E927wI+SqZ1JWvdzd03fm10YNjat5cs7J7y+IXjLa6fuHnHL/g/cabtRWKyhHx+viaoL8DuDjXbPCvW5EcYeq1BiV/5nGW1Zf/G1vKEXo+IZQ6d4R5+Q3ONRvsm5dAj7JM+2xcv+H8jMH+Bsxv39eQPbsU187e6ehzirUzxKXGxuFvoEzqcE/FoQ5PCuvwHx3qcHIdvr2o89Y227rDVPl25Uvr+va/btC3eznbjqAfdavqTOvfLWlsx/JPvY9gw+HfPPL/ZEvyV7EdjlFv7YpjI56/I002Zrmfn16C+XuMHqXS7w7REnv/61D0A/lrzz7bsh0xXKHE3tGKvA6lD3Wp/VGJd3m5Lva3iw66j4D1ry/qUq/pGo0qHsI2jba68dBXHP3DteGeeMb6NxT0MK6qHAXfPWrwD5L9WcR+OI8fqJ+2/uvF3fw9Zh/BmHfri+dF1T6CVOv7HWpnrcF2VM7RvvOeO8TXhzaU78HP7D8Gme8/eA0wlL3i/2iusnuKx/4Tiw+BD1eul/tr9J4ons+z1on2p5+X+5l6b4DKj+O4idkbgHbNZKbuXDeZqbk1xyup4ijuR9XvtfFaZ+zvPz0K9GHetU619urh6ghcyxavNPEbK5yjQfvGv3uQev+iijtU/FQ37hg5esR2vEr2dX4DBHEpnVz0bxPUycPE6pGXL+xQndoTF549Z738DsYtnh/j2OVJwo+0tabq7cXn9vE7wqNec35DzQsy8R7ChmLrr3X9KeLoF+8s0p9i/5v0p7w3AWVmbba1Rqzm/97eodj5/60N+lO1J8bD1RG4lC4ir0PpQ90i5/+oW2wH1b3W3v5hZQetbbSDyifzuolaq1e2ou19DrN0mHMIsTp8j6PDdXMIaox7uGJ1eJFrKvPqcCh3UZ3K/Xg6rPSWc1ip12LUnMRbi4mdk7y0wViSYwGFS8XCoXAOy+BfTnmbRez35j7V2R/xCsgTvI7soIqj2lrbUTlFtWbdzabtCcqNY9WfbtAnqzl3Fa5QYn+DBnkdSh/qUtuzEu/ych3G2mzPsI5z8rE+2dqepYveXgbPJxvcqvvkNzXok1Xu08MVO79GXofSp7q94vlovpLMJ99OdXV9MtvZD4CdfbsTb7btt01OsX6b7X5G/bVn727ZbyMupe/LZmdLvMvLdTF2NnzeJD7F5oCs7fDsAw3Nfbz9ZIvOYx50P9mHHB1uYj/ZULy31whvdi8wb5BONdYutXkV8tXbU7ns8yp1x4Bnn2PvGPhoYvs8zKZ51yB/znv8UXtluP+fpHlbqj2vat7G5w8GQGNM3t3g73fy7oliW/feLNQDloGyQ8gHzrurscr8GwhYvm/TYD+zBPsrVN/Ynix677XRVtdXfsGxJ2iHeuKZZ084plF65O3T8fSI94EgTXy3tMF+mfRokXtvPT1KPbedda6O9Sh27+1XWtIjtfdW+THF61nnkpAm3ntrsIZkGfTIi29S731UeqTmMXX1aG1jwuYVjG/G8fusNVbWU+TPrPwwwrLfHOMlPV1Efjsxr+/uEA8Owmu+p9zjdS/TvH4Y8TrVPjJvP/7hHtDp/bsG+/JCPgHvozYmdCAM40L7gmc0YuYqBv9YsGUH3aeJtrJfvMP7URvWM3dfiRo7seOQ5+4If0v+0P+Y+wFXdV/JKce31V3D2hD0eLjUeFO6iLwOpQ91i8wdxZwrQRsQEyOlPp9kdMWeT8J+YH/5rqvrE8dIHq7YdaRF5uhLvMvLdXVzkMoebULfUvr7DtHV9L7xZzRojzYFPYyr7n2ldyxBDKvsCMt/VffoPLtBO8KxgMKF4yr2nCPyOpR+Xsa1VzwfzVcu2pFXU+zlnRvYgjqzI6YruN/b4LbpO+I3PTqWJenbWI/sdzxRj44JWrsEj58v8oKePc/RI+RTTzxjPToSyTseg6l/F3VH8G7b4d0O1Nln5J09+7EGebcp6GF+WfvqTALHGfeR/d2id/aK76M5i7K/W9S32DVy05/w7LUF/aY/KoZvKxZUcwps02irO6d4paM/KueOz7y17ph1oI7AtUrr0bFzinnXo5Uuoq7X2a9xKerwGw51OKkOh+LtVV+VPRVqPu3FwbHz6Xe0PJ9WeaVQqu4Neg/54UX8Dib3qc5e9fdC/vXDjh28VPZQvm9B+ZlQYudVq7yHMhRvr7rxZdYeyg/P6ZNZj+zzsvoVnt+W9pnl5TolB3UvMO+RUTxsazyrPTLeeI7dI/O3DY5npaf8nfdAhcL7Wgz2E+QbFrE/inmB40DtrVXjAHUllH6epB9yHCCfeRzg+huPA3X+HGm+iE/A8jqlwT5Asky1h2PWbxJZXmM9n/QJZXURDusIJhSTteHagLojEbiOOLiGDq7NSFxe20hrn/AfLb6vVeAfEvxW8b0P8OuCngHh/zeImb62UYYxnF8CmP8EH3sRNp+0wbI7hnUCHm0Ww1tfQ5sPgr6Gsg3tNL0eXUU36oK1r3jQqfiPuPCZtbVJuJq2R03KxMN1LBKX8RPlGz4fgX3KoSSS9SnuQzfT48zaN3p20tAz1r3t3Oeptd+E7llbbeme6punewjPuqdwbUfiMn4qfdtKw4NdtutZBQ+wffyOdh39n73LNvvhwzIexS/0YeaLxvlwqNukuiug7ijRe2U+TS/i2iZ6ryR6zfcqnd8R7R+j9rEt1T775SsE/BUC/uI9ecTTNfEuytd4GmIdzKXY/8CjveL7qGa5cM215y+cvubc6J6T4espjrWQdoy1PH9t/UHZqfE5IPhHF3wJPHoMxLwXcYn2AtwZGncbQEsKO1+KMYkebF/FpPY5Ma27Hq3rglbF47o+YD0vPxuKtpFP69R2KQ6mOvSjfWrHxgnqGuIyOjhevYbsBMbQ9v6OaB9lxm2p9mPidxXvB91+fEHjOI8MbTfpV3Ec4Rgv2SVoOxSTH/J9TfRjQPBPhDH+PTTGlU0JcDc7cHX1tJ+Xn83SU4Ovq6cYA4VyUD19+gro6VNIT1PHf2uEH58xbTeDXjftO0+dPXvtdafOj06fufvCvXef3o31nYd5isXlKZ4N9ucFwzKM4fwhgDkfYaOazlM8v52562GeIltMnuL5oF/3HeYpMo+nh3mKalwHyVPctyJ5CoRHHH2CP0b0h4J+hv2S4iO2GZMH2HTg7fsg03mDTahH+J+hOA9zB5y3wD5cUUFvJ4vLW2wLeKVXQXdeQb4QYy6T0ZFseo6QZXGxjJorGy6eKzN8Py/jKsX1hMtkgLHDUNBlY+Qotb1XPB/NV3ZjYz5rf0D0vw78yK/UiFNmjUm2JSoXFdp81xLYEhzr1n4TvsLaastXNCETD9fRmriW1T+oGEzNe8d78aHuCNWhXeT8s9lVtBHKpw4I/p1kx9G32Ps7on3uZ6y/r5uvDuP2rWA33hWRi1b8jc0TqXljrA/YjMC16eDacHANI3F1xPue/2GbHpsfM/j3g2z+mGRTsun236FB+Uw1B18FG8fya8LGBR5/fAl8GOrd5erDmpSv4VqlOQ7aoz7Bz5qz8Lqq8isp11w/tgJrrh8Bu/pxsdaBdjEmXvZ8GMryaASuow6uTQfXkUhcXttIK9qHUEx31irw85g1eaL+qLk451sfANn8B+VkDednAOZzzjyUZafGjvLDam6NOekvk59YRF4MdYHzYtinefNia2n6drJJmTSRFzN+onwv7l9sR9anuA+Yk8VxZu0bPVekoWfXs8Mq59SE7llbbeme6pune94cMdZfKVzGT6Vvx9LwYNeLP5AHVTnNqr1j9i7b7K3NMh7FL7W3Q8UqPHe/Euo4vjqeT9Or8qkDgjd6zfcqnd8R7WMOldvy4pKOwNUTzzCOWSOeKvvn7ZdROdktB17JDHFwzMC2KRQvtr1SwHu8Oi7oQRoRXygnBPy2A2/fMX+POKpi4EeQ7lwF79j7O6IPV1XQ26lov4ofCH9cwAfdOVHQuKgcvenK5ZSjf2zB88D/7yw+x8Sts2w0+xaEX4YcLtKK84jrN8u0LcLX4Zxk7KsE3XVjGWurrVimCR3xcG3VxLVs+sbxC8J7cUfbawZ75DuWcc3gOrBj11MMonTHi0Fm6RrHFEp+3p4Ataa9XhN+26FHxXdKZl6sanXoqznuNr+P+oS4jI4BwT+D9EnFRyoWwXkut+XFpV5sVhWL3AixyP8D/UlinEGdAQA=", + "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 9bfc89425f8..22bf576b6df 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 @@ -35,8 +35,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 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 9bfc89425f8..22bf576b6df 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 @@ -35,8 +35,8 @@ expression: artifact } } }, - "bytecode": "H4sIAAAAAAAA/+1dfYwlWVW/76O6+/XHdE9/7E7P7Oz0fOzO7rKY1/N6ZnY3JLR8KX+AGEQlosnM7G4ANyiGDWqy5IEgJiaCRCARSCBrFJWNiv6BZjUKmAhq0BgkfsQNfxAhJEayKipBpIY63b/69a/Oq+quW+/NTFfSqVd1z73n855z7qlb1a2we7Syc5eug4DZzs79gx2bNY7Vl4R6h8H8TO875+wU2tDeqZHZHuGtc/wH+lsXe4K/Gukf9LIxY8rHxowwfn86G+dFw93xmZf0WMiu0Yasz8y3/+bD7u+F7HeP+sTQbUTZ91cE/YZrLuP1yEye1w7IpyY6Ng03OiElV6QjqZ+OLcM15dCREB3TkXRj4/fijD8wvmZAjh3Bk+FX86NVcLaxuM1wzYZ48+bbx6bHG9Jotr5E8CyDorFmKo7VE20xdDodivlG/AsCvopOke/IvPWXwl69MB+9GvhYCnvnXYt4jGS3O/5+Ns74myantpBh6vPuJZ7nsusk7NpRW8glIfivT++OeX92b1H0n6a2OWjrUds8tM2RPhbiyKtvPB7JxuuCHBCn0dYmePyNcrJ7W9k51cHqzG4fHDMATrzH9jon6OGxkH5Pjwb/UHbuCb7qlPMyjMtyU3bD+p+PRJenf8RptFXV/3Z2VvpvQ7+OuOfp39oWRL/9+sWO4A3zNYwzi2GXX9WP/ekS4d3Ozv2DHZsJ0fPS7JyK+nbKa5eJl5po2InJR0NezqyzZZLPsoA/CjA8PxbFWIH6JQI2oTaD/f7QiHzk3F8mvpHeKaKjJXhU/VoFfL4qOyubWInD88DTMdrECtG/IuBRfsbvYthrL9gX+yUCtkNtBvujoRH5SJtYIdw4n+rCazG9M9zFa/pITeN4Zh8LYa/+usM8fatxZDMoawuIH68RHvVntrMk+h+lNozFhvNG5Zv96JwYK1C/RMCyHzXYNzQjHzlnVgn3XBzcW56ska45kvWKoJWvEwHL8cxgHyd+1+LwK2W9RnyjnjlP6ozgX43BvjayD77SIr6SEXQZPbcBHzXRciEhWn4+O6e5wBPZb+W7TU/Kd+NaqjvM83B7iCLTHR+2ALjVegLx4zXC4/rTfNiS6O/5bsOZyvEDYVc+1/EMd+EO5Zi3a+6n5jjiWC7oh/mr3U8K+rWgHeHfk50xf1U6xOcXrEOUYzfrYzo8RvRuZ9f9gx2Dsjo5RjI4JuBRTyazJdH/NmrDuWA4cS6o2hPXOyM9m7nUIn6QX0XPopAdrwM5518QsuGc/0niN9KcljH1dsIdqc532bNFlPUCyXpZ0BqoXyJgWdYG+1th/LJWNj/t8M11WjUXI/uSnTrdejYe1umOCR7bBI+/0yOhex/PzqpOp2wG73GdTtnMQtA2pM6Gh+9xPXcdeFE1uPkCXv8w7PLK9ZAT0D9GLDhOPLK8ThCPJwT8cYDhtd26GCtQv0TA8trOYP8sNCIfOV9ZFkrfWP8q0vens/PNoG+uf+1X31z/Mti/Co3Ix9V31fwc/Vp32Aj9rn6VTqrqd0n053UOxiHDeaPyzX5MzZEQtF0jbJEf++dm5FPKj2GOarLA5+FFedUz2Rn9WFl9cF0K6cS+o+TLdSmD/VJ2nlT5qjoU8/e17Jyuj76c/Va+yOSqfBGu3brDRmTizsljjpzKzsmqvshwpnKcau3K5zqe4S7coRz31lzWaWyv5nK8oB/WXFTOhP2KcqZvZudRNZdjAFclLt9B9G5n1/2DHQNPJygjxI/XCI96Mpktif5cc1FxGefCYthrU0V1PNSb2v+SEPxshkPFCLWOQxp47a/qjEHQx7BHC2hbymiLvVZWMeKYwxuv/VEXvPZXOjN+1iPxw34J1/7rgsd22DvP0adx7D4GNsNrf1WLxHu89ldxQPn0VsHZ8PA93u9zvIax2FeUrSMY/Gkx18wWTkL/GP5N+SuU/Uni8aSARx/G+fcJMVagfomA5fzbYO9tNSIfOfdZFkrfXh3B4O+/ifTNdYT96pvrCAa7NQH6VvmKyUzlK5gzdIeN0D8om3/sV79Loj/n7hjT5qkNY4jR01QOd/sImZTJ4XCOePsJsS/2K7Of0GBf3GpEPtLmWRZqf6pXYzD47xU+rqw+uMaAMhuVPyJsUf748gmQb4/oDfXhvcjPxGoc+wrLrMaxH2UfWd/Ym5d4X8yPZUpJ11M/kP1Wft7ssuq69FTYHSOGT7sTcKscHvHjNcLfCTBcW8D++/XzuGZ96lDGrox57V9VxnaNOWl6zXvAsc1g3wRz4fWOnrw6m5fzjENPGE/q1NNJaqua8+Bc4DbTC9bqFqnNYD8IOnvzoc5cnfF+DfV8qSfGjFF7Mbq6BXwYbW3BB8ogoXtvh3yLay/rQnZ4j2svJwQ93ljqXTvPz1strAttNcp6M2V/i2w9J7thvm0D2qaGeVlsAP93kJxw7q9TG859w61qhqdAJiz7GPa3kY2H9oc4+f3MDWiz3+mR0L33OvZX9f3MU4IeHquodtkm+gz+Axl9kf2bzPkNV+qrP2INRJ/Rexu0nSzg5cPES6x6seJlXfCi7Jrr5Egjzg2Of2WeURj8r4PN8Rpz1HMb7xkF7xNYJ/zqeQY/9/oY6Wgcz7Ex1xiXjj7u6GhUfs06QhliX7xWtUXWkcF+YgJ8guKN9+CMOycx2qrmJH/ixAQ1P/Eex4Qye4JGvXPOtvHpCdI/0tvQHixX/15OUFb/n60xJ1gX9ET+psEDRuuGoFXRsyjkg33xOhGw/HzEYP+O7PR0HH6lnZ52eGM73YhEV4toQTtFnEZbW8jJfqN87d4/OHaq1p14z7NTzu2x33YtstncYtkgnW1Bp1cjGMe67AzQmAzzbWehjddl1oZyVeuy09SGeY3hVnsyzoBMWK830p6Mrzq2XXVPxhlBD4+F9OP8WyD6DP5r5NuQr9i+zXBF3kf0oDdHlUwXhSywL14nAvYUtRnsf5Osz8ThV8r6jMMb75tCu+F9U2eEDIyfs5H4Mf2dy8ZDGz8reGwTPP5Oj4TvZRNNzVH0jx1xj+foaUFP0bV6NrAg6G0VnEMoty/qruy6aF8U7xM3+BmQC++TOU+0b2fX/YMdO/Xpu4lHlu154vG8gL8bYHjPwF1irED9EgHLewYMdqndiHzk3D5PfCO97GNagkfV73gBn6uOTdwTh+eBp2O0CcSP1wiPejF+F8Nee8G+2C8RsPyOrMHe0W5EPtImDJfKN01m6pkUzrvusBH6B2Xn8H71uyT68zN1jBWGsylfd9cIvsv4Opy77OuU32QZJQKWfZ3B3j8Bvi7yWvyCFzsRZ1Hs7As/WdbOjd8ysep8AX60cfZLlybAL3nyxbo2y9f2D70g4yHNoR7MfitfZ3K92d83rfKOF/o6fJ702KEcS73j5ckxBG23nIdhm8FeA5t+WdsfD/eoFL0r+woY79WObr09Kijfbtanqb3Uo3RVZi816o91i/15nzXq1nCiHNUzO+vDvvg1Tiyo+pxU7WkK1E/VJHgfk8FepVgwruekj0Wwz0jP7UrbJ+LHa4T37BP78763Ivt8bB/2+RMTbJ+PT4B9KllOO3xzzUy9fxr7fRq2OayZnRQ8tsNem0N75Wf3Tzg1s6rPlpXNqD2SrYKz4eF73r463l+B+xdUjYxt1/LQd0OMfUc7D2NjvtOpmWwAjqb2eSLvGySHDQGv9nmabZ8UY4Wgcxb17hL7gnfRfI+190LNd8OV6vLJAl2+5xbVJe/vQVjOPw32V9uNyEfq0nCpfMJkpvIJzCG7w0bod/WrdFJVv2ovLa9l1DuKOA+8+M5+v2gtzz7U4H+jYv6BNHD+sd/vaHEN12CfmoD8g5+Bh/rwDrz38CPzfKlF+ELYG8cR/2zYq/8690eUsbn0wL0cPEetr/e+bivs9TUdca/tjNWpcazbahxrvcaxLK6oOlOr4Gx4+J63T6ioxvhZyO0+2R7Nl7KRsr7d+24D77VlelWtj/3YZ8iPjeM9/lSO/zhBcuT9/d73Lwz2bycgP/Vymsh7yC6l4fkx5z22BPAW6VetBavqV9VIOKdRuQDaoMpp2H+Nyj9MP7Hyjy8e1j/2dbA91V3/+MotXv/Y+V52hjidV18rWDM/e7hmLsxtWFbfmIA1862km5aANV9cZ+3gDIwfQ5YbYa9skKczxO8ZAb8BMBxnsf+d1FZUO1jNfAPb+Fx2/7AeuttWlLevdPLyGVc91HQZsw50TNhFi/qEUK4OpPAV4UdYzsMM9k7Swzj2ySveOA/DHI3zMJXnNvWOm9l60TtuRls77J0b6Fd57twNNrNa4lvaam3p1QTq/E6lyvfmCM/JGvF4dZlR+R7/3+INwLOdnfsHOjYf4XrLyyGXvFAQO7ac2DED9MeIHR2QgXoWPkMynhHwqDeOHS0xVqB+iYDl2GGwz+s0Ih/ps2Yc3tj3dCLRxXpA38P10/RoCzmhHhK69wLH9/Bc5Xue72mF0WPNibEm7d3CnOyG+bZZaJsa5mWB3zfkdwtV7UX5O8Od+pJfyzbLsS95heNLxrF3CG1gv3uHbL6tibEC9UsELK9LDfaHJyAPrbo3zPhKj+6wEfpd/SqdVNWvV/dUOaDhbCrPU/U29W2NqvW2RxxfW/X7WmuCHm+ssr4WZZ0eXWiL7Wtzshvm23Ctz74W1/X8vwuM77I1QYN/o/CrSl5Gs5q7KPNu1qepWgr6DbV+LVNLQRvzain8bTzsxzl47O/QGF1F36Ex2tqCD5QB73l/izN31xzZGS6U3ZygpyWuVUydJXijbwrgEWa9gJ+3Az9vK3hfOAnaForGfKeTi5wjvraz6/7Bjh17Pxt2D2Xv50hu5wT8WYAxftU74/xe81qBPHBucJ7yLspFzsaRj8xFzhJv3nyN5Kf6rDecr2eEbNtCTqjzhO69t+H5WvZbggb/gQnQv4pnxmvVXDQS/QMvp1kTPHn+APXC8Qz7n3Lks+bIZ27C5DMXST4b2e8y/iP2N2+U/1Brh6r+43ci+4+e6Lddj2yuejpuCzo9P9DEOuAdNI9y3zkZ5tvugjZeB+B7w+yn1ToAa2RnoR3hn3ZyGtRrjDmtvh+CeQz/jwvkH/videLIir8L8SmKUeN4R175GJNBT/ASw8eYPNDHKPm1CZ71wPL9TI0+5pygx8tR0A/yd7UM/nOkf+Qrtv75WwLKlyHP/P1ElRvwtaodblCbwX5+AmRRZi7EyiO9uaDWTVXnwj9FngsR4+01z18vCDpVvEU9pkcX2mLHW/weB8fbe6CN4y1+B4N9Dr6nq+ItxyOD/7KItzxmgDExJnE8RHy8Zp8j/DOCF84F/o18QKSahvQB5xze+HsykfIS9xt2iNNoaws5ed+w+w/HB6jn0HiPfcB5QQ+PhfSjn+LvkBv8/06A/svOBf4OpDcXzhXwq+LhTt9uXhbjjIfeXIilIy8eIk6eC2Xj4VQm36bmQgvGKvu/WFDW6dEd5sfazu73D3Zcj1lPU8zKyW6Yb7sX2ixmma1gzDK4RSEn/n7avSEKbzt2dJ/JMOzqAXEabW2Cx9/XZUH31hw7Ut/wwntsR+p7bnxt+FHOXAM32BPkQ5Cn2D7EcJXR/T2R6PJ0f4+QbVXdn46sex4L6Ue/wutLgz8/Afr3/KDK3Y3W++PQulP7eQ7gVjmK4Vf2a329b6A14bO/SD47Z6vD3d9IVyL4KapPDch+nhOi8CLtx3CpNfl9IU9XrNzIm393C/m1hWxzaz+696DjP6quye8T9PBYRf6j6Bna80n/46hPev5jFe6dLuAZn9sjzGoBzy8EnbytQCdFa+6iOt9LYEyucUeaU5vs59pAM+KcKZBbCNWfadxHbV1oM5zmF5NhHL5Tfr7l1F8sX7W2+6FtOmtbCntjEP+vS5Nb0Tdf2aca/CuFLbSofwh6zWnzQ63LsC/CqjUn/+8Bg301zXfkJ/Z85/mL9LMdKvka/Gsc+ap1nbemR/qwL+ufYTeozWCvToB8FW+8po/1DgDbeVE8MtraQk5o5wnde60TT1vQryPueWv6VtBjIf0YczkOGPwbbhD9r0Wiy9M/5yzpUVX/b2pY/62gcxHeQ2j0Fe0hXC3g52edXGQW+nQEXWyDBv+Ek4tEssdNlgPmIqdJVopHlPOkrRnRTu4n+hU85l48JzGH99aY56mtO9w7ZhN51ot6u3SgHacH1wVRt6tAY0w/2CJ5Ff3fK/Y3Zddv76rR36wKetT7TLPUhu8zofxxHK5bmZyxzWDfPwFrvjI204lEl2czHSHbqjbzocg2w2Mh/ehPec1v8E+S/hFHbP0bLnwfT9kCv+uOejlJbZzLIm+zkXgzeudG6ICfXeEzXtzrys/JP1bjs6uOoIfHQvpRD2xDBv9xsqFYz8uVDc0V8IDyQJ55X1NLyCME32em5w1qM9hPkCxira2qvl89TW0oE/4mhDeHYu+FMJ9Qdi8E+iuMhwnd+9PIc0i939wqOAcaowiPWiOr3OugeNjnI05VAz1CMNae/ja7fDaTd+rb/5LetbYx/9pZm0Rakw7YV4eg/URRTR3h0S75XetZMVagfomA5XetDfbz3UbkI/1K0Z6/m1k3LQHrfQPM6FPvseB3DbpZn8jvc7jvrar3GVt0jfDee6vrQnYqxhjOpuKIegbGONOjLXhEmbHP+lcnjnTCXtnhPfa7nI+OGkv5cGWLKOv06A7zeLaz+/2DHfKd85zshvk2tC3e+4p2dDvJSeUjKnbhM8DpzJGy/v7zMObsgeVvBRnsNycg5tTpa8ehX6WTqvpV36jg7xqrXFHNEaMH54i3FlK+fJXalB+bFD9vtFX184uZbJSfRxvriHveeoGfFcwK+lEPvOY2+LWMvnHOTWU3TddclP5ZxiFU1/8JR/8t6FembqfqiJ4PKFuvYB9f9IwcYyrzeZbsKNb7xcqO1h3e2I5iP6M0Wso+o1wXfKB87d69DdmRGqvsPh6UdXp0qW07u98/2CHzxZzshvk2/L4m54v4jIS/B1c2FrL9dURbU3skVN1L5b1V614POfZXdb3CvkGNVRTH+Pm0wW+T/xnH8wdPHsizt18I++K18sWnCmTxkgmQxUFrx6qW2NS3K8wnFH27wmhrh70+BH0Nf2/75c4cwrnXEfc8H25wsWu6LcIT67vF7BPUN7/L1I7fmsn7+v9WpnW8jfkjoJOmvyOh8n/knWuIo9aFvI6fEWMF6qf2eXLt2GCvJY3Ix30+F3k9sKObUc//itZfCI8yZd0kYqwg+jHsfmvHCeDoZn3GaefI037tXH3Hx6s3GM6mcjG1JvdyMeQRZcbz8PEac7FE0OONpXy4skWUdXp0h3k829n9/sEOuRbIyW6Yb0Pb4rUA2hHXjlU+4u2zSmPOewtizs85MedW8GuJgOXascH+YtKIfGTMMVx1+tpx6FfppKp+1bMmrh2X3Yto9OAc8fbuKV/Oe7mUH5sUP2+0VfXzH3L8PNpYR9zz1gsoK7wuWzs2+CcnYG6Wqfm1I9Hlya9NMg5hV/8of9QZy/c3G6r5KVsqWzvGvtivTO3YYH+P7Ijn8nZ23T/goeyI6W8RjV1oK3r/7Q9gnfkX5M/QDm51f/Z0w/4Mx7oRath15K1cw14VchqVtx7a8O7BNvw3hzYc3YbvyH4r++P9XyjDGHak9uIjTqOt6l78Zxw7Qj17ulc5OecdbUE/2ho/TzH4L01Ara+M/mPlCp7+EyHvqvr/akP6H1VL42dR7QL68ToRsHcU8Pks2dFR6BPbjo46vDW9j9RoKdpfxHZ0VPCB8rV7/9OwH8Gxyn5DdZz7SHOyG+bblqGN4xHak5dTec+x2P7UXsmewNfUvgDEyfvbyu4LmJ36zrmO/W1HBT08VtEam78NuvO+a0bfJOwLUPJAnley356/4mvli08VyOI2ksWk+GLeF4C6530BykZi69b0p/YIrgoeq+4RvNOZQ+i/OuKe58MNTvnCVsHZ8PA9b662Cc9ajXhQhjwHuJ6EtZop+I15TtEeAsPLe0zSYzs79w90DC4kRPerMiLT03Om8rwYvc8F2/D+353JRj2PwOd43WGez0jr8J3nEaNqi0XvDiM85tv8PAL78z68m7H+8JDjKw7rD/XUH8x33Mz1h5c6dhR73aBsctLWDTnZDfNtZdcNXZKTipkqzhnuVEWPF8SFHxJxYZw+XX2foqpPVzVl7Kv8FMJ6e6P2Gx9j740atR+jzN4o73n9nJDdzRwfX3cYH+2IFh89v8bPmFT+jn5NxVheK6Ie+J2xm9GGnzi04eg2vBHybVVt+GbODX+p4dyw6NkK1/QM/leojjWOZ1O8B+R9sJb/qOPbmrYRtTfJs5Gye5M+OMb1Q9n/gzPO9UNOdsN8G+Z87KMwfvBzh7LrB9xf+dHDOLtzcJz93cM469pwnXs59htn2c9+DvzsH0+QnzV7LOtn0X7RH/D+908d1mlcG83JbphvK2uj6ySnsn7WcKcq+tyhn9052M9+IbKf7Yl+27XIZnCNZYN03gg+3KtjYh7F88PalJ9Wz2C9Oqa3t6gp/2z8lPXPyD/KKaF7X6nRP6v9QJHfYbjqyUfFC+b/3ydgTwHP0VHPeNk/PevU0iPxM2C5h6D3hTGPaj8A2qr3LTd+/l+0ZwZjIuv7GxO0hwTpZX8yH4ku1gPOF8TJ+6nK7udrZZth6thPpb5f5tkRwvNeJM+O+N1NhN0Ims9exmfs/W/KjpYd3tiOYtl3i2hBO1LxtS3khM8hE+atITtaFmOpOKZkjX09/5z+5v3FBnv7BNmRl9/EejfSsyMVv6va0UnHjm6A/GYnf18RtHp2ivLBvspOEZbjpsHeTXa6Eodfaacrzcj64aZlnRTI+rkk60l5d4X3ueJa39aGCwTL4+M5hPwaxg6ed9MA0yY8vRrx9ACGdWN7Hn85IyZNIy9P78K3AEfZ/N3gHwIf5e2RNJqq7gG5Ub/Joep+i9nvm7ne9D1OzDqs6x/ukSz7HPwHa8x9brU9kmVri7aXSPmjpnPoUTUw9kdla4SP1OiP1H4+HqvoHSl+19fgf5zypVi1E5Uv8bdFvDVU7Hd9lf4R535rxG+MvIZqiWsbq+w7mijr9OgO82NtZ/f7Bzuu+5GnyY/kZDfMty1Cm/kRsxXMDTmvWYS2eeAtvV4KUXhza4NLgtaqtcGhY0cop464x3Y0X1J2k1YPY9mVrWP8Qo2ymxP0sLwMP9pol9p29tuR/0X5x/a/i8SbWiuq9Z3ZT5oHPpl1upm/ufl+x35w7dgR91iOas3ljVV2TYGyTo/uMI9nO7vfP9jR2L7yaSEnZYu4r5xt0au/oOz5PeOuwN1UHqL2EiVCTlX3Ev22Y8Nd6NcR97x1McqqaKwbYV3s7SVC+2YbVs+7lA2zfaMNG25ltzMgE5Z9Uz7UW0+X/v5bjXnwjKCHx0L60UaLvnn0SYrDsdab3vcseb/jp6Fe+vfk27A/20ikGn+f41TZb16yzQbi1+591rGRFvTriHuejbTC6LHKrpVQ1unRHeZ5287u9w92SB+Vk90w34Z+l32U+o6l8lEtakMfZbhH2SLHWbSLHuFiuyjSqdIDPkNMj+4wP9Z2dr9/sEOuWVHWrAd8dsNr1sSRE8qwC7w1MZ+NlrLzeVrwcV0WdO9LNc5nzjOCuObaFsZk9q1fJX/P+eZ2dt0/4KH8Pc+5FuHmue7NA7SV9OgOo/Ah50HV91wWBf8Ih3wnAnaK2gz2v0iXnL9v1yMDqUvDNQf84bqG5znWXnjdsQBtXLc6Eoknsz+rBaAPQJxGW5vg8Xd6JHTvW44PwJjrxWFVt1oo6Ie+C3GpOs+cwKXmGOoiPbrQFjvmLwGNPMewXsgxH+tmxpOK+VwDwhiNdUuWl4oTlscuiDb8rsW92e+Y8rz8wHds+zqt2fi2t4CPLrQj/EqmC1wL2Ll7ADofvXxl89HBlUevXLzy8MNb166wXwkgu7kI+K9cHjxw7cLWtctXLw6uDC41jv/axUtXr21dvNJ/ZDO9vDAKv9mo2X964PxMD7N/818Mj/tHEP7OTMepXW7A3Ls+lsCXwg1gn3h6zAAtNfqDC8bbNNJB9CD+RQFvvyPTOvBonRa0Khm3Cs44Ft6bHubv9YZ74VFO04R7FuGpbQ7auoRnPrtGW8OxjI6E4DczuzE9zUAf678k8KPOGJfCj36Xx+qIewaf2vZ95PO6gLvOWIfzCOd4zn4AdxEfHcGHku9cibHmnLF6zlizJcfycCOtXRrf7GeqYPwewS9k12if04Iets/ngy98xUwexsb8boB5MflLzz8fwTYBj7kewxuvKc7vI9+7CHhi+DNFN9qC4VcyqOrPDNcsjVX33KtTJ95YR0qOZfJE/aa/X9OMri8wD+2g55nhN3qW4tCzY3uLQ1+mhr8O2zNcTdme4s2zPYRn21NjLZYcy+Sp7G0hjgwG7NdDgQwQP16jX8f4Z33ZZ79+Jj+OkhfGMM7RlqBtltqOQts80bs83EsvjrVI9C4TvRZ7lc0vCfxHCD/iUvg5Lh8V8EcFfGor10imU6Iv6tdkirlOrs8wP57Fa5TdlKAlIfifBP/5UyXicwr3Vgeuqh/pDvP3RuXkBl81J0f/lB77zcnfcgPk5G+mnDy2b56i8fEe0/ZWyOHrrhNceOCBSw9euNrfuvzwtUcf3hqUrRMcriHGt4Z4N/ifjxSsId4DMO8bwxriw4driJt6DfFhsK+nDtcQwZPp4RqieKz9rCGeukHWEAiPY3QJ/gjRnx4YZzguKTkizjI5+qwDb9f4LEetTxKC/yPK8zCv5zUF8nC0gN5WKLemWBTwyq5S2/l9ioWYc5mO5sLeNUII5XIZ9VzAxuLnAgzfHebHyuX1NJbpAHOHnqDL5sg84d7O7vcPdgzK5nyGPyH6/xziyGcq5Cmj5iT7ErVOTHE+MwG+BOe64a8jVhiupmJFHTrxxpqvONakxgeVg6l1r9mAiqmqbsS1IfOr6CNUTE0I/l/Ij2Nssf5LAj/zWTbeV60lpfP2C+A3nilRJ1LyLVsnUuvGsjFgtsRYs85YM85YvZJjtUR/L/6MM2Yg/Ya/Dl9ouJryhYo3zxciPOu5bA3EG2ucOkW+2Ucp34l23SV45TvnBb/Kd7I9oW/htcp+fef/3QC+8+tiTwD6mTK5luf/UH9l9D3vjDXrjDVXcqyytoY+IT1MJ1PBtzW2TbQZtY7jWt1sbxfPiV4exsacB5il7Ldaw7DulB2pOrNal2E983iGc5w1FbQFrqkgTwetqUzF4W2zTp3UUVMxeaJ+09/nm9H1BeYB63k4zwy/0XM0Dj0Dz5eqekUdtme4mrI9xZtne976omzMUWOZPJW9HYkjgwH79VAgg6J6WNGeAOvLPvtiLz+OkpfaA6me+/O6bxnaOHdYGe6lV9XiEoI3ene+VwF9rP+SwI/1N8al8HNcXhbwywI+tZXvIpkq/+ftK1X1vAUHXukMx+CcgX1Tenj57LKA92S1IuhBGnG89FgV8IsOvF1j7RfHKNpP8kKynTXoY/2XBA9rBfS2CvAXyQPhVwR8ajvPy2gcV33XbOVWqu++DPKKV1bIW0f5aI4tCD8J9T+kFdcRr5uAWIdrEsNfRy6zs56hsWLlMnXYiDfWQsWxJs3evJqJl3c0XW9+LcWOSayZXAE/9jrKQZTteDnIKFvjnGJUzYvHV89DpyvCLzr0qPxO6czLVa0NYzXn3Rb30Z5wLKMjIfifJntS+ZHKRXCdy7i8vNTLzYpykTdCLvL/F1UsrymBAQA=", - "debug_symbols": "zd3drhy3lYbhe9GxDsj1z9xKMAicxAkEGHbgOAMMgtz7tOQ02xE3XOPpTfZ7Yuz27l56JFR9zWJxsf754c/f/vEff/3Dp+//8sPfP/zu9//88N0Pf/rmp08/fH979c9/ffzwxx8/fffdp7/+4Zf/+0P7/J9uX97/97998/3nl3//6Zsff/rwu+7944dvv//z55/i9vm/fPru2w+/8/av//r4oftv/kS8/Ym6fyL060/kb/5EvfkJafMT9stPfPy/v/Vz8bGxuLSdxfvO4rKzuO4sbjuL+87isbN47iy+8wyVnWeo7jxDdecZqjvPUN15hurOM1R3nqG68wy1Z48Wifj3WyXy6+LP/ptL3Ytr618X953FY2fx3Fm8dhYfG4t721m87ywuO4vrzuLPnqGqci9u9XVx31k8dhbPncVrZ/GxsXi0ncX7zuKys7juLL7zDI2dZ2g8fYb6DK7hF0Oc7PNSPvXrlIvESAojGRRJNoykYySCkehBSet6L9tkkRhG4hhJYCT5KsnXs8NZGMmgSKphJB0jEYxEMRLDSI5mrM2ybRnHVmAkiZEURjJeJPGv7xiOhpF0jEQwkqMZGw9JfH3EDsNIHCMJjCQxksJIBkXSW+NQOodyNGbLJ2Usy2aacijGoTiHEq+irIdtcijFoQwMpZ9M297v9xJuP7WF0jkU4VD0VRRfKMahOIcSHMrJtO06c6Xb8h3Ui0MZGIq0V1GW4JfOoZw8mSXGvaxkLpTgUJJDKQ5lYCjaOJTOoQiHYicjbsyyfR1mq3MowaEkh1IcysBQrHEoRyNOHrmitlCORpzOpTtiS5ucKYdiHIpzKEcHlKKPw3a5OrTkUIpDGRiKNw6lcyjCoSiHwrlm9pMRp22W1bYMEjw5lOJQxosofZkAi8ahdA5FOJSTEaeSk7JG3PN9Me9HcQ4lXkSx5dbU0aabC0pxKAND2dd386V631pdtlbXrdVta3XfWj22Vs+t1Wtr9bGz+tP9G9bu2ymZya+/1aPdB/Qeugzon27geEeKcCjKoRiH4ucot9nOuWOY6VgowaEkh1IcyngRxZYp/NE4lM6hCIeiHIpxKM6hHE3bxzaOFss9lpEcSnEog0KR1l5Eyb5QOociHIpyKEfTNh+UWg9b51CCQ0kOpTiUgaH0xqF0DuVk2nqb9269LxHXlUMxDsU5lHgVZT1sk0MpDmVgKHIybV1jUpa5OJHOoQiHcjRttT0otVCMQ/EXUZamKJHgUJJDKQ7laNr6I23XmQQ9mStR8+Z6LDfsRJVDMQ7FOZTgUJJDKQ5lYCh2cugU7fFQonVAacKhKIdiHIpzKMGhJIdyNOLskSsuC+VoxM31RT3i6xt24o1D6RyKcChH09b647BdRvxuHIpzKMGhJIdSHMrAUKJxKJxr5jgZcSl2L5uyUoxDcQ7lZMT98qkUy+7gEsmh1Isoy7M6JAaGko1D6RzKtrT9Ul23Vret1X1r9dhaPbdWr63Vx87q+/pWvlTvW6s/fa7aPQq8Xbw1ZLbqhSytevJ8d8n7UYxDcQ4lOJTkUIpDGecoVnqnWNkyin6+u+T9KJ1DEQ5FX0Tx5bAdxqE4hxIcSnIoxaEMCkXb0bQNm5SUhdI5FOFQlEOxV1FyoTiHEhxKcihH07YelLEetgND6Y1D6RyKcCjKoRiH4hxKcCgn03bMjURs9CVte3EoA0ORxqH0F1FkOWxFOBTlUIxDOZm2w2RSluYFleBQkkM5mrazP+tGsYUyMBRtr6KMhdI5FOFQFEOxg8eKW7+P4tzWtLXOoQiHohyKcSjOoQSHkhxKYSh+9OuwdKbt6AulcyjCoSiHYhyKcyjBoSSHUhzKwYsPb33upNuWpdcaJ4dOzdrjvbVQlEMxDsU5lOBQkkMpDmVgKNk4lKMRN+Z7e1umevLkySxzJ93bj8tMQgaHkhxKcSgDQ6nGoXQORTgU5VCMQ+GkbXHStjhpW5y0LU7ajqNpm3PoJLVcHY7OoQiHohyKcSjOoQSHkhxKcSiDQrGGSVtrmLS1hklba5i0tYZJW2uYtLWGSVs7uY7f9XEbU7UtlOJQBoZych3/FeVkxPXMOS243A+yk4vnryjGoTiHwsmVzsmVfjRXUiYlv15ZatI4lM6hnIy42+3BB8UWinIo9iJKLWfQyRXrV5TgUJJDORlxv7ouzhSz9Nf06NJfn5Ol5itFOBTlUE5GnJk/KMt3kDqHEq+ijIWSHEpxKANDOdto8euUzqEIh6IcinEozqFw0tY4aXu20SJ1UmqlDAzFG4fSORThUJRDMQ7FOZTgUJJD4aStc9I2Tqbt4zm27kv7iUXnUIRD0RdRlo3l7WgnzAXFOZTgUJJDKQ5lYCjZOJTOoQiHwknb5KTt0VYln48zdI9lNvtoq9IFJTmU4lAGhnK0VemC0jkU4VCUQzEOhZO2xUnb4qRtcdK2OGk7OGk7OGk7OGl7tFXJc+404stTOO1oq9IFxTmU4FBOpm3MnVw91ouPo61KF5RBofjRVqX/oORC6RyKcCjKoWxL2y/VfWv12Fo9t1avrdXHzur7mnO+VO9bq8vW6rq1+rPn6m3gN6NgSYKn22hux8WsXr/+Vmlz92Jpy+7F/vQzKN6RkhxKcSgDQ3m6o+c3UDxtrqbONyidQxEORTkUexHFlywX51CCQ0kOpTiUgaFo41A6h3I0bWMOETNjoSiHYhyKcyjxIkot80SaHEpxKANDsaNpWw/KWA5b6xyKcCjKoRiH4hxKcCjJoZxM2+pz+VjJGnEDQ/HGoXQORV5FWQ5bVw7FOBTnUE6mbdnckKNsmc325FCKQxkYShxN28eDH2p58INH51DkRZRlFwwP5VCMQ3EO5WDaRvd7t/rtxyX4Y5ykjHuuhKw3SbNxKJ1DEQ5FORTjUJxDCQ7l6NCp5grZWlY9eg4MpRqH0jkU4VCUQzEOxTmUkxeqYz7qLdoacXVy6NTm7sXRahlQjqODhCZzQNnbQlEOxTgU51CCQ0kOpTiUQaFE6xyKUK6ZoymHcjTibDwouVCcQ4kXUZb2vGjJoRSHMjCUfjLiHk9qv+XZcth24VCUQzEOxTmU4FCSQykMRTCz2XGyuyFEdVJ0pQiHcjLiRPJB8YViHIq/iGLLiP9kd8MVJTmU4lC2jeI+V9/XsPClet9aXbZW163VbWt131o9tlbPrdVra/Wnz9W0OdqJX3+rSNzfewuQZWT0/Nr496N0DkXOUfrwWXb4cqw8vwr8/SjBoeTBY6XNnTul9b5QikMZGIo3DqW/irLMELtwKMqhGIdyMuJud9RnxLUl4jw5lDoZ/BKTsk4U+MBQonEonUORV1HGQlEOxTgU51A4A8pIDqU4lIGhZONQOofCuVBN5VAcM6DMOEkxmRTThZIcSnEoR6+Zf7kH2zJ0qsah9FdRlkFCCYeiHIpxKM+mbczdOuON6rG1em6tXlurj53Vn37WwK9X71ury9bqurW6ba2+9VwdW8/VsfVcHVvP1bHzXM3WtlZ/+lztcy25X7xVvOZ9OR+5UIRDUQ4lDlJE71s43n5cj5XkUIpDGS+iLAP7fHrT+XekdA5FOBQ7SOk+c2VdjZ9Pr7B+R0pwKPkqyhL8vTiUgaFI41BORlzPmpSKhSIcinIoxqE4hxIcSnIohaEoZxSnR0dxv1y1uXwzq3Ao+irK8h2kxqE4hxIcyraI+1K9tlYfO6tb21q9b60uW6vr1uq2tbpvrR5bqz99rsb9rbeZ/l9/q0ncb7uZjJVSHMrAUJ5ed/4bKGLzHqpYLbn+9Arrd6QYh+IHKd7nKNqXfbbz6cXe70hJDqU4lPEiyvIw6IzGoXQORTiUk2nrPtf8eawU41CcQwkOJV9F8YVyNG0fKyH98zu+ogwMJRuH0jkU4VCUQzEOxTmUkxFnNiPOlm0RM4tDGa+6DlpmiKtxKJ1DEQ6Fc/lexqE4hxIcCmcUV0dHcaNNyliG2aNxKJ1DOTqK++XC0SXihnIo9irKcjIP51CCQ0kOZVvafqk+Nlav1rZW71ury9bqurW6ba3uW6vH1uq5tfqz52q2++qjVP31t1rOVmzLZYa4nl6F/36Up1fhvyOlcyjCoSiHYgcpfd5jsb7s7VO9OJSBocjJk7mHT0rqQukcinAoyqHYqyi1UJxDCQ4lOZTiUAaGoo1D6RyKcCjKoXDSVjlpq0fTdtwfWmDSZaEkh1IcysBQrHEonUMRDkU5FONQDkacRMx1iVHL5bslh1InKeP+QC7JlgtlYCjeOJTOociLKOvJ7MqhGIfiHMrJtE2ZC7zemCz15FCKQxkYSjQOpXMowqEoh2IcinMonLQNTtoGJ22Dk7bJSds8mrZzAkyy2kIRDkU5FONQnEMJDiU5lJNpO3JSxrJ7SuXAUKpxKCfTdjy2txnLVkhVwqEoh2IcinMowaEkh1IcysBQRuNQOGk7OGk7OGk7OGk7OGk7DqattnYvq637QkkOpTiUQaGM1jiUzqEIh3I0bYc9KLFQjENxDiU4lHwRRWShFIcyMJTeOJTOoQiHohyKcSjOoQSHwknbzknbfnRsa4+h07Ir0JDGoXQORTgUPUmZayi15UoxDsU5lOBQkkMpDmVgKHo0bUeflDEWSudQhENRDsU4FOdQgkNJDqU4lIGhGCdtjZO2xklb46StcdLWTqZt13mh2j+/4ytKcCjJoRSHMjCUk71kV5TOoQiHcjJte+akLG3442Qv2RXFOZSjaZv9QVm+gzw5lOJQxosotdzyjsahdA5FOBTlUIxDcQ4lOJTkUIpD4aRtctL2ZC+ZytydU6UvX4cne8muKMqhGIdyMm1F59hWbD1sg0PJF1G8L5TiUAaGcrKX7IrSORThUJRDMQ7FOZTgUDhpW5y0raNp+xhQyvL8pjEah9I5FOFQlEMxDsU5lOBQTqat9nm7QdemnKO9ZBeUQaH0drSZTFs9LLFaOsgiL7Isy7NvFgVZDGRxkCVAlgRZCmQZHEtvIEsHWUC520G524/m7qMFRH39buwOsgTIkiDL0dzNxxiz3jh2B8dytMHsPyy1WjrIIiCLgiwGsjjIEiBLgiwFsgyORUG5q6DcPdpsZip3i9k6ZjjabXZlMZDFQZYAWRJkKZBlcCxHm86uLB1kAeWugXLXQLlroNw1UO4e7T2zufu42rL7+M1SIMvgWI62n11ZOsgiIIuCLAayOMgSIAsodx2Uu0f70GzM+yQufbEcbUS7snSQRUCWk7nrMRc+eo3VYiCLgywBsiTIUiDL4FiOtqRdWU7mbjzu24fYahGQRUEWA1kcZAmQJUGWAlkGx3K0Oe3KAsrdAuXu0f60sDl3GLHOHR5tULuyOMgSIMvJ3M02x1LZ17HU0Sa1K8vgWI62qV1ZjuZuxbS09dg92qh2ZVGQxUAWB1kCZEmQpUCWgbH0o/1qVxZO7vbGyd3eOLl7uyl88nvaHt/TVqvFQZYAWY6Od60/LGO1FMgyXmTxpU+4H+1Xu7J0kEVAlpO5mzmmZb0n3I/2q11ZHGQ5mrupD0tfLQmy1KssuVoGx3K0X+3K0kEWAVkUZDGQxUGWAFkSZAHlroBy92i/WrW5vq7W9VL9aL/alUVAFgVZDGRxkCVAlgRZCmQZHIuBctdAuXu0X61q3p+uYatFQRYDWRxkOZq7Mec86o1r+6P9aleWAlkGx3K0X+3K0kEWAVkUZDGQxUEWUO46KHcdlLsOyt0A5W6AcjdAuRug3A1Q7gYodwOUuwHK3QDlboByN0G5e7JfzVrd572tt/X+9Ml+tUuLgiwGsjjIEiBLgiwFsgyO5WS/2qUFlLsFyt2T/Wp2++OmRdd5zJP9apcWB1kCZDmZdX3c1xKbdFktg2M52SN2aekgi4AsCrIYyOIgS4AsCbKczF3RmBZ/wzIwFjnZI3Zp6SDLydyVeFjWfc/lZI/YpcVeZFnv28vJHrFLS4AsCbJsy92fy4+t5fd1cv1cvu8tL3vL697ytre87y0fe8vn3vJPn7V6n8XPvEiQKLlTotbOTnm+w+j9LM93GL2jpYMsArIoyGLnLGZyX+Vopm21JMhSIMs4aQmbllyvOrSBLB1kEZBFX2XJ1WIgi4MsAbIczd1xf695e8NSIMvgWKyBLP1Flt5Xy9HcrXnnzEasFgVZDGRxkCVAlgRZCmQZHIs3kKWDLKDcdVDuOih3HZS7DspdP5m7Lo/xi613H7xAlsGxRANZOsgiIIuCLAayOMhyMut0PsnHdN0tT6JAlpNZp+PxfbTuaivZQJYOsgjIoi+yvDHnkQayOMgSIAvoXlaC7mXl4FiqgSwdZBGQRUEWA1kcZAFdTxfoerpA19MDdD09QNfTA3Q9PUDX08NAFtD19AiQ5WjuPq6nvdb1mKNAloGxaGsgSwdZBGRRkMVAFgdZAmTh5K42Tu5qO5q7j27KWJ+iqb2BLP1FFvHVIiCLgiwGsjjIEiBLgiwFsgyORRrIAspdAeXuyf4ji/mUOwuP1WIgi4MsAbIkyFIgy+BYjvZlXVk6yCIgCyh3FZS7CspdBeWugnJXQbmroNw92pcV8yl3FrXOMxzty7qyCMiiIMvJ3M02LfnGdcDRvqwrS7zIon21JMhSIMvgWPb1Zf1cvu8tL3vL697ytre87y0fe8vn3vK1t/zYWv75rp68l68eF2/12QWW0deR2/NdPe9oEZBFQRYDWRxkiXOW0Jw7SGmuI9rnO2nez5INZDmYL7eL1PtoKWx93qymgCwKshjI4q+yrPmSAbIkyFIgy8ncNatpeWMWrBrI0kEWAVn0RZZoq+Vo7mpOi60zT+UgS4AsCbIUyDI4ltFAlg6yCMiiIAsodwcodwcodwcodwcod8fR3M3H+GUs85jWGsjSQRYBWRRkMZDFQZYAWRJkOTqn2mPOY8oyj2m9gSwns05tfh/d7kmuFgFZFGQxkMVfZFnnPKwHyJIgS4EsnHtZJpx7WSYdZBGQRUEWA1kcZOHcKzdJkAV0Pa2g62kFXU8r6HpaQdfTaiAL6HpaQdfTCrqe1gJZTuau9zne9fUpmmYNZOkgi4AsCrIYyOIgS4AsCbIUyALKXQflrh/N3cf8i8d6TeICsuiLLLnOY7qBLA6yBMhyNHdr3ifxN8aY0UCWDrIIyKIgi4EsDrIEyELKlwJZBsdytP8o+n1X/gjJ1dJBFgFZFGQxkMVBlgBZEmQpjqVAWVegrCtQ1hUo6wqUdQXKugJlXYGyrkhZNziWoz0/4Q9LvGHpIIuALAqyGMjiIEuALAmyFMgyMBZvnNz1xsldb5zc9cbJXW+c3PWjPT9Rfrdk66slQJYEWQpkGRzL0f6jK0sHWQRkUZDFQBZQ7nZQ7h7tP8r+sOj63Xi0/+jKMl5kseVelh/tP7qydJBFQBYFWQxkcZAlQJYEWQpkAeWugnL3aC9U+piWtNUiIIuCLAayOMgSIEuCLAWyDI7laC/UlQWUuwbKXQPlroFy10C5a6DcNVDuHu2FyjF7/6ut8wxHe6EuLEd7oa4sHWQ5mbslD8sb1wFHe6GuLPYqy1gtDrIEyJIgy7bc/bn82Fp+XyfXz+X73vKyt7zuLW97y/ve8rG3fO4t/+xZW3JfEVFXzxosqXtnZ8l4wzI4lqc7jN7T0kEWAVkUZLFzlhg2u+OGy2rxk5a0ack3/l0Gx1INZOknLaEPy7pKoARkUZDFQBYHWQJkSZClQJbBsYwGsoByd4Byd4Byd4Byd4BydxzN3XEfv2Rr62zPSJClQJaBsURrIEsHWQRkUZDFQBYHWTi5G42Tu9E4uRsNlLsdlLv9YO5m0zYt65PlogvIoiCLgSwOsgTIkiBLgSyDYxFQ1gko6+Ro1pVMy2irxUAWB1kCZMlXWWy1HM26+SSf24/rWEoGx6INZOkgi4AsCrIYyOIgS4AsCbKAcldBuWug3DVQ7hood+1k7va5i2D2dRfBMANZHGQJkCVBlgJZBsfiDWTpIAso6xyUdQ7KOgdlnYOyzkFZ56CsC1DWBSjrQkCWo7nrc7x7+5NXi4EsDrIEyJIgS4Esg2PJBrJ0kEVAFlDuJih3E5S7CcrdBOVugnI3QblbR3O3dFrGOndYHWQRkEVBlpP5In2urZC+Xgec7D+6tBTIMjiWk/1Hl5YOsgjIoiCLnbRoTIv31eIgS4AsCbIUyDIwlmwNZOkgi4AsnKzLxsm6bJysy8bJumycrMsGyroOyroOyroOyrqjPT9XlqO5mw/LeMPiIEuALAmyFMgyOBZpIEsHWQRkOZkv2u5P2kjtsloCZEmQpUCWwbEc7bO5snSQRUCWk+M61XkvSy1Wi4EsDrIEyJIgS4Esg2M52mdzZekgCyjrDJR1Bso6A2WdgbLOQFlnoKxzUNY5KOtcQJajufvob9R6w2Igi4MsAbIkyFIgy+BYjvbZXFk6yCIgCyh3A5S7AcrdAOVugHI3QLkboNxNUO4e7bOxNtc1m7TVIiCLgiwGsjjIEiBLgiwFspzMXdO5F7DZep/kaJ/NlaWDLAKy6KsstVoMZHGQJUCWBFkKZBkcy2ggSwdZBGQB5e4A5e7R/iMLmZay1RIgS77Isu7XnEf7j64sA2Opo/1HV5YOsgjIoiCLgSwOsgTIwsndapzcraO9UN7mmMFlmVOto71QV5b+IovKahGQRUEWA1kcZAmQJUGWAlkGxyINZAHlroBy9+izmNxmX5ZHrRYDWRxkiRdZ0lZLgiwFsgyO5WiPmFfdLdHX64CjPWJXFgFZ9FWW9ZrkaI/YlcVBlgBZtuXuz+Vrb/mn0zHHv986xP+fb/0ieb6P690kHSMRjEQxEsNI8pwk87FLTGqulgJZBsfi7aRF/GFZs9Y7yCIgi4IsBrI4yBIgS4IsBbIMjiVAuRug3A1Q7gYodwOUu3E0d/1hyXU2IgJkSZClQJbBsWQDWTrIIiCLgiwGsoByN0G5m6DcTVDuJih362jujtmpWm2dka4OsgjIoiCLgSwOsgTIkiBLgSyDYxmg3B2g3B2g3B2g3B2g3B0nc7dk3ieptZu4RoAsCbIUyDIwltEayNJBFgFZFGQxkIWTu6Nxcne0o7lbj+/G4aulQJbBsfQGsnSQRUAWBVkMZHGQJUAWUO52UO52UO4KKHcFlLsCyl0B5a6AcldAuSug3BVQ7goodwWUu3oyd4fNTo/huVo6yCIgi4IsBrI4yJIgS4Esg2MxUNYZKOsMlHUGyjoDZZ0dzLpq/f7eamqrJUCWBFkKZBkcy8kesUtLB1kEZFGQBZR1Dso6B2Wdg7LOQVkXoKwLUNYFKOsClHUn+7IuLUdz12ta1n0zRgTIkiBLgSyDY8kGsnSQRUAWBVkMZAHlboJyN0G5m6DcTVDuFih3C5S7dTR3x71s9XUd/CgFWQxkcZDlZL70ntMi63XAyf6jK8vJ/qNLSwdZBGRRkMVAFgdZTo7ruum0eK2WBFkKZBkUi7TWQJYOsgjIoiCLgSyYrLtZMFl3sxzNunHfz6OkjdUyOJbeQJYOsgjIoiCLgSwOsgTIkiALKHc7KHcFlLsCyl0B5e7Jnp8SsWlZ7k/fLAayOMgSIMvJ3JXHHLykrJYCWQbHcrLn59LSQRYBWRRkOZq7NecxZcRqcZAlQJYEWZ7NOon7PioSuZR/uo3nonzfW172lte95W1ved9bPvaWz73la2/5Z89abfcHoWlfv0SebgKRuuu19bV831te9pbXveVtb3nfWz72ls+95Wtv+bGt/L9ur/77mx8/ffPH7779++0Tn3/5j+//9NOnH77/98uf/udv99/88cdP33336a9/+NuPP/zp2z//48dv//DdD3/6/LsP7d//+b10j4/SMz/DP79uaR9vcw7j9tq+/L612+/db6/9y+vqH0X08+vPh4BI6ke5pcztdX55rbd6twHr7fXnf+Tbrz7/Pvvt9fjyOuWjmNjt9Zcpfmlx+x8tPgO+zLPfMHX7E6vd/q63v+//Ag==", + "bytecode": "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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_regex/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index f126b2379c1..785317c98d4 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -23,8 +23,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": { "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/slice_regex/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_0.snap index 7bf68b988d4..5d795f64b73 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_0.snap @@ -23,8 +23,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": { "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/slice_regex/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index e5cb2af1ade..4213b1a93aa 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_regex/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -23,8 +23,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": { "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",