From b0c09b6449a5ae82fc7d5d3cf23f37e206e53d40 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sat, 4 Oct 2025 21:02:05 -0300 Subject: [PATCH 01/18] better tests to measure cost of contract calls --- sway-lib-std/src/codec.sw | 12 +- .../const_of_contract_call/snapshot.toml | 7 + .../const_of_contract_call/stdout.snap | 1054 +++++++++++++++++ test/src/snapshot/mod.rs | 86 ++ 4 files changed, 1157 insertions(+), 2 deletions(-) diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw index 1b45e57a97f..fdfdf421240 100644 --- a/sway-lib-std/src/codec.sw +++ b/sway-lib-std/src/codec.sw @@ -3380,14 +3380,18 @@ impl AbiDecode for [T; N] where T: AbiDecode, { + #[inline(never)] fn abi_decode(ref mut buffer: BufferReader) -> [T; N] { const LENGTH: u64 = __size_of::() * N; - let mut array = [0u8; LENGTH]; + __log(LENGTH); + let mut array = [0u8; LENGTH]; let array: &mut [T; N] = __transmute::<&mut [u8; LENGTH], &mut [T; N]>(&mut array); let mut i = 0; + __log(N); while i < N { + __log(2); let item: &mut T = __elem_at(array, i); *item = buffer.decode::(); i += 1; @@ -5376,8 +5380,12 @@ where retl: u64 }; + __log(101); let mut buffer = BufferReader::from_parts(ptr, len); - T::abi_decode(buffer) + __log(102); + let r = T::abi_decode(buffer); + __log(103); + r } pub fn decode_script_data() -> T diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml index e29e5ff922e..e5d4b87659f 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml @@ -1,7 +1,14 @@ cmds = [ +<<<<<<< HEAD "forc test --path {root} --release --experimental const_generics", { repeat = "for-each-block", cmds = [ "replace-file src/main.sw \"fn cost_of_in\" \"fn isolated_cost_of_in\"", "forc test --path {root} --release --experimental const_generics" ] } +======= + "forc test --path {root} --release --experimental const_generics --logs --ir final", + # { repeat = "for-each-block", cmds = [ + # "forc test --path {root} --release --experimental const_generics" + # ] } +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) ] \ No newline at end of file diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index b0918dd0684..5fdc669d7a2 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -12,6 +12,7 @@ output: tested -- const_of_contract_call +<<<<<<< HEAD test cost_of_in_bool ... ok (???, 14600 gas) test cost_of_in_u8 ... ok (???, 18427 gas) test cost_of_in_u16 ... ok (???, 17781 gas) @@ -41,6 +42,38 @@ tested -- const_of_contract_call test in_enum_u64 ... ok (???, 15575 gas) test in_enum_u64_u64 ... ok (???, 15362 gas) test in_enum_u64_u64_u64 ... ok (???, 15551 gas) +======= +<<<<<<< HEAD + test cost_of_in_bool ... ok (???, 2082 gas) + test cost_of_in_u8 ... ok (???, 4331 gas) + test cost_of_in_u16 ... ok (???, 3948 gas) + test cost_of_in_u32 ... ok (???, 4389 gas) + test cost_of_in_u64 ... ok (???, 4397 gas) + test cost_of_in_u256 ... ok (???, 4240 gas) + test cost_of_in_b256 ... ok (???, 1954 gas) + test cost_of_in_str_0 ... ok (???, 2505 gas) + test cost_of_in_str_1 ... ok (???, 2806 gas) + test cost_of_in_str_8 ... ok (???, 3229 gas) + test cost_of_in_str_16 ... ok (???, 2837 gas) + test cost_of_in_str_32 ... ok (???, 3035 gas) + test cost_of_in_array_0 ... FAILED (???, 1095 gas) + test cost_of_in_array_1 ... ok (???, 1589 gas) + test cost_of_in_array_8 ... ok (???, 4192 gas) + test cost_of_in_array_16 ... ok (???, 4563 gas) + test cost_of_in_array_32 ... ok (???, 7889 gas) + test cost_of_in_array_64 ... ok (???, 14352 gas) + test cost_of_in_tuple_0 ... ok (???, 3289 gas) + test cost_of_in_tuple_1 ... ok (???, 3860 gas) + test cost_of_in_tuple_2 ... ok (???, 4228 gas) + test cost_of_in_tuple_3 ... ok (???, 4571 gas) + test cost_of_in_tuple_4 ... ok (???, 4935 gas) + test in_struct_u64 ... ok (???, 3103 gas) + test in_struct_u64_u64 ... ok (???, 3364 gas) + test in_struct_u64_u64_u64 ... ok (???, 3623 gas) + test in_enum_u64 ... ok (???, 2653 gas) + test in_enum_u64_u64 ... ok (???, 2528 gas) + test in_enum_u64_u64_u64 ... ok (???, 2640 gas) +>>>>>>> ce8248b66 (better tests to measure cost of contract calls) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 @@ -639,3 +672,1024 @@ tested -- const_of_contract_call test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? +======= + test cost_of_in_bool ... ok (???, 3371 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_u8 ... ok (???, 5610 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_u16 ... ok (???, 5227 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_u32 ... ok (???, 5672 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_u64 ... ok (???, 5673 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_u256 ... ok (???, 5520 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_b256 ... ok (???, 3250 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_str_0 ... ok (???, 3784 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_str_1 ... ok (???, 4091 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_str_8 ... ok (???, 4512 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_str_16 ... ok (???, 4122 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_str_32 ... ok (???, 4318 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_array_0 ... ok (???, 3174 gas) + decoded log values: +100, log rb: 1515152261580153489 +0, log rb: 1515152261580153489 +0, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +0, log rb: 1515152261580153489 +0, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_array_1 ... ok (???, 4031 gas) + decoded log values: +100, log rb: 1515152261580153489 +1, log rb: 1515152261580153489 +1, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +1, log rb: 1515152261580153489 +1, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_array_8 ... ok (???, 9221 gas) + decoded log values: +100, log rb: 1515152261580153489 +8, log rb: 1515152261580153489 +8, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +[0, 0, 0, 0, 0, 0, 0, 0], log rb: 3565715504387854074 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +8, log rb: 1515152261580153489 +8, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_array_16 ... FAILED (???, 5970 gas) + decoded log values: +100, log rb: 1515152261580153489 +16, log rb: 1515152261580153489 +16, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 + test cost_of_in_array_32 ... FAILED (???, 7884 gas) + decoded log values: +100, log rb: 1515152261580153489 +32, log rb: 1515152261580153489 +32, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 + test cost_of_in_array_64 ... FAILED (???, 11544 gas) + decoded log values: +100, log rb: 1515152261580153489 +64, log rb: 1515152261580153489 +64, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 + test cost_of_in_tuple_0 ... ok (???, 4538 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_tuple_1 ... ok (???, 5114 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_tuple_2 ... ok (???, 5484 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_tuple_3 ... ok (???, 5828 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_tuple_4 ... ok (???, 6188 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test in_struct_u64 ... ok (???, 4357 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test in_struct_u64_u64 ... ok (???, 4612 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test in_struct_u64_u64_u64 ... ok (???, 4872 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test in_enum_u64 ... ok (???, 3910 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test in_enum_u64_u64 ... ok (???, 3781 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test in_enum_u64_u64_u64 ... ok (???, 3891 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + + failures: + test cost_of_in_array_16, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":368 + revert code: 0 + decoded log values: +100, log rb: 1515152261580153489 +16, log rb: 1515152261580153489 +16, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 + raw logs: +[ + { + "LogData": { + "data": "0000000000000064", + "digest": "5fcba2633bef1c29420e0eed7b037ced8b00466b0e8f1c5ce1cad2e97e117aad", + "id": "0000000000000000000000000000000000000000000000000000000000000000", + "is": 10368, + "len": 8, + "pc": 41476, + "ptr": 67104768, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000010", + "digest": "998e907bfbb34f71c66b6dc6c40fe98ca6d2d5a29755bc5a04824c36082a61d1", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86656, + "ptr": 67103744, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000010", + "digest": "998e907bfbb34f71c66b6dc6c40fe98ca6d2d5a29755bc5a04824c36082a61d1", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86788, + "ptr": 67102720, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67101696, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67100672, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67099648, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67098624, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67097600, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67096576, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67095552, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67094528, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67093504, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67092480, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67091456, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 69320, + "len": 8, + "pc": 86928, + "ptr": 67090432, + "ra": 0, + "rb": 1515152261580153489 + } + } +] + + + test cost_of_in_array_32, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":375 + revert code: 0 + decoded log values: +100, log rb: 1515152261580153489 +32, log rb: 1515152261580153489 +32, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 + raw logs: +[ + { + "LogData": { + "data": "0000000000000064", + "digest": "5fcba2633bef1c29420e0eed7b037ced8b00466b0e8f1c5ce1cad2e97e117aad", + "id": "0000000000000000000000000000000000000000000000000000000000000000", + "is": 10368, + "len": 8, + "pc": 42520, + "ptr": 67104768, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000020", + "digest": "707d56f1f282aee234577e650bea2e7b18bb6131a499582be18876aba99d4b60", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88292, + "ptr": 67103744, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000020", + "digest": "707d56f1f282aee234577e650bea2e7b18bb6131a499582be18876aba99d4b60", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88424, + "ptr": 67102720, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67101696, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67100672, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67099648, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67098624, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67097600, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67096576, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67095552, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67094528, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67093504, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67092480, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67091456, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67090432, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67089408, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 70472, + "len": 8, + "pc": 88564, + "ptr": 67088384, + "ra": 0, + "rb": 1515152261580153489 + } + } +] + + + test cost_of_in_array_64, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":382 + revert code: 0 + decoded log values: +100, log rb: 1515152261580153489 +64, log rb: 1515152261580153489 +64, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 +2, log rb: 1515152261580153489 + raw logs: +[ + { + "LogData": { + "data": "0000000000000064", + "digest": "5fcba2633bef1c29420e0eed7b037ced8b00466b0e8f1c5ce1cad2e97e117aad", + "id": "0000000000000000000000000000000000000000000000000000000000000000", + "is": 10368, + "len": 8, + "pc": 43656, + "ptr": 67104768, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000040", + "digest": "3f710ac088db33363087de2b9a657541fe5447821debaa9fe5cbd538eb1a5f29", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91080, + "ptr": 67103744, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000040", + "digest": "3f710ac088db33363087de2b9a657541fe5447821debaa9fe5cbd538eb1a5f29", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91212, + "ptr": 67102720, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67101696, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67100672, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67099648, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67098624, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67097600, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67096576, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67095552, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67094528, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67093504, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67092480, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67091456, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67090432, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67089408, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67088384, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67087360, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67086336, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67085312, + "ra": 0, + "rb": 1515152261580153489 + } + }, + { + "LogData": { + "data": "0000000000000002", + "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", + "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", + "is": 72776, + "len": 8, + "pc": 91352, + "ptr": 67084288, + "ra": 0, + "rb": 1515152261580153489 + } + } +] + + + +test result: FAILED. 26 passed; 3 failed; finished in ??? + + Finished in ??? +error: Some tests failed. +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) diff --git a/test/src/snapshot/mod.rs b/test/src/snapshot/mod.rs index 3e112a0e0cb..f026d0d60e5 100644 --- a/test/src/snapshot/mod.rs +++ b/test/src/snapshot/mod.rs @@ -3,10 +3,14 @@ use libtest_mimic::{Arguments, Trial}; use normalize_path::NormalizePath; use regex::{Captures, Regex}; use std::{ +<<<<<<< HEAD collections::{BTreeSet, HashMap, VecDeque}, path::{Path, PathBuf}, str::FromStr, sync::Once, +======= + collections::{BTreeSet, HashMap, HashSet, VecDeque}, ffi::OsStr, path::{Path, PathBuf}, str::FromStr, sync::Once +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) }; use sway_core::Engines; use sway_features::ExperimentalFeatures; @@ -40,8 +44,12 @@ struct UndoFiles { impl Drop for UndoFiles { fn drop(&mut self) { +<<<<<<< HEAD #[allow(clippy::iter_over_hash_type)] for (path, contents) in self.contents.drain() { +======= + for (path, contents) in self.contents.iter() { +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) let _ = std::fs::write(path, contents); } } @@ -74,8 +82,13 @@ pub(super) async fn run(filter_regex: Option<®ex::Regex>) -> Result<()> { Trial::test(name.clone(), move || { let snapshot_toml = std::fs::read_to_string(format!("{}/snapshot.toml", dir.display()))?; +<<<<<<< HEAD let snapshot_toml = if snapshot_toml.trim().is_empty() { "cmds = [ \"forc build --path {root}\" ]".to_string() +======= + let snapshot_toml = if snapshot_toml.is_empty() { + "cmds = [ \"forc build --path {root}\"]".to_string() +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else { snapshot_toml }; @@ -83,11 +96,22 @@ pub(super) async fn run(filter_regex: Option<®ex::Regex>) -> Result<()> { let snapshot_toml = toml::from_str::(&snapshot_toml)?; let root = dir.strip_prefix(&repo_root).unwrap().display().to_string(); +<<<<<<< HEAD let cmds = snapshot_toml.get("cmds").unwrap().as_array().unwrap(); let mut snapshot = String::new(); let _ = run_cmds(&name, &repo_root, &root, cmds, &mut snapshot); +======= + let cmds = snapshot_toml + .get("cmds") + .unwrap() + .as_array() + .unwrap(); + + let mut snapshot = String::new(); + run_cmds(&name, &repo_root, &root, cmds, &mut snapshot); +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) fn stdout(root: &str, snapshot: &str) { let root = PathBuf::from_str(root).unwrap(); @@ -118,13 +142,22 @@ fn run_cmds( cmds: &Vec, snapshot: &mut String, ) -> std::result::Result<(), libtest_mimic::Failed> { +<<<<<<< HEAD +======= + // file contents to be set again after all cmds + let mut undo = UndoFiles::default(); + +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) use std::fmt::Write; let name = PathBuf::from_str(test_name).unwrap(); let name = name.file_stem().unwrap(); +<<<<<<< HEAD let find_blocks_regex = Regex::new(r#"START ([0-9a-zA-Z_]*)"#).unwrap(); +======= +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) for cmd in cmds { match cmd { toml::Value::String(cmd) => { @@ -146,12 +179,20 @@ fn run_cmds( FORC_DOC_COMPILATION.call_once(|| { compile_forc_doc(); }); +<<<<<<< HEAD format!("target/release/forc-doc {cmd} 1>&2") +======= + format!("target/debug/forc-doc {cmd} 1>&2") +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else if let Some(cmd) = cmd.strip_prefix("forc ") { FORC_COMPILATION.call_once(|| { compile_forc(); }); +<<<<<<< HEAD format!("target/release/forc {cmd} 1>&2") +======= + format!("target/debug/forc {cmd} 1>&2") +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else if let Some(cmd) = cmd.strip_prefix("sub ") { let arg = cmd.trim(); if let Some(l) = last_output.take() { @@ -180,6 +221,7 @@ fn run_cmds( last_output = Some(new_output); } continue; +<<<<<<< HEAD } else if let Some(args) = cmd.strip_prefix("replace-file ") { let Some((path, args)) = args.trim().split_once(" ") else { panic!("replace needs three arguments: file from to"); @@ -215,6 +257,8 @@ fn run_cmds( std::fs::write(path, contents).unwrap(); continue; +======= +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else if let Some(args) = cmd.strip_prefix("filter-fn ") { if let Some(output) = last_output.take() { let (name, fns) = args.trim().split_once(" ").unwrap(); @@ -348,6 +392,7 @@ fn run_cmds( let _ = writeln!(snapshot, "{}", last_output.unwrap_or_default()); } toml::Value::Table(map) => { +<<<<<<< HEAD let repeat_type = map["repeat"].as_str().unwrap(); let cmds = map["cmds"].as_array().unwrap(); @@ -361,11 +406,27 @@ fn run_cmds( } let path = PathBuf::from_str(root).unwrap().join("src/main.sw"); +======= + let ty = map["repeat"].as_str().unwrap(); + let cmds = map["cmds"].as_array().unwrap(); + + match ty { + "for-each-block" => { + fn remove_block_from_file(contents: &str, block_name: &str) -> String { + let block_regex = Regex::new(&format!("\\/\\* START {block_name} \\*\\/[.\\s\\S]+?END {block_name} \\*\\/")).unwrap(); + block_regex.replace_all(&contents, |_: &Captures| -> String { + String::new() + }).to_string() + } + + let path = PathBuf::from_str(&root).unwrap().join("src/main.sw"); +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) let byte_contents = std::fs::read(&path).unwrap(); let contents = String::from_utf8(byte_contents.clone()).unwrap(); let mut blocks = BTreeSet::new(); +<<<<<<< HEAD for capture in find_blocks_regex.captures_iter(&contents) { let name = capture.get(1).unwrap().as_str().to_string(); blocks.insert(name); @@ -383,6 +444,24 @@ fn run_cmds( new_contents = remove_block_from_file(&new_contents, remove_block) .to_string(); +======= + let regex = Regex::new(r#"START ([0-9a-zA-Z_]*)"#).unwrap(); + for capture in regex.captures_iter(&contents) { + let name = capture.get(1).unwrap().as_str().to_string(); + blocks.insert(name); + } + + for block in blocks.iter() { + writeln!(snapshot, "> Block: {block}"); + + let mut undo = UndoFiles::default(); + undo.contents.insert(path.clone(), byte_contents.clone()); + + let mut new_contents = contents.clone(); + for remove_block in blocks.iter() { + if remove_block != block { + new_contents = remove_block_from_file(&new_contents, &remove_block).to_string(); +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) } } @@ -390,6 +469,7 @@ fn run_cmds( let _ = run_cmds(test_name, repo_root, root, cmds, snapshot); } } +<<<<<<< HEAD _ => { panic!("`{cmd}` is not a supported repeat type.\nPossible types are: for-each-block."); } @@ -398,6 +478,12 @@ fn run_cmds( _ => { panic!("`cmds` items can only be strings or inline tables."); } +======= + _ => todo!(), + } + } + _ => todo!(), +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) } } From 2fad2ae36bbef467fd93aa67d2d0d470b2f58291 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 5 Oct 2025 11:51:47 -0300 Subject: [PATCH 02/18] fix SubtsType for TyConstantDecl --- scripts/bisect-forc/bisect-forc.sh | 19 ++++++++++--------- sway-lib-std/src/codec.sw | 27 ++++++++++++--------------- 2 files changed, 22 insertions(+), 24 deletions(-) diff --git a/scripts/bisect-forc/bisect-forc.sh b/scripts/bisect-forc/bisect-forc.sh index 3f883ade03c..ae93dae7b5f 100755 --- a/scripts/bisect-forc/bisect-forc.sh +++ b/scripts/bisect-forc/bisect-forc.sh @@ -20,15 +20,7 @@ compile_and_cp_to_cache() { fi } -run_cargo() { - if [ "$2" = "" ]; then - bash -c "$CACHE/$CACHENAME build --path $PROJ" &>> /dev/null - echo "$?" - else - bash -c "$CACHE/$CACHENAME $2 --path $PROJ" &>> /dev/null - echo "$?" - fi -} + INITIAL_COMMIT="$(git show -s --format='%H' HEAD)" END_COMMIT="" @@ -47,6 +39,15 @@ git log -1 --oneline echo -n "Running: " CACHENAME="$(git show -s --format='%as-%ct-%H' HEAD)" +run_cargo() { + if [ "$2" = "" ]; then + bash -c "$CACHE/$CACHENAME build --path $PROJ" &>> /dev/null + echo "$?" + else + bash -c "$CACHE/$CACHENAME $2 --path $PROJ" &>> /dev/null + echo "$?" + fi +} compile_and_cp_to_cache "$CACHENAME" INITIAL_COMPILATION_STATUS=$(run_cargo "$1" "$2") diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw index fdfdf421240..263c125cf9c 100644 --- a/sway-lib-std/src/codec.sw +++ b/sway-lib-std/src/codec.sw @@ -3376,27 +3376,28 @@ impl AbiDecode for str[64] { // END STRARRAY_DECODE #[cfg(experimental_const_generics = true)] -impl AbiDecode for [T; N] +impl AbiDecode for [TTT; N] where - T: AbiDecode, + TTT: AbiEncode + AbiDecode, { #[inline(never)] - fn abi_decode(ref mut buffer: BufferReader) -> [T; N] { - const LENGTH: u64 = __size_of::() * N; - __log(LENGTH); + fn abi_decode(ref mut buffer: BufferReader) -> [TTT; N] { + const SIZE_OF_TTT = __size_of::(); + const LENGTH: u64 = SIZE_OF_TTT * N; let mut array = [0u8; LENGTH]; - let array: &mut [T; N] = __transmute::<&mut [u8; LENGTH], &mut [T; N]>(&mut array); + let array: &mut [TTT; N] = __transmute::<&mut [u8; LENGTH], &mut [TTT; N]>(&mut array); let mut i = 0; - __log(N); while i < N { - __log(2); - let item: &mut T = __elem_at(array, i); - *item = buffer.decode::(); + let item: &mut TTT = __elem_at(array, i); + let decoded = buffer.decode::(); + __log((i, decoded)); + *item = decoded; i += 1; } + __log(*array); *array } } @@ -5380,12 +5381,8 @@ where retl: u64 }; - __log(101); let mut buffer = BufferReader::from_parts(ptr, len); - __log(102); - let r = T::abi_decode(buffer); - __log(103); - r + T::abi_decode(buffer) } pub fn decode_script_data() -> T From 72cd0b0a26e003b587138bb8ed2ac45d2cc108e0 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 5 Oct 2025 12:09:27 -0300 Subject: [PATCH 03/18] bring whole snapshot test back --- .../const_of_contract_call/snapshot.toml | 7 - .../const_of_contract_call/stdout.snap | 29793 +++++++++++++++- test/src/snapshot/mod.rs | 86 - 3 files changed, 28533 insertions(+), 1353 deletions(-) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml index e5d4b87659f..e29e5ff922e 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml @@ -1,14 +1,7 @@ cmds = [ -<<<<<<< HEAD "forc test --path {root} --release --experimental const_generics", { repeat = "for-each-block", cmds = [ "replace-file src/main.sw \"fn cost_of_in\" \"fn isolated_cost_of_in\"", "forc test --path {root} --release --experimental const_generics" ] } -======= - "forc test --path {root} --release --experimental const_generics --logs --ir final", - # { repeat = "for-each-block", cmds = [ - # "forc test --path {root} --release --experimental const_generics" - # ] } ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) ] \ No newline at end of file diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index 5fdc669d7a2..ddd024d23cb 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -1,6 +1,11 @@ --- source: test/src/snapshot/mod.rs --- +<<<<<<< HEAD +======= +<<<<<<< HEAD +<<<<<<< HEAD +>>>>>>> 8cc595443 (bring whole snapshot test back) > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 101 output: @@ -8,681 +13,28161 @@ output: Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) Finished release [optimized + fuel] target(s) [35.272 KB] in ??? - Running 29 tests, filtered 0 tests - -tested -- const_of_contract_call - <<<<<<< HEAD - test cost_of_in_bool ... ok (???, 14600 gas) - test cost_of_in_u8 ... ok (???, 18427 gas) - test cost_of_in_u16 ... ok (???, 17781 gas) - test cost_of_in_u32 ... ok (???, 18557 gas) - test cost_of_in_u64 ... ok (???, 18536 gas) - test cost_of_in_u256 ... ok (???, 18265 gas) - test cost_of_in_b256 ... ok (???, 14378 gas) - test cost_of_in_str_0 ... ok (???, 15302 gas) - test cost_of_in_str_1 ... ok (???, 15805 gas) - test cost_of_in_str_8 ... ok (???, 16528 gas) - test cost_of_in_str_16 ... ok (???, 15865 gas) - test cost_of_in_str_32 ... ok (???, 16205 gas) - test cost_of_in_array_0 ... FAILED (???, 12886 gas) - test cost_of_in_array_1 ... ok (???, 13775 gas) - test cost_of_in_array_8 ... ok (???, 18788 gas) - test cost_of_in_array_16 ... ok (???, 19141 gas) - test cost_of_in_array_32 ... ok (???, 25119 gas) - test cost_of_in_array_64 ... ok (???, 36762 gas) - test cost_of_in_tuple_0 ... ok (???, 16648 gas) - test cost_of_in_tuple_1 ... ok (???, 17622 gas) - test cost_of_in_tuple_2 ... ok (???, 18257 gas) - test cost_of_in_tuple_3 ... ok (???, 18849 gas) - test cost_of_in_tuple_4 ... ok (???, 19471 gas) - test in_struct_u64 ... ok (???, 16337 gas) - test in_struct_u64_u64 ... ok (???, 16791 gas) - test in_struct_u64_u64_u64 ... ok (???, 17241 gas) - test in_enum_u64 ... ok (???, 15575 gas) - test in_enum_u64_u64 ... ok (???, 15362 gas) - test in_enum_u64_u64_u64 ... ok (???, 15551 gas) ======= -<<<<<<< HEAD - test cost_of_in_bool ... ok (???, 2082 gas) - test cost_of_in_u8 ... ok (???, 4331 gas) - test cost_of_in_u16 ... ok (???, 3948 gas) - test cost_of_in_u32 ... ok (???, 4389 gas) - test cost_of_in_u64 ... ok (???, 4397 gas) - test cost_of_in_u256 ... ok (???, 4240 gas) - test cost_of_in_b256 ... ok (???, 1954 gas) - test cost_of_in_str_0 ... ok (???, 2505 gas) - test cost_of_in_str_1 ... ok (???, 2806 gas) - test cost_of_in_str_8 ... ok (???, 3229 gas) - test cost_of_in_str_16 ... ok (???, 2837 gas) - test cost_of_in_str_32 ... ok (???, 3035 gas) - test cost_of_in_array_0 ... FAILED (???, 1095 gas) - test cost_of_in_array_1 ... ok (???, 1589 gas) - test cost_of_in_array_8 ... ok (???, 4192 gas) - test cost_of_in_array_16 ... ok (???, 4563 gas) - test cost_of_in_array_32 ... ok (???, 7889 gas) - test cost_of_in_array_64 ... ok (???, 14352 gas) - test cost_of_in_tuple_0 ... ok (???, 3289 gas) - test cost_of_in_tuple_1 ... ok (???, 3860 gas) - test cost_of_in_tuple_2 ... ok (???, 4228 gas) - test cost_of_in_tuple_3 ... ok (???, 4571 gas) - test cost_of_in_tuple_4 ... ok (???, 4935 gas) - test in_struct_u64 ... ok (???, 3103 gas) - test in_struct_u64_u64 ... ok (???, 3364 gas) - test in_struct_u64_u64_u64 ... ok (???, 3623 gas) - test in_enum_u64 ... ok (???, 2653 gas) - test in_enum_u64_u64 ... ok (???, 2528 gas) - test in_enum_u64_u64_u64 ... ok (???, 2640 gas) ->>>>>>> ce8248b66 (better tests to measure cost of contract calls) +======= +// IR: Final +library { +} - failures: - test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 - revert code: 0 + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) +// IR: Final +contract { + global __const_global : string<10> = const string<10> "in_array_0" + global __const_global0 : string<10> = const string<10> "in_array_1" + global __const_global1 : string<11> = const string<11> "in_array_16" + global __const_global10 : string<8> = const string<8> "in_str_0" + global __const_global11 : string<8> = const string<8> "in_str_1" + global __const_global12 : string<9> = const string<9> "in_str_16" + global __const_global13 : string<9> = const string<9> "in_str_32" + global __const_global14 : string<8> = const string<8> "in_str_8" + global __const_global15 : string<13> = const string<13> "in_struct_u64" + global __const_global16 : string<17> = const string<17> "in_struct_u64_u64" + global __const_global17 : string<21> = const string<21> "in_struct_u64_u64_u64" + global __const_global18 : string<10> = const string<10> "in_tuple_0" + global __const_global19 : string<10> = const string<10> "in_tuple_1" + global __const_global2 : string<11> = const string<11> "in_array_32" + global __const_global20 : string<10> = const string<10> "in_tuple_2" + global __const_global21 : string<10> = const string<10> "in_tuple_3" + global __const_global22 : string<10> = const string<10> "in_tuple_4" + global __const_global23 : string<6> = const string<6> "in_u16" + global __const_global24 : string<7> = const string<7> "in_u256" + global __const_global25 : string<6> = const string<6> "in_u32" + global __const_global26 : string<6> = const string<6> "in_u64" + global __const_global27 : string<5> = const string<5> "in_u8" + global __const_global3 : string<11> = const string<11> "in_array_64" + global __const_global4 : string<10> = const string<10> "in_array_8" + global __const_global5 : string<7> = const string<7> "in_b256" + global __const_global6 : string<7> = const string<7> "in_bool" + global __const_global7 : string<11> = const string<11> "in_enum_u64" + global __const_global8 : string<15> = const string<15> "in_enum_u64_u64" + global __const_global9 : string<19> = const string<19> "in_enum_u64_u64_u64" + pub entry fn __entry() -> (), !3 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut slice __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_010 + local mut { ptr, u64, u64 } __aggr_memcpy_011 + local mut { ptr, u64, u64 } __aggr_memcpy_012 + local mut { ptr, u64 } __aggr_memcpy_013 + local mut { ptr, u64 } __aggr_memcpy_014 + local mut { ptr, u64 } __aggr_memcpy_015 + local mut { ptr, u64 } __aggr_memcpy_016 + local mut { ptr, u64 } __aggr_memcpy_017 + local mut string<0> __aggr_memcpy_018 + local mut { ptr, u64, u64 } __aggr_memcpy_019 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut { ptr, u64, u64 } __aggr_memcpy_020 + local mut { ptr, u64 } __aggr_memcpy_021 + local mut { ptr, u64 } __aggr_memcpy_022 + local mut string<1> __aggr_memcpy_023 + local mut { ptr, u64, u64 } __aggr_memcpy_024 + local mut { ptr, u64, u64 } __aggr_memcpy_025 + local mut { ptr, u64 } __aggr_memcpy_026 + local mut { ptr, u64 } __aggr_memcpy_027 + local mut string<16> __aggr_memcpy_028 + local mut { ptr, u64, u64 } __aggr_memcpy_029 + local mut { ptr, u64 } __aggr_memcpy_03 + local mut { ptr, u64, u64 } __aggr_memcpy_030 + local mut { ptr, u64 } __aggr_memcpy_031 + local mut { ptr, u64 } __aggr_memcpy_032 + local mut string<32> __aggr_memcpy_033 + local mut { ptr, u64, u64 } __aggr_memcpy_034 + local mut { ptr, u64, u64 } __aggr_memcpy_035 + local mut { ptr, u64 } __aggr_memcpy_036 + local mut { ptr, u64 } __aggr_memcpy_037 + local mut string<8> __aggr_memcpy_038 + local mut { ptr, u64, u64 } __aggr_memcpy_039 + local mut { ptr, u64 } __aggr_memcpy_04 + local mut { ptr, u64, u64 } __aggr_memcpy_040 + local mut { ptr, u64 } __aggr_memcpy_041 + local mut { ptr, u64 } __aggr_memcpy_042 + local mut { ptr, u64 } __aggr_memcpy_043 + local mut { ptr, u64 } __aggr_memcpy_044 + local mut { ptr, u64 } __aggr_memcpy_045 + local mut { ptr, u64 } __aggr_memcpy_046 + local mut { ptr, u64 } __aggr_memcpy_047 + local mut { ptr, u64 } __aggr_memcpy_048 + local mut { ptr, u64, u64 } __aggr_memcpy_049 + local mut { ptr, u64 } __aggr_memcpy_05 + local mut { ptr, u64, u64 } __aggr_memcpy_050 + local mut { ptr, u64 } __aggr_memcpy_051 + local mut u256 __aggr_memcpy_052 + local mut { ptr, u64, u64 } __aggr_memcpy_053 + local mut { ptr, u64, u64 } __aggr_memcpy_054 + local mut { ptr, u64 } __aggr_memcpy_055 + local mut { ptr, u64, u64 } __aggr_memcpy_056 + local mut { ptr, u64, u64 } __aggr_memcpy_057 + local mut { ptr, u64 } __aggr_memcpy_058 + local mut { ptr, u64 } __aggr_memcpy_059 + local mut { ptr, u64 } __aggr_memcpy_06 + local mut { ptr, u64, u64 } __aggr_memcpy_060 + local mut { ptr, u64, u64 } __aggr_memcpy_061 + local mut { ptr, u64 } __aggr_memcpy_062 + local mut b256 __aggr_memcpy_07 + local mut { ptr, u64, u64 } __aggr_memcpy_08 + local mut { ptr, u64, u64 } __aggr_memcpy_09 + local { ptr, u64 } __anon_0 + local { ptr } __anon_00 + local { ptr, u64 } __anon_000 + local { u64, ( u64 ) } __anon_001 + local { u64, u64, u64, u64 } __anon_0010 + local { u64, ( u64 | u64 ) } __anon_002 + local { u64, ( u64 | u64 | u64 ) } __anon_003 + local { u64 } __anon_004 + local { u64, u64 } __anon_005 + local { u64, u64, u64 } __anon_006 + local { u64 } __anon_007 + local { u64, u64 } __anon_008 + local { u64, u64, u64 } __anon_009 + local { ptr } __anon_01 + local { bool } __anon_010 + local { ptr, u64, u64 } __anon_011 + local { { u64, ( u64 ) } } __anon_012 + local { { u64, ( u64 | u64 ) } } __anon_013 + local { { u64, ( u64 | u64 | u64 ) } } __anon_014 + local { string<0> } __anon_015 + local { ptr, u64, u64 } __anon_016 + local { string<1> } __anon_017 + local { ptr, u64, u64 } __anon_018 + local { string<16> } __anon_019 + local { [u64; 0] } __anon_02 + local { ptr, u64, u64 } __anon_020 + local { string<32> } __anon_021 + local { ptr, u64, u64 } __anon_022 + local { string<8> } __anon_023 + local { ptr, u64, u64 } __anon_024 + local { { u64 } } __anon_025 + local { { u64, u64 } } __anon_026 + local { { u64, u64, u64 } } __anon_027 + local { () } __anon_028 + local { { u64 } } __anon_029 + local { [u64; 1] } __anon_03 + local { { u64, u64 } } __anon_030 + local { { u64, u64, u64 } } __anon_031 + local { { u64, u64, u64, u64 } } __anon_032 + local { u64 } __anon_033 + local { ptr, u64, u64 } __anon_034 + local { u256 } __anon_035 + local { ptr, u64, u64 } __anon_036 + local { u64 } __anon_037 + local { ptr, u64, u64 } __anon_038 + local { u64 } __anon_039 + local { [u64; 16] } __anon_04 + local { u8 } __anon_040 + local { ptr, u64, u64 } __anon_041 + local { ptr, u64 } __anon_042 + local { ptr, u64 } __anon_043 + local { ptr, u64 } __anon_044 + local { ptr, u64 } __anon_045 + local { ptr, u64 } __anon_046 + local { ptr, u64 } __anon_047 + local { ptr, u64 } __anon_048 + local { ptr, u64 } __anon_049 + local { [u64; 32] } __anon_05 + local { ptr, u64 } __anon_050 + local { ptr, u64 } __anon_051 + local { ptr, u64 } __anon_052 + local { ptr, u64 } __anon_053 + local { ptr, u64 } __anon_054 + local { ptr, u64 } __anon_055 + local { ptr, u64 } __anon_056 + local { ptr, u64 } __anon_057 + local { ptr, u64 } __anon_058 + local { ptr, u64 } __anon_059 + local { [u64; 64] } __anon_06 + local { ptr, u64 } __anon_060 + local { ptr, u64 } __anon_061 + local { ptr, u64 } __anon_062 + local { ptr, u64 } __anon_063 + local { ptr, u64 } __anon_064 + local { ptr, u64 } __anon_065 + local { ptr, u64 } __anon_066 + local { ptr, u64 } __anon_067 + local { ptr, u64 } __anon_068 + local { ptr, u64 } __anon_069 + local { [u64; 8] } __anon_07 + local { ptr, u64 } __anon_070 + local { ptr, u64 } __anon_071 + local { ptr, u64 } __anon_072 + local { ptr, u64 } __anon_073 + local { ptr, u64 } __anon_074 + local { ptr, u64 } __anon_075 + local { b256 } __anon_08 + local { ptr, u64, u64 } __anon_09 + local slice __anon_1 + local { ptr, u64 } __anon_10 + local slice __anon_11 + local b256 __anon_110 + local { ptr, u64, u64 } __anon_111 + local { u64, ( u64 | u64 ) } __anon_112 + local { u64, ( u64 | u64 | u64 ) } __anon_113 + local string<0> __anon_114 + local string<1> __anon_115 + local string<16> __anon_116 + local string<32> __anon_117 + local string<8> __anon_118 + local u64 __anon_119 + local { ptr, u64 } __anon_12 + local u256 __anon_120 + local u64 __anon_121 + local { ptr, u64, u64 } __anon_122 + local slice __anon_13 + local { ptr, u64 } __anon_14 + local slice __anon_15 + local { ptr, u64 } __anon_16 + local slice __anon_17 + local { ptr, u64 } __anon_18 + local slice __anon_19 + local { ptr, u64 } __anon_2 + local { ptr, u64 } __anon_20 + local slice __anon_21 + local { ptr, u64, u64 } __anon_210 + local { { ptr, u64, u64 } } __anon_211 + local { u64, ( u64 | u64 | u64 ) } __anon_212 + local { ptr, u64, u64 } __anon_213 + local { ptr, u64, u64 } __anon_214 + local { ptr, u64, u64 } __anon_215 + local { ptr, u64, u64 } __anon_216 + local { ptr, u64, u64 } __anon_217 + local { ptr, u64, u64 } __anon_218 + local { ptr, u64, u64 } __anon_219 + local { ptr, u64 } __anon_22 + local { ptr, u64, u64 } __anon_220 + local { { ptr, u64, u64 } } __anon_221 + local slice __anon_23 + local { ptr, u64 } __anon_24 + local slice __anon_25 + local { ptr, u64 } __anon_26 + local slice __anon_27 + local { ptr, u64 } __anon_28 + local slice __anon_29 + local slice __anon_3 + local { ptr, u64 } __anon_30 + local slice __anon_31 + local { { ptr, u64, u64 } } __anon_310 + local { { ptr, u64, u64 } } __anon_311 + local { { ptr, u64, u64 } } __anon_312 + local { { ptr, u64, u64 } } __anon_313 + local { { ptr, u64, u64 } } __anon_314 + local { { ptr, u64, u64 } } __anon_315 + local { { ptr, u64, u64 } } __anon_316 + local { { ptr, u64, u64 } } __anon_317 + local { { ptr, u64, u64 } } __anon_318 + local { ptr, u64 } __anon_32 + local slice __anon_33 + local { ptr, u64 } __anon_34 + local slice __anon_35 + local { ptr, u64 } __anon_36 + local slice __anon_37 + local { ptr, u64 } __anon_38 + local slice __anon_39 + local { ptr, u64 } __anon_4 + local { ptr, u64 } __anon_40 + local slice __anon_41 + local { ptr, u64 } __anon_42 + local slice __anon_43 + local { ptr, u64 } __anon_44 + local slice __anon_45 + local { ptr, u64 } __anon_46 + local slice __anon_47 + local { ptr, u64 } __anon_48 + local slice __anon_49 + local slice __anon_5 + local { ptr, u64 } __anon_50 + local slice __anon_51 + local { ptr, u64 } __anon_52 + local slice __anon_53 + local { ptr, u64 } __anon_54 + local slice __anon_55 + local { ptr, u64 } __anon_56 + local slice __anon_57 + local { ptr, u64 } __anon_6 + local slice __anon_7 + local { ptr, u64 } __anon_8 + local slice __anon_9 + local slice __log_arg + local { u64, ( u64 ) } __matched_value_10 + local { u64, ( u64 | u64 ) } __matched_value_12 + local { u64, ( u64 | u64 | u64 ) } __matched_value_14 + local slice __ret_val + local slice __ret_val0 + local slice __ret_val1 + local { { ptr, u64, u64 } } __ret_val10 + local { { ptr, u64, u64 } } __ret_val11 + local { { ptr, u64, u64 } } __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local { { ptr, u64, u64 } } __ret_val15 + local { { ptr, u64, u64 } } __ret_val16 + local { { ptr, u64, u64 } } __ret_val17 + local { { ptr, u64, u64 } } __ret_val18 + local { { ptr, u64, u64 } } __ret_val19 + local slice __ret_val2 + local { { ptr, u64, u64 } } __ret_val20 + local { { ptr, u64, u64 } } __ret_val21 + local { { ptr, u64, u64 } } __ret_val22 + local { { ptr, u64, u64 } } __ret_val23 + local { { ptr, u64, u64 } } __ret_val24 + local { { ptr, u64, u64 } } __ret_val25 + local { { ptr, u64, u64 } } __ret_val26 + local { { ptr, u64, u64 } } __ret_val27 + local { { ptr, u64, u64 } } __ret_val28 + local { { ptr, u64, u64 } } __ret_val29 + local slice __ret_val3 + local { { ptr, u64, u64 } } __ret_val30 + local { { ptr, u64, u64 } } __ret_val31 + local { { ptr, u64, u64 } } __ret_val32 + local { { ptr, u64, u64 } } __ret_val33 + local { { ptr, u64, u64 } } __ret_val34 + local { { ptr, u64, u64 } } __ret_val35 + local { { ptr, u64, u64 } } __ret_val36 + local { { ptr, u64, u64 } } __ret_val37 + local { { ptr, u64, u64 } } __ret_val38 + local { { ptr, u64, u64 } } __ret_val39 + local slice __ret_val4 + local { { ptr, u64, u64 } } __ret_val40 + local { { ptr, u64, u64 } } __ret_val41 + local { { ptr, u64, u64 } } __ret_val42 + local { { ptr, u64, u64 } } __ret_val43 + local { { ptr, u64, u64 } } __ret_val44 + local { { ptr, u64, u64 } } __ret_val45 + local { { ptr, u64, u64 } } __ret_val46 + local { { ptr, u64, u64 } } __ret_val47 + local { { ptr, u64, u64 } } __ret_val48 + local slice __ret_val49 + local [u64; 0] __ret_val5 + local slice __ret_val50 + local slice __ret_val51 + local slice __ret_val52 + local slice __ret_val53 + local slice __ret_val54 + local slice __ret_val55 + local slice __ret_val56 + local slice __ret_val57 + local slice __ret_val58 + local slice __ret_val59 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val60 + local slice __ret_val61 + local slice __ret_val62 + local slice __ret_val63 + local slice __ret_val64 + local slice __ret_val65 + local slice __ret_val66 + local slice __ret_val67 + local slice __ret_val68 + local slice __ret_val69 + local { { ptr, u64, u64 } } __ret_val7 + local [u64; 1] __ret_val70 + local [u64; 16] __ret_val71 + local [u64; 32] __ret_val72 + local [u64; 64] __ret_val73 + local [u64; 8] __ret_val74 + local slice __ret_val75 + local slice __ret_val76 + local slice __ret_val77 + local slice __ret_val78 + local slice __ret_val79 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val80 + local slice __ret_val81 + local slice __ret_val82 + local { { ptr, u64, u64 } } __ret_val9 + local slice __tmp_arg + local slice __tmp_arg0 + local slice __tmp_arg1 + local slice __tmp_arg10 + local slice __tmp_arg100 + local slice __tmp_arg101 + local slice __tmp_arg102 + local slice __tmp_arg103 + local slice __tmp_arg104 + local slice __tmp_arg105 + local slice __tmp_arg106 + local slice __tmp_arg107 + local slice __tmp_arg108 + local slice __tmp_arg109 + local slice __tmp_arg11 + local slice __tmp_arg110 + local slice __tmp_arg111 + local slice __tmp_arg112 + local slice __tmp_arg113 + local slice __tmp_arg114 + local slice __tmp_arg115 + local slice __tmp_arg116 + local slice __tmp_arg117 + local slice __tmp_arg118 + local slice __tmp_arg119 + local slice __tmp_arg12 + local slice __tmp_arg120 + local slice __tmp_arg121 + local slice __tmp_arg122 + local slice __tmp_arg123 + local slice __tmp_arg124 + local slice __tmp_arg125 + local slice __tmp_arg126 + local slice __tmp_arg127 + local [u64; 8] __tmp_arg128 + local [u64; 8] __tmp_arg129 + local slice __tmp_arg13 + local { u64 } __tmp_arg130 + local { u64 } __tmp_arg131 + local { u64, u64, u64 } __tmp_arg132 + local { u64, u64, u64 } __tmp_arg133 + local { u64, u64 } __tmp_arg134 + local { u64, u64 } __tmp_arg135 + local slice __tmp_arg14 + local slice __tmp_arg15 + local slice __tmp_arg16 + local slice __tmp_arg17 + local slice __tmp_arg18 + local slice __tmp_arg19 + local slice __tmp_arg2 + local slice __tmp_arg20 + local slice __tmp_arg21 + local slice __tmp_arg22 + local slice __tmp_arg23 + local slice __tmp_arg24 + local slice __tmp_arg25 + local slice __tmp_arg26 + local slice __tmp_arg27 + local slice __tmp_arg28 + local slice __tmp_arg29 + local slice __tmp_arg3 + local slice __tmp_arg30 + local slice __tmp_arg31 + local slice __tmp_arg32 + local slice __tmp_arg33 + local slice __tmp_arg34 + local slice __tmp_arg35 + local slice __tmp_arg36 + local slice __tmp_arg37 + local slice __tmp_arg38 + local slice __tmp_arg39 + local slice __tmp_arg4 + local slice __tmp_arg40 + local slice __tmp_arg41 + local slice __tmp_arg42 + local slice __tmp_arg43 + local slice __tmp_arg44 + local slice __tmp_arg45 + local slice __tmp_arg46 + local slice __tmp_arg47 + local slice __tmp_arg48 + local slice __tmp_arg49 + local slice __tmp_arg5 + local slice __tmp_arg50 + local slice __tmp_arg51 + local slice __tmp_arg52 + local slice __tmp_arg53 + local slice __tmp_arg54 + local slice __tmp_arg55 + local slice __tmp_arg56 + local { { ptr, u64, u64 } } __tmp_arg57 + local { { ptr, u64, u64 } } __tmp_arg58 + local { { ptr, u64, u64 } } __tmp_arg59 + local slice __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg60 + local { { ptr, u64, u64 } } __tmp_arg61 + local { { ptr, u64, u64 } } __tmp_arg62 + local { { ptr, u64, u64 } } __tmp_arg63 + local { { ptr, u64, u64 } } __tmp_arg64 + local { { ptr, u64, u64 } } __tmp_arg65 + local { { ptr, u64, u64 } } __tmp_arg66 + local { { ptr, u64, u64 } } __tmp_arg67 + local { { ptr, u64, u64 } } __tmp_arg68 + local { { ptr, u64, u64 } } __tmp_arg69 + local slice __tmp_arg7 + local { { ptr, u64, u64 } } __tmp_arg70 + local { { ptr, u64, u64 } } __tmp_arg71 + local { { ptr, u64, u64 } } __tmp_arg72 + local { { ptr, u64, u64 } } __tmp_arg73 + local { { ptr, u64, u64 } } __tmp_arg74 + local { { ptr, u64, u64 } } __tmp_arg75 + local { { ptr, u64, u64 } } __tmp_arg76 + local { { ptr, u64, u64 } } __tmp_arg77 + local { { ptr, u64, u64 } } __tmp_arg78 + local { { ptr, u64, u64 } } __tmp_arg79 + local slice __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg80 + local { { ptr, u64, u64 } } __tmp_arg81 + local { { ptr, u64, u64 } } __tmp_arg82 + local { { ptr, u64, u64 } } __tmp_arg83 + local { { ptr, u64, u64 } } __tmp_arg84 + local { { ptr, u64, u64 } } __tmp_arg85 + local { { ptr, u64, u64 } } __tmp_arg86 + local { { ptr, u64, u64 } } __tmp_arg87 + local { { ptr, u64, u64 } } __tmp_arg88 + local { { ptr, u64, u64 } } __tmp_arg89 + local slice __tmp_arg9 + local { { ptr, u64, u64 } } __tmp_arg90 + local { { ptr, u64, u64 } } __tmp_arg91 + local { { ptr, u64, u64 } } __tmp_arg92 + local { { ptr, u64, u64 } } __tmp_arg93 + local { { ptr, u64, u64 } } __tmp_arg94 + local { { ptr, u64, u64 } } __tmp_arg95 + local { { ptr, u64, u64 } } __tmp_arg96 + local { { ptr, u64, u64 } } __tmp_arg97 + local { { ptr, u64, u64 } } __tmp_arg98 + local { { ptr, u64, u64 } } __tmp_arg99 + local { u64, ( u64 | u64 ) } __tmp_block_arg + local { { ptr, u64, u64 } } __tmp_block_arg0 + local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg1 + local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg2 + local { { ptr, u64, u64 } } __tmp_block_arg3 + local { { ptr, u64, u64 } } __tmp_block_arg4 + local mut { ptr } _buffer + local slice _method_name + local [u64; 0] _result + local slice _result_ + local [u64; 1] _result__ + local slice _result___ + local [u64; 16] _result____ + local slice _result_____ + local [u64; 32] _result______ + local slice _result_______ + local [u64; 64] _result________ + local slice _result_________ + local [u64; 8] _result__________ + local slice _result___________ + local b256 _result____________ + local slice _result_____________ + local slice _result_______________ + local { u64, ( u64 ) } _result________________ + local slice _result_________________ + local { u64, ( u64 | u64 ) } _result__________________ + local slice _result___________________ + local { u64, ( u64 | u64 | u64 ) } _result____________________ + local slice _result_____________________ + local string<0> _result______________________ + local slice _result_______________________ + local string<1> _result________________________ + local slice _result_________________________ + local string<16> _result__________________________ + local slice _result___________________________ + local string<32> _result____________________________ + local slice _result_____________________________ + local string<8> _result______________________________ + local slice _result_______________________________ + local { u64 } _result________________________________ + local slice _result_________________________________ + local { u64, u64 } _result__________________________________ + local slice _result___________________________________ + local { u64, u64, u64 } _result____________________________________ + local slice _result_____________________________________ + local { u64 } _result_______________________________________ + local slice _result________________________________________ + local { u64, u64 } _result_________________________________________ + local slice _result__________________________________________ + local { u64, u64, u64 } _result___________________________________________ + local slice _result____________________________________________ + local { u64, u64, u64, u64 } _result_____________________________________________ + local slice _result______________________________________________ + local slice _result________________________________________________ + local u256 _result_________________________________________________ + local slice _result__________________________________________________ + local slice _result____________________________________________________ + local slice _result______________________________________________________ + local slice _result________________________________________________________ + local { [u64; 0] } args + local { [u64; 1] } args_ + local { [u64; 16] } args__ + local { [u64; 32] } args___ + local { [u64; 64] } args____ + local { [u64; 8] } args_____ + local { b256 } args______ + local { bool } args_______ + local { { u64, ( u64 ) } } args________ + local { { u64, ( u64 | u64 ) } } args_________ + local { { u64, ( u64 | u64 | u64 ) } } args__________ + local { string<0> } args___________ + local { string<1> } args____________ + local { string<16> } args_____________ + local { string<32> } args______________ + local { string<8> } args_______________ + local { { u64 } } args________________ + local { { u64, u64 } } args_________________ + local { { u64, u64, u64 } } args__________________ + local { () } args___________________ + local { { u64 } } args____________________ + local { { u64, u64 } } args_____________________ + local { { u64, u64, u64 } } args______________________ + local { { u64, u64, u64, u64 } } args_______________________ + local { u64 } args________________________ + local { u256 } args_________________________ + local { u64 } args__________________________ + local { u64 } args___________________________ + local { u8 } args____________________________ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer10 + local { { ptr, u64, u64 } } buffer11 + local { { ptr, u64, u64 } } buffer12 + local { { ptr, u64, u64 } } buffer13 + local { { ptr, u64, u64 } } buffer14 + local { { ptr, u64, u64 } } buffer15 + local { { ptr, u64, u64 } } buffer16 + local { { ptr, u64, u64 } } buffer17 + local { { ptr, u64, u64 } } buffer18 + local { { ptr, u64, u64 } } buffer19 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer20 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer5 + local { { ptr, u64, u64 } } buffer6 + local { { ptr, u64, u64 } } buffer7 + local { { ptr, u64, u64 } } buffer8 + local { { ptr, u64, u64 } } buffer9 + local { { ptr, u64, u64 } } buffer_1 + local { { ptr, u64, u64 } } buffer_12 + local { { ptr, u64, u64 } } buffer_14 + local { { ptr, u64, u64 } } buffer_17 + local { { ptr, u64, u64 } } buffer_21 + local { { ptr, u64, u64 } } buffer_24 + local { { ptr, u64, u64 } } buffer_26 + local { { ptr, u64, u64 } } buffer_28 + local { { ptr, u64, u64 } } buffer_3 + local { { ptr, u64, u64 } } buffer_31 + local { { ptr, u64, u64 } } buffer_33 + local { { ptr, u64, u64 } } buffer_35 + local { { ptr, u64, u64 } } buffer_44 + local { { ptr, u64, u64 } } buffer_46 + local { { ptr, u64, u64 } } buffer_48 + local { { ptr, u64, u64 } } buffer_5 + local { { ptr, u64, u64 } } buffer_50 + local { { ptr, u64, u64 } } buffer_53 + local { { ptr, u64, u64 } } buffer_7 + local { { ptr, u64, u64 } } buffer_9 + local mut { { ptr, u64, u64 } } buffer__ + local mut { { ptr, u64, u64 } } buffer__0 + local mut { { ptr, u64, u64 } } buffer__1 + local mut { { ptr, u64, u64 } } buffer__2 + local mut { { ptr, u64, u64 } } buffer__3 + local { { ptr, u64, u64 } } buffer__4 + local { { ptr, u64, u64 } } buffer__5 + local { { ptr, u64, u64 } } buffer__6 + local { { ptr, u64, u64 } } buffer__7 + local { { ptr, u64, u64 } } buffer___ + local { { ptr, u64, u64 } } buffer___0 + local { { ptr, u64, u64 } } buffer___1 + local { { ptr, u64, u64 } } buffer___2 + local { { ptr, u64, u64 } } buffer____ + local { { ptr, u64, u64 } } buffer____0 + local { { ptr, u64, u64 } } buffer____1 + local { { ptr, u64, u64 } } buffer____2 + local { { ptr, u64, u64 } } buffer_____ + local { { ptr, u64, u64 } } buffer_____0 + local { { ptr, u64, u64 } } buffer_____1 + local { { ptr, u64, u64 } } buffer______ + local { { ptr, u64, u64 } } buffer______0 + local { { ptr, u64, u64 } } buffer_______ + local { { ptr, u64, u64 } } buffer________ + local slice data + local slice data0 + local slice data1 + local slice data2 + local slice data3 + local slice data4 + local [u64; 0] item_ + local [u64; 1] item_0 + local [u64; 16] item_1 + local string<1> item_10 + local string<16> item_11 + local string<32> item_12 + local string<8> item_13 + local { u64, u64, u64, u64 } item_14 + local u256 item_16 + local [u64; 32] item_2 + local [u64; 64] item_3 + local b256 item_4 + local { u64, ( u64 ) } item_6 + local { u64, ( u64 | u64 ) } item_7 + local { u64, ( u64 | u64 | u64 ) } item_8 + local string<0> item_9 + local slice self_ + local slice self_0 + local slice self_1 + local slice self_10 + local slice self_11 + local slice self_12 + local slice self_13 + local [u64; 64] self_14 + local slice self_15 + local slice self_16 + local slice self_17 + local b256 self_18 + local slice self_19 + local [u64; 0] self_2 + local slice self_20 + local slice self_21 + local { u64, ( u64 ) } self_22 + local slice self_23 + local slice self_24 + local { u64, ( u64 | u64 ) } self_25 + local slice self_26 + local slice self_27 + local { u64, ( u64 | u64 | u64 ) } self_28 + local slice self_29 + local slice self_3 + local slice self_30 + local slice self_31 + local slice self_32 + local string<0> self_33 + local slice self_34 + local string<1> self_35 + local slice self_36 + local string<16> self_37 + local slice self_38 + local string<32> self_39 + local [u64; 1] self_4 + local slice self_40 + local slice self_41 + local string<8> self_42 + local slice self_43 + local slice self_44 + local slice self_45 + local slice self_46 + local slice self_5 + local { u64, u64, u64, u64 } self_52 + local u256 self_56 + local [u64; 16] self_6 + local slice self_7 + local [u64; 32] self_8 + local slice self_9 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_10 + local slice slice_11 + local slice slice_12 + local slice slice_13 + local slice slice_14 + local slice slice_15 + local slice slice_16 + local slice slice_17 + local slice slice_18 + local slice slice_19 + local slice slice_2 + local slice slice_20 + local slice slice_21 + local slice slice_22 + local slice slice_23 + local slice slice_24 + local slice slice_25 + local slice slice_26 + local slice slice_27 + local slice slice_28 + local slice slice_29 + local slice slice_3 + local slice slice_30 + local slice slice_31 + local slice slice_32 + local slice slice_4 + local slice slice_5 + local slice slice_6 + local slice slice_7 + local slice slice_8 + local slice slice_9 + local b256 v + local u256 v0 + local [u64; 0] v_ + local [u64; 1] v_0 + local [u64; 16] v_1 + local string<0> v_10 + local string<1> v_11 + local string<16> v_12 + local string<32> v_13 + local string<8> v_14 + local { u64 } v_15 + local { u64, u64 } v_16 + local { u64, u64, u64 } v_17 + local { u64 } v_19 + local [u64; 32] v_2 + local { u64, u64 } v_20 + local { u64, u64, u64 } v_21 + local { u64, u64, u64, u64 } v_22 + local u256 v_24 + local [u64; 64] v_3 + local [u64; 8] v_4 + local b256 v_5 + local { u64, ( u64 ) } v_7 + local { u64, ( u64 | u64 ) } v_8 + local { u64, ( u64 | u64 | u64 ) } v_9 + entry(): + v0 = asm() -> ptr fp, !8 { + } + v1 = const u64 592, !11 + v2 = add v0, v1, !12 + v3 = asm(ptr: v2, val) -> u64 val, !17 { + lw val ptr i0, !18 + } + v4 = asm(ptr: v3) -> ptr ptr, !20 { + } + v5 = get_local __ptr { ptr }, __anon_00, !22 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6, !23 + store v4 to v7, !24 + v8 = get_local __ptr { ptr }, _buffer, !25 + mem_copy_val v8, v5 + v9 = asm() -> ptr fp, !31 { + } + v10 = const u64 584, !34 + v11 = add v9, v10, !35 + v12 = asm(ptr: v11, val) -> u64 val, !38 { + lw val ptr i0, !18 + } + v13 = asm(ptr: v12) -> ptr ptr, !40 { + } + v14 = get_local __ptr { ptr }, __anon_01, !42 + v15 = const u64 0 + v16 = get_elem_ptr v14, __ptr ptr, v15, !43 + store v13 to v16, !44 + v17 = get_local __ptr { ptr }, buffer, !46 + mem_copy_val v17, v14 + v18 = get_local __ptr { ptr }, buffer, !48 + v19 = const u64 0 + v20 = get_elem_ptr v18, __ptr ptr, v19, !54 + v21 = load v20, !55 + v22 = asm(ptr: v21, val) -> u64 val, !57 { + lw val ptr i0, !58 + } + v23 = load v20, !55 + v24 = const u64 8, !55 + v25 = add v23, v24, !55 + store v25 to v20, !60 + v26 = get_local __ptr slice, __ret_val + v27 = call read_bytes_8(v18, v22, v26) + v28 = get_local __ptr slice, data, !62 + mem_copy_val v28, v26 + v29 = get_local __ptr slice, data, !64 + v30 = get_local __ptr slice, self_, !67 + mem_copy_val v30, v29 + v31 = get_local __ptr slice, self_, !70 + v32 = get_local __ptr slice, slice_, !73 + mem_copy_val v32, v31 + v33 = get_local __ptr slice, slice_, !75 + v34 = asm(ptr: v33) -> __ptr { ptr, u64 } ptr { + } + v35 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v35, v34 + v36 = get_local __ptr { ptr, u64 }, __anon_042, !67 + mem_copy_val v36, v35 + v37 = const u64 0 + v38 = get_elem_ptr v36, __ptr ptr, v37, !77 + v39 = get_local __ptr { ptr, u64 }, __anon_000, !79 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr ptr, v40, !80 + mem_copy_val v41, v38 + v42 = const u64 1 + v43 = get_elem_ptr v39, __ptr u64, v42, !81 + store v22 to v43, !82 + v44 = asm(s: v39) -> __ptr slice s { + } + v45 = get_local __ptr slice, __aggr_memcpy_00 + mem_copy_val v45, v44 + v46 = get_local __ptr slice, _method_name, !83 + mem_copy_val v46, v45 + v47 = get_local __ptr slice, _method_name, !84 + v48 = get_global __ptr string<10>, __const_global + v49 = cast_ptr v48 to ptr, !85 + v50 = get_local __ptr { ptr, u64 }, __anon_0, !85 + v51 = const u64 0 + v52 = get_elem_ptr v50, __ptr ptr, v51 + store v49 to v52, !85 + v53 = const u64 1 + v54 = get_elem_ptr v50, __ptr u64, v53 + v55 = const u64 10 + store v55 to v54, !85 + v56 = get_local __ptr slice, __anon_1, !85 + mem_copy_bytes v56, v50, 16 + v57 = get_local __ptr slice, __tmp_arg + mem_copy_val v57, v47 + v58 = get_local __ptr slice, __tmp_arg0 + mem_copy_val v58, v56 + v59 = call eq_11(v57, v58) + cbr v59, block0(), block1(), !86 -test result: FAILED. 28 passed; 1 failed; finished in ??? + block0(): + v60 = get_local __ptr { ptr }, _buffer, !87 + v61 = get_local __ptr [u64; 0], __ret_val5 + v62 = call abi_decode_18(v60, v61) + v63 = get_local __ptr { [u64; 0] }, __anon_02, !93 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr [u64; 0], v64, !94 + mem_copy_val v65, v61 + v66 = get_local __ptr { [u64; 0] }, args, !95 + mem_copy_val v66, v63 + v67 = get_local __ptr { [u64; 0] }, args, !96 + v68 = const u64 0 + v69 = get_elem_ptr v67, __ptr [u64; 0], v68, !97 + v70 = get_local __ptr [u64; 0], v_, !100 + mem_copy_val v70, v69 + v71 = get_local __ptr [u64; 0], v_, !103 + v72 = get_local __ptr [u64; 0], _result, !104 + mem_copy_val v72, v71 + v73 = get_local __ptr [u64; 0], _result, !105 + v74 = get_local __ptr [u64; 0], item_, !108 + mem_copy_val v74, v73 + v75 = get_local __ptr [u64; 0], item_, !110 + v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val28 + v77 = call new_21(v76) + v78 = get_local __ptr [u64; 0], self_2, !113 + mem_copy_val v78, v75 + v79 = get_local __ptr { { ptr, u64, u64 } }, buffer_1, !114 + mem_copy_val v79, v76 + v80 = get_local __ptr { { ptr, u64, u64 } }, buffer_1, !116 + v81 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !118 + mem_copy_val v81, v80 + v82 = const u64 0, !119 + br encode_28_abi_encode_29_while(v82), !120 - Finished in ??? -error: Some tests failed. + encode_28_abi_encode_29_while(v83: u64): + v84 = const u64 0 + v85 = cmp lt v83 v84, !123 + cbr v85, encode_28_abi_encode_29_while_body(), encode_28_abi_encode_29_end_while(), !124 -> Block: ARRAY0 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_28_abi_encode_29_while_body(): + v86 = get_local __ptr [u64; 0], self_2, !126 + v87 = get_elem_ptr v86, __ptr u64, v83, !128 + v88 = load v87, !129 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !131 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg57 + mem_copy_val v90, v89 + v91 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v92 = call abi_encode_20(v88, v90, v91) + v93 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !133 + mem_copy_val v93, v91 + v94 = const u64 1, !134 + v95 = add v83, v94, !137 + br encode_28_abi_encode_29_while(v95), !138 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 101 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.768 KB] in ??? - Running 1 test, filtered 0 tests + encode_28_abi_encode_29_end_while(): + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !140 + v97 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !142 + mem_copy_val v97, v96 + v98 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !144 + v99 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg79 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, __ret_val49 + v101 = call as_raw_slice_22(v99, v100) + v102 = get_local __ptr slice, _result_, !145 + mem_copy_val v102, v100 + v103 = get_local __ptr slice, _result_, !146 + v104 = get_local __ptr slice, self_0, !149 + mem_copy_val v104, v103 + v105 = get_local __ptr slice, self_0, !150 + v106 = get_local __ptr slice, slice_0, !151 + mem_copy_val v106, v105 + v107 = get_local __ptr slice, slice_0, !152 + v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { + } + v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v109, v108 + v110 = get_local __ptr { ptr, u64 }, __anon_043, !149 + mem_copy_val v110, v109 + v111 = get_elem_ptr v110, __ptr ptr, v37, !153 + v112 = load v111, !149 + v113 = get_local __ptr slice, _result_, !154 + v114 = get_local __ptr slice, __tmp_arg100 + mem_copy_val v114, v113 + v115 = call len_30(v114) + retd v112 v115, !155 -tested -- const_of_contract_call + block1(): + v116 = get_local __ptr slice, _method_name, !156 + v117 = get_global __ptr string<10>, __const_global0 + v118 = cast_ptr v117 to ptr, !157 + v119 = get_local __ptr { ptr, u64 }, __anon_2, !157 + v120 = const u64 0 + v121 = get_elem_ptr v119, __ptr ptr, v120 + store v118 to v121, !157 + v122 = const u64 1 + v123 = get_elem_ptr v119, __ptr u64, v122 + v124 = const u64 10 + store v124 to v123, !157 + v125 = get_local __ptr slice, __anon_3, !157 + mem_copy_bytes v125, v119, 16 + v126 = get_local __ptr slice, __tmp_arg1 + mem_copy_val v126, v116 + v127 = get_local __ptr slice, __tmp_arg2 + mem_copy_val v127, v125 + v128 = call eq_11(v126, v127) + cbr v128, block3(), block4(), !158 - test isolated_cost_of_in_array_0 ... FAILED (???, 10911 gas) + block3(): + v129 = get_local __ptr { ptr }, _buffer, !159 + v130 = get_local __ptr [u64; 1], __ret_val70 + v131 = call abi_decode_34(v129, v130) + v132 = get_local __ptr { [u64; 1] }, __anon_03, !162 + v133 = const u64 0 + v134 = get_elem_ptr v132, __ptr [u64; 1], v133, !163 + mem_copy_val v134, v130 + v135 = get_local __ptr { [u64; 1] }, args_, !164 + mem_copy_val v135, v132 + v136 = get_local __ptr { [u64; 1] }, args_, !165 + v137 = const u64 0 + v138 = get_elem_ptr v136, __ptr [u64; 1], v137, !166 + v139 = get_local __ptr [u64; 1], v_0, !169 + mem_copy_val v139, v138 + v140 = get_local __ptr [u64; 1], v_0, !171 + v141 = get_local __ptr [u64; 1], _result__, !172 + mem_copy_val v141, v140 + v142 = get_local __ptr [u64; 1], _result__, !173 + v143 = get_local __ptr [u64; 1], item_0, !176 + mem_copy_val v143, v142 + v144 = get_local __ptr [u64; 1], item_0, !177 + v145 = get_local __ptr { { ptr, u64, u64 } }, __ret_val29 + v146 = call new_21(v145) + v147 = get_local __ptr [u64; 1], self_4, !178 + mem_copy_val v147, v144 + v148 = get_local __ptr { { ptr, u64, u64 } }, buffer_3, !179 + mem_copy_val v148, v145 + v149 = get_local __ptr { { ptr, u64, u64 } }, buffer_3, !180 + v150 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !181 + mem_copy_val v150, v149 + v151 = const u64 0, !119 + br encode_36_abi_encode_37_while(v151), !182 - failures: - test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 - revert code: 0 + encode_36_abi_encode_37_while(v152: u64): + v153 = const u64 1 + v154 = cmp lt v152 v153, !183 + cbr v154, encode_36_abi_encode_37_while_body(), encode_36_abi_encode_37_end_while(), !184 + encode_36_abi_encode_37_while_body(): + v155 = get_local __ptr [u64; 1], self_4, !185 + v156 = get_elem_ptr v155, __ptr u64, v152, !186 + v157 = load v156, !187 + v158 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !188 + v159 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg58 + mem_copy_val v159, v158 + v160 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v161 = call abi_encode_20(v157, v159, v160) + v162 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !189 + mem_copy_val v162, v160 + v163 = const u64 1, !134 + v164 = add v152, v163, !190 + br encode_36_abi_encode_37_while(v164), !191 + encode_36_abi_encode_37_end_while(): + v165 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !192 + v166 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !193 + mem_copy_val v166, v165 + v167 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !194 + v168 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg80 + mem_copy_val v168, v167 + v169 = get_local __ptr slice, __ret_val50 + v170 = call as_raw_slice_22(v168, v169) + v171 = get_local __ptr slice, _result___, !195 + mem_copy_val v171, v169 + v172 = get_local __ptr slice, _result___, !196 + v173 = get_local __ptr slice, self_1, !199 + mem_copy_val v173, v172 + v174 = get_local __ptr slice, self_1, !200 + v175 = get_local __ptr slice, slice_1, !201 + mem_copy_val v175, v174 + v176 = get_local __ptr slice, slice_1, !202 + v177 = asm(ptr: v176) -> __ptr { ptr, u64 } ptr { + } + v178 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v178, v177 + v179 = get_local __ptr { ptr, u64 }, __anon_044, !199 + mem_copy_val v179, v178 + v180 = get_elem_ptr v179, __ptr ptr, v37, !203 + v181 = load v180, !199 + v182 = get_local __ptr slice, _result___, !204 + v183 = get_local __ptr slice, __tmp_arg101 + mem_copy_val v183, v182 + v184 = call len_30(v183) + retd v181 v184, !205 -test result: FAILED. 0 passed; 1 failed; finished in ??? + block4(): + v185 = get_local __ptr slice, _method_name, !206 + v186 = get_global __ptr string<11>, __const_global1 + v187 = cast_ptr v186 to ptr, !207 + v188 = get_local __ptr { ptr, u64 }, __anon_4, !207 + v189 = const u64 0 + v190 = get_elem_ptr v188, __ptr ptr, v189 + store v187 to v190, !207 + v191 = const u64 1 + v192 = get_elem_ptr v188, __ptr u64, v191 + v193 = const u64 11 + store v193 to v192, !207 + v194 = get_local __ptr slice, __anon_5, !207 + mem_copy_bytes v194, v188, 16 + v195 = get_local __ptr slice, __tmp_arg3 + mem_copy_val v195, v185 + v196 = get_local __ptr slice, __tmp_arg4 + mem_copy_val v196, v194 + v197 = call eq_11(v195, v196) + cbr v197, block6(), block7(), !208 - Finished in ??? -error: Some tests failed. + block6(): + v198 = get_local __ptr { ptr }, _buffer, !209 + v199 = get_local __ptr [u64; 16], __ret_val71 + v200 = call abi_decode_40(v198, v199) + v201 = get_local __ptr { [u64; 16] }, __anon_04, !212 + v202 = const u64 0 + v203 = get_elem_ptr v201, __ptr [u64; 16], v202, !213 + mem_copy_val v203, v199 + v204 = get_local __ptr { [u64; 16] }, args__, !214 + mem_copy_val v204, v201 + v205 = get_local __ptr { [u64; 16] }, args__, !215 + v206 = const u64 0 + v207 = get_elem_ptr v205, __ptr [u64; 16], v206, !216 + v208 = get_local __ptr [u64; 16], v_1, !219 + mem_copy_val v208, v207 + v209 = get_local __ptr [u64; 16], v_1, !221 + v210 = get_local __ptr [u64; 16], _result____, !222 + mem_copy_val v210, v209 + v211 = get_local __ptr [u64; 16], _result____, !223 + v212 = get_local __ptr [u64; 16], item_1, !226 + mem_copy_val v212, v211 + v213 = get_local __ptr [u64; 16], item_1, !227 + v214 = get_local __ptr { { ptr, u64, u64 } }, __ret_val30 + v215 = call new_21(v214) + v216 = get_local __ptr [u64; 16], self_6, !228 + mem_copy_val v216, v213 + v217 = get_local __ptr { { ptr, u64, u64 } }, buffer_5, !229 + mem_copy_val v217, v214 + v218 = get_local __ptr { { ptr, u64, u64 } }, buffer_5, !230 + v219 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !231 + mem_copy_val v219, v218 + v220 = const u64 0, !119 + br encode_42_abi_encode_43_while(v220), !232 -> Block: ARRAY1 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_42_abi_encode_43_while(v221: u64): + v222 = const u64 16 + v223 = cmp lt v221 v222, !233 + cbr v223, encode_42_abi_encode_43_while_body(), encode_42_abi_encode_43_end_while(), !234 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.944 KB] in ??? - Running 1 test, filtered 0 tests + encode_42_abi_encode_43_while_body(): + v224 = get_local __ptr [u64; 16], self_6, !235 + v225 = get_elem_ptr v224, __ptr u64, v221, !236 + v226 = load v225, !237 + v227 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !238 + v228 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg59 + mem_copy_val v228, v227 + v229 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v230 = call abi_encode_20(v226, v228, v229) + v231 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !239 + mem_copy_val v231, v229 + v232 = const u64 1, !134 + v233 = add v221, v232, !240 + br encode_42_abi_encode_43_while(v233), !241 -tested -- const_of_contract_call + encode_42_abi_encode_43_end_while(): + v234 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !242 + v235 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !243 + mem_copy_val v235, v234 + v236 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !244 + v237 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg81 + mem_copy_val v237, v236 + v238 = get_local __ptr slice, __ret_val51 + v239 = call as_raw_slice_22(v237, v238) + v240 = get_local __ptr slice, _result_____, !245 + mem_copy_val v240, v238 + v241 = get_local __ptr slice, _result_____, !246 + v242 = get_local __ptr slice, self_3, !249 + mem_copy_val v242, v241 + v243 = get_local __ptr slice, self_3, !250 + v244 = get_local __ptr slice, slice_2, !251 + mem_copy_val v244, v243 + v245 = get_local __ptr slice, slice_2, !252 + v246 = asm(ptr: v245) -> __ptr { ptr, u64 } ptr { + } + v247 = get_local __ptr { ptr, u64 }, __aggr_memcpy_03 + mem_copy_val v247, v246 + v248 = get_local __ptr { ptr, u64 }, __anon_045, !249 + mem_copy_val v248, v247 + v249 = get_elem_ptr v248, __ptr ptr, v37, !253 + v250 = load v249, !249 + v251 = get_local __ptr slice, _result_____, !254 + v252 = get_local __ptr slice, __tmp_arg102 + mem_copy_val v252, v251 + v253 = call len_30(v252) + retd v250 v253, !255 - test isolated_cost_of_in_array_1 ... ok (???, 11355 gas) + block7(): + v254 = get_local __ptr slice, _method_name, !256 + v255 = get_global __ptr string<11>, __const_global2 + v256 = cast_ptr v255 to ptr, !257 + v257 = get_local __ptr { ptr, u64 }, __anon_6, !257 + v258 = const u64 0 + v259 = get_elem_ptr v257, __ptr ptr, v258 + store v256 to v259, !257 + v260 = const u64 1 + v261 = get_elem_ptr v257, __ptr u64, v260 + v262 = const u64 11 + store v262 to v261, !257 + v263 = get_local __ptr slice, __anon_7, !257 + mem_copy_bytes v263, v257, 16 + v264 = get_local __ptr slice, __tmp_arg5 + mem_copy_val v264, v254 + v265 = get_local __ptr slice, __tmp_arg6 + mem_copy_val v265, v263 + v266 = call eq_11(v264, v265) + cbr v266, block9(), block10(), !258 -test result: OK. 1 passed; 0 failed; finished in ??? + block9(): + v267 = get_local __ptr { ptr }, _buffer, !259 + v268 = get_local __ptr [u64; 32], __ret_val72 + v269 = call abi_decode_46(v267, v268) + v270 = get_local __ptr { [u64; 32] }, __anon_05, !262 + v271 = const u64 0 + v272 = get_elem_ptr v270, __ptr [u64; 32], v271, !263 + mem_copy_val v272, v268 + v273 = get_local __ptr { [u64; 32] }, args___, !264 + mem_copy_val v273, v270 + v274 = get_local __ptr { [u64; 32] }, args___, !265 + v275 = const u64 0 + v276 = get_elem_ptr v274, __ptr [u64; 32], v275, !266 + v277 = get_local __ptr [u64; 32], v_2, !269 + mem_copy_val v277, v276 + v278 = get_local __ptr [u64; 32], v_2, !271 + v279 = get_local __ptr [u64; 32], _result______, !272 + mem_copy_val v279, v278 + v280 = get_local __ptr [u64; 32], _result______, !273 + v281 = get_local __ptr [u64; 32], item_2, !276 + mem_copy_val v281, v280 + v282 = get_local __ptr [u64; 32], item_2, !277 + v283 = get_local __ptr { { ptr, u64, u64 } }, __ret_val31 + v284 = call new_21(v283) + v285 = get_local __ptr [u64; 32], self_8, !278 + mem_copy_val v285, v282 + v286 = get_local __ptr { { ptr, u64, u64 } }, buffer_7, !279 + mem_copy_val v286, v283 + v287 = get_local __ptr { { ptr, u64, u64 } }, buffer_7, !280 + v288 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !281 + mem_copy_val v288, v287 + v289 = const u64 0, !119 + br encode_48_abi_encode_49_while(v289), !282 - Finished in ??? + encode_48_abi_encode_49_while(v290: u64): + v291 = const u64 32 + v292 = cmp lt v290 v291, !283 + cbr v292, encode_48_abi_encode_49_while_body(), encode_48_abi_encode_49_end_while(), !284 -> Block: ARRAY16 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_48_abi_encode_49_while_body(): + v293 = get_local __ptr [u64; 32], self_8, !285 + v294 = get_elem_ptr v293, __ptr u64, v290, !286 + v295 = load v294, !287 + v296 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !288 + v297 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg60 + mem_copy_val v297, v296 + v298 = get_local __ptr { { ptr, u64, u64 } }, __ret_val9 + v299 = call abi_encode_20(v295, v297, v298) + v300 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !289 + mem_copy_val v300, v298 + v301 = const u64 1, !134 + v302 = add v290, v301, !290 + br encode_48_abi_encode_49_while(v302), !291 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.968 KB] in ??? - Running 1 test, filtered 0 tests + encode_48_abi_encode_49_end_while(): + v303 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !292 + v304 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !293 + mem_copy_val v304, v303 + v305 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !294 + v306 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg82 + mem_copy_val v306, v305 + v307 = get_local __ptr slice, __ret_val52 + v308 = call as_raw_slice_22(v306, v307) + v309 = get_local __ptr slice, _result_______, !295 + mem_copy_val v309, v307 + v310 = get_local __ptr slice, _result_______, !296 + v311 = get_local __ptr slice, self_5, !299 + mem_copy_val v311, v310 + v312 = get_local __ptr slice, self_5, !300 + v313 = get_local __ptr slice, slice_3, !301 + mem_copy_val v313, v312 + v314 = get_local __ptr slice, slice_3, !302 + v315 = asm(ptr: v314) -> __ptr { ptr, u64 } ptr { + } + v316 = get_local __ptr { ptr, u64 }, __aggr_memcpy_04 + mem_copy_val v316, v315 + v317 = get_local __ptr { ptr, u64 }, __anon_046, !299 + mem_copy_val v317, v316 + v318 = get_elem_ptr v317, __ptr ptr, v37, !303 + v319 = load v318, !299 + v320 = get_local __ptr slice, _result_______, !304 + v321 = get_local __ptr slice, __tmp_arg103 + mem_copy_val v321, v320 + v322 = call len_30(v321) + retd v319 v322, !305 -tested -- const_of_contract_call + block10(): + v323 = get_local __ptr slice, _method_name, !306 + v324 = get_global __ptr string<11>, __const_global3 + v325 = cast_ptr v324 to ptr, !307 + v326 = get_local __ptr { ptr, u64 }, __anon_8, !307 + v327 = const u64 0 + v328 = get_elem_ptr v326, __ptr ptr, v327 + store v325 to v328, !307 + v329 = const u64 1 + v330 = get_elem_ptr v326, __ptr u64, v329 + v331 = const u64 11 + store v331 to v330, !307 + v332 = get_local __ptr slice, __anon_9, !307 + mem_copy_bytes v332, v326, 16 + v333 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v333, v323 + v334 = get_local __ptr slice, __tmp_arg8 + mem_copy_val v334, v332 + v335 = call eq_11(v333, v334) + cbr v335, block12(), block13(), !308 - test isolated_cost_of_in_array_16 ... ok (???, 15174 gas) + block12(): + v336 = get_local __ptr { ptr }, _buffer, !309 + v337 = get_local __ptr [u64; 64], __ret_val73 + v338 = call abi_decode_52(v336, v337) + v339 = get_local __ptr { [u64; 64] }, __anon_06, !312 + v340 = const u64 0 + v341 = get_elem_ptr v339, __ptr [u64; 64], v340, !313 + mem_copy_val v341, v337 + v342 = get_local __ptr { [u64; 64] }, args____, !314 + mem_copy_val v342, v339 + v343 = get_local __ptr { [u64; 64] }, args____, !315 + v344 = const u64 0 + v345 = get_elem_ptr v343, __ptr [u64; 64], v344, !316 + v346 = get_local __ptr [u64; 64], v_3, !319 + mem_copy_val v346, v345 + v347 = get_local __ptr [u64; 64], v_3, !321 + v348 = get_local __ptr [u64; 64], _result________, !322 + mem_copy_val v348, v347 + v349 = get_local __ptr [u64; 64], _result________, !323 + v350 = get_local __ptr [u64; 64], item_3, !326 + mem_copy_val v350, v349 + v351 = get_local __ptr [u64; 64], item_3, !327 + v352 = get_local __ptr { { ptr, u64, u64 } }, __ret_val32 + v353 = call new_21(v352) + v354 = get_local __ptr [u64; 64], self_14, !328 + mem_copy_val v354, v351 + v355 = get_local __ptr { { ptr, u64, u64 } }, buffer_9, !329 + mem_copy_val v355, v352 + v356 = get_local __ptr { { ptr, u64, u64 } }, buffer_9, !330 + v357 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !331 + mem_copy_val v357, v356 + v358 = const u64 0, !119 + br encode_54_abi_encode_55_while(v358), !332 -test result: OK. 1 passed; 0 failed; finished in ??? + encode_54_abi_encode_55_while(v359: u64): + v360 = const u64 64 + v361 = cmp lt v359 v360, !333 + cbr v361, encode_54_abi_encode_55_while_body(), encode_54_abi_encode_55_end_while(), !334 - Finished in ??? + encode_54_abi_encode_55_while_body(): + v362 = get_local __ptr [u64; 64], self_14, !335 + v363 = get_elem_ptr v362, __ptr u64, v359, !336 + v364 = load v363, !337 + v365 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !338 + v366 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg61 + mem_copy_val v366, v365 + v367 = get_local __ptr { { ptr, u64, u64 } }, __ret_val10 + v368 = call abi_encode_20(v364, v366, v367) + v369 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !339 + mem_copy_val v369, v367 + v370 = const u64 1, !134 + v371 = add v359, v370, !340 + br encode_54_abi_encode_55_while(v371), !341 -> Block: ARRAY32 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_54_abi_encode_55_end_while(): + v372 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !342 + v373 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !343 + mem_copy_val v373, v372 + v374 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !344 + v375 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg83 + mem_copy_val v375, v374 + v376 = get_local __ptr slice, __ret_val53 + v377 = call as_raw_slice_22(v375, v376) + v378 = get_local __ptr slice, _result_________, !345 + mem_copy_val v378, v376 + v379 = get_local __ptr slice, _result_________, !346 + v380 = get_local __ptr slice, self_7, !349 + mem_copy_val v380, v379 + v381 = get_local __ptr slice, self_7, !350 + v382 = get_local __ptr slice, slice_4, !351 + mem_copy_val v382, v381 + v383 = get_local __ptr slice, slice_4, !352 + v384 = asm(ptr: v383) -> __ptr { ptr, u64 } ptr { + } + v385 = get_local __ptr { ptr, u64 }, __aggr_memcpy_05 + mem_copy_val v385, v384 + v386 = get_local __ptr { ptr, u64 }, __anon_047, !349 + mem_copy_val v386, v385 + v387 = get_elem_ptr v386, __ptr ptr, v37, !353 + v388 = load v387, !349 + v389 = get_local __ptr slice, _result_________, !354 + v390 = get_local __ptr slice, __tmp_arg104 + mem_copy_val v390, v389 + v391 = call len_30(v390) + retd v388 v391, !355 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.968 KB] in ??? - Running 1 test, filtered 0 tests + block13(): + v392 = get_local __ptr slice, _method_name, !356 + v393 = get_global __ptr string<10>, __const_global4 + v394 = cast_ptr v393 to ptr, !357 + v395 = get_local __ptr { ptr, u64 }, __anon_10, !357 + v396 = const u64 0 + v397 = get_elem_ptr v395, __ptr ptr, v396 + store v394 to v397, !357 + v398 = const u64 1 + v399 = get_elem_ptr v395, __ptr u64, v398 + v400 = const u64 10 + store v400 to v399, !357 + v401 = get_local __ptr slice, __anon_11, !357 + mem_copy_bytes v401, v395, 16 + v402 = get_local __ptr slice, __tmp_arg9 + mem_copy_val v402, v392 + v403 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v403, v401 + v404 = call eq_11(v402, v403) + cbr v404, block15(), block16(), !358 -tested -- const_of_contract_call + block15(): + v405 = get_local __ptr { ptr }, _buffer, !359 + v406 = get_local __ptr [u64; 8], __ret_val74 + v407 = call abi_decode_58(v405, v406) + v408 = get_local __ptr { [u64; 8] }, __anon_07, !362 + v409 = const u64 0 + v410 = get_elem_ptr v408, __ptr [u64; 8], v409, !363 + mem_copy_val v410, v406 + v411 = get_local __ptr { [u64; 8] }, args_____, !364 + mem_copy_val v411, v408 + v412 = get_local __ptr { [u64; 8] }, args_____, !365 + v413 = const u64 0 + v414 = get_elem_ptr v412, __ptr [u64; 8], v413, !366 + v415 = get_local __ptr [u64; 8], v_4, !369 + mem_copy_val v415, v414 + v416 = get_local __ptr [u64; 8], v_4, !371 + v417 = get_local __ptr [u64; 8], __tmp_arg128 + mem_copy_val v417, v416 + v418 = get_local __ptr slice, __ret_val75 + v419 = call encode_60(v417, v418) + v420 = get_local __ptr slice, __log_arg + mem_copy_val v420, v418 + v421 = const u64 3565715504387854074 + log __ptr slice v420, v421 + v422 = get_local __ptr [u64; 8], v_4, !373 + v423 = get_local __ptr [u64; 8], _result__________, !374 + mem_copy_val v423, v422 + v424 = get_local __ptr [u64; 8], _result__________, !375 + v425 = get_local __ptr [u64; 8], __tmp_arg129 + mem_copy_val v425, v424 + v426 = get_local __ptr slice, __ret_val76 + v427 = call encode_60(v425, v426) + v428 = get_local __ptr slice, _result___________, !376 + mem_copy_val v428, v426 + v429 = get_local __ptr slice, _result___________, !377 + v430 = get_local __ptr slice, self_9, !380 + mem_copy_val v430, v429 + v431 = get_local __ptr slice, self_9, !381 + v432 = get_local __ptr slice, slice_5, !382 + mem_copy_val v432, v431 + v433 = get_local __ptr slice, slice_5, !383 + v434 = asm(ptr: v433) -> __ptr { ptr, u64 } ptr { + } + v435 = get_local __ptr { ptr, u64 }, __aggr_memcpy_06 + mem_copy_val v435, v434 + v436 = get_local __ptr { ptr, u64 }, __anon_048, !380 + mem_copy_val v436, v435 + v437 = get_elem_ptr v436, __ptr ptr, v37, !384 + v438 = load v437, !380 + v439 = get_local __ptr slice, _result___________, !385 + v440 = get_local __ptr slice, __tmp_arg105 + mem_copy_val v440, v439 + v441 = call len_30(v440) + retd v438 v441, !386 - test isolated_cost_of_in_array_32 ... ok (???, 19221 gas) + block16(): + v442 = get_local __ptr slice, _method_name, !387 + v443 = get_global __ptr string<7>, __const_global5 + v444 = cast_ptr v443 to ptr, !388 + v445 = get_local __ptr { ptr, u64 }, __anon_12, !388 + v446 = const u64 0 + v447 = get_elem_ptr v445, __ptr ptr, v446 + store v444 to v447, !388 + v448 = const u64 1 + v449 = get_elem_ptr v445, __ptr u64, v448 + v450 = const u64 7 + store v450 to v449, !388 + v451 = get_local __ptr slice, __anon_13, !388 + mem_copy_bytes v451, v445, 16 + v452 = get_local __ptr slice, __tmp_arg11 + mem_copy_val v452, v442 + v453 = get_local __ptr slice, __tmp_arg12 + mem_copy_val v453, v451 + v454 = call eq_11(v452, v453) + cbr v454, block18(), block19(), !389 -test result: OK. 1 passed; 0 failed; finished in ??? + block18(): + v455 = get_local __ptr { ptr }, _buffer, !390 + v456 = const u64 0 + v457 = get_elem_ptr v455, __ptr ptr, v456, !397 + v458 = load v457, !398 + v459 = asm(ptr: v458) -> __ptr b256 ptr { + } + v460 = get_local __ptr b256, __aggr_memcpy_07 + mem_copy_val v460, v459 + v461 = get_local __ptr b256, v, !400 + mem_copy_val v461, v460 + v462 = load v457, !401 + v463 = const u64 32, !402 + v464 = add v462, v463, !403 + store v464 to v457, !405 + v465 = get_local __ptr b256, v, !407 + v466 = get_local __ptr { b256 }, __anon_08, !408 + v467 = const u64 0 + v468 = get_elem_ptr v466, __ptr b256, v467, !409 + mem_copy_val v468, v465 + v469 = get_local __ptr { b256 }, args______, !410 + mem_copy_val v469, v466 + v470 = get_local __ptr { b256 }, args______, !411 + v471 = const u64 0 + v472 = get_elem_ptr v470, __ptr b256, v471, !412 + v473 = get_local __ptr b256, v_5, !415 + mem_copy_val v473, v472 + v474 = get_local __ptr b256, v_5, !417 + v475 = get_local __ptr b256, _result____________, !418 + mem_copy_val v475, v474 + v476 = get_local __ptr b256, _result____________, !419 + v477 = get_local __ptr b256, item_4, !422 + mem_copy_val v477, v476 + v478 = get_local __ptr b256, item_4, !423 + v479 = get_local __ptr { { ptr, u64, u64 } }, __ret_val33 + v480 = call new_21(v479) + v481 = get_local __ptr b256, self_18, !424 + mem_copy_val v481, v478 + v482 = get_local __ptr { { ptr, u64, u64 } }, buffer_12, !425 + mem_copy_val v482, v479 + v483 = get_local __ptr { { ptr, u64, u64 } }, buffer_12, !427 + v484 = const u64 0 + v485 = get_elem_ptr v483, __ptr { ptr, u64, u64 }, v484, !429 + v486 = asm(buffer: v485) -> __ptr { ptr, u64, u64 } buffer { + } + v487 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_08 + mem_copy_val v487, v486 + v488 = get_local __ptr { ptr, u64, u64 }, __anon_09, !430 + mem_copy_val v488, v487 + v489 = const u64 0 + v490 = get_elem_ptr v488, __ptr ptr, v489, !431 + v491 = load v490, !432 + v492 = const u64 1 + v493 = get_elem_ptr v488, __ptr u64, v492, !433 + v494 = load v493, !434 + v495 = const u64 2 + v496 = get_elem_ptr v488, __ptr u64, v495, !435 + v497 = load v496, !436 + v498 = get_local __ptr b256, self_18, !438 + v499 = const u64 32 + v500 = add v497, v499, !439 + v501 = cmp gt v500 v494, !440 + cbr v501, encode_67_abi_encode_68_block1(), encode_67_abi_encode_68_block0(v491, v494), !441 - Finished in ??? + encode_67_abi_encode_68_block0(v502: ptr, v503: u64): + v504 = get_local __ptr b256, __anon_110, !442 + mem_copy_val v504, v498 + v505 = add v502, v497, !443 + v506 = cast_ptr v505 to __ptr u8, !444 + mem_copy_bytes v506, v504, 32, !445 + v507 = get_local __ptr { ptr, u64, u64 }, __anon_210, !446 + v508 = const u64 0 + v509 = get_elem_ptr v507, __ptr ptr, v508, !447 + store v502 to v509, !448 + v510 = const u64 1 + v511 = get_elem_ptr v507, __ptr u64, v510, !449 + store v503 to v511, !450 + v512 = const u64 2 + v513 = get_elem_ptr v507, __ptr u64, v512, !451 + store v500 to v513, !452 + v514 = asm(buffer: v507) -> __ptr { ptr, u64, u64 } buffer { + } + v515 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_09 + mem_copy_val v515, v514 + v516 = get_local __ptr { { ptr, u64, u64 } }, __anon_310, !454 + v517 = const u64 0 + v518 = get_elem_ptr v516, __ptr { ptr, u64, u64 }, v517, !455 + mem_copy_val v518, v515 + v519 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !456 + mem_copy_val v519, v516 + v520 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !457 + v521 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg84 + mem_copy_val v521, v520 + v522 = get_local __ptr slice, __ret_val54 + v523 = call as_raw_slice_22(v521, v522) + v524 = get_local __ptr slice, _result_____________, !458 + mem_copy_val v524, v522 + v525 = get_local __ptr slice, _result_____________, !459 + v526 = get_local __ptr slice, self_10, !462 + mem_copy_val v526, v525 + v527 = get_local __ptr slice, self_10, !463 + v528 = get_local __ptr slice, slice_6, !464 + mem_copy_val v528, v527 + v529 = get_local __ptr slice, slice_6, !465 + v530 = asm(ptr: v529) -> __ptr { ptr, u64 } ptr { + } + v531 = get_local __ptr { ptr, u64 }, __aggr_memcpy_010 + mem_copy_val v531, v530 + v532 = get_local __ptr { ptr, u64 }, __anon_049, !462 + mem_copy_val v532, v531 + v533 = get_elem_ptr v532, __ptr ptr, v37, !466 + v534 = load v533, !462 + v535 = get_local __ptr slice, _result_____________, !467 + v536 = get_local __ptr slice, __tmp_arg106 + mem_copy_val v536, v535 + v537 = call len_30(v536) + retd v534 v537, !468 -> Block: ARRAY64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_67_abi_encode_68_block1(): + v538 = const u64 2 + v539 = mul v494, v538, !469 + v540 = add v539, v499, !470 + v541 = asm(new_cap: v540, old_ptr: v491, len: v497) -> __ptr u8 hp, !471 { + aloc new_cap + mcp hp old_ptr len + } + br encode_67_abi_encode_68_block0(v541, v540), !472 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.008 KB] in ??? - Running 1 test, filtered 0 tests + block19(): + v542 = get_local __ptr slice, _method_name, !473 + v543 = get_global __ptr string<7>, __const_global6 + v544 = cast_ptr v543 to ptr, !474 + v545 = get_local __ptr { ptr, u64 }, __anon_14, !474 + v546 = const u64 0 + v547 = get_elem_ptr v545, __ptr ptr, v546 + store v544 to v547, !474 + v548 = const u64 1 + v549 = get_elem_ptr v545, __ptr u64, v548 + v550 = const u64 7 + store v550 to v549, !474 + v551 = get_local __ptr slice, __anon_15, !474 + mem_copy_bytes v551, v545, 16 + v552 = get_local __ptr slice, __tmp_arg13 + mem_copy_val v552, v542 + v553 = get_local __ptr slice, __tmp_arg14 + mem_copy_val v553, v551 + v554 = call eq_11(v552, v553) + cbr v554, block21(), block22(), !475 -tested -- const_of_contract_call + block21(): + v555 = get_local __ptr { ptr }, _buffer, !476 + v556 = call read_72(v555), !481 + v557 = const u8 0, !482 + v558 = cmp eq v556 v557, !485 + v559 = const bool false, !486 + cbr v558, decode_69_abi_decode_70_abi_decode_71_block5(v559), decode_69_abi_decode_70_abi_decode_71_block1(), !487 - test isolated_cost_of_in_array_64 ... ok (???, 27369 gas) + decode_69_abi_decode_70_abi_decode_71_block1(): + v560 = const u8 1, !488 + v561 = cmp eq v556 v560, !491 + v562 = const bool true, !492 + cbr v561, decode_69_abi_decode_70_abi_decode_71_block5(v562), decode_69_abi_decode_70_abi_decode_71_block3(), !493 -test result: OK. 1 passed; 0 failed; finished in ??? + decode_69_abi_decode_70_abi_decode_71_block3(): + v563 = const u64 0, !494 + revert v563, !496 - Finished in ??? + decode_69_abi_decode_70_abi_decode_71_block5(v564: bool): + v565 = get_local __ptr { bool }, __anon_010, !497 + v566 = const u64 0 + v567 = get_elem_ptr v565, __ptr bool, v566, !498 + store v564 to v567, !499 + v568 = get_local __ptr { bool }, args_______, !500 + mem_copy_val v568, v565 + v569 = get_local __ptr { bool }, args_______, !501 + v570 = const u64 0 + v571 = get_elem_ptr v569, __ptr bool, v570, !502 + v572 = load v571 + v573 = get_local __ptr { { ptr, u64, u64 } }, __ret_val34 + v574 = call new_21(v573) + v575 = get_local __ptr { { ptr, u64, u64 } }, buffer_14, !505 + mem_copy_val v575, v573 + v576 = get_local __ptr { { ptr, u64, u64 } }, buffer_14, !507 + v577 = const u64 0 + v578 = get_elem_ptr v576, __ptr { ptr, u64, u64 }, v577, !508 + v579 = asm(buffer: v578) -> __ptr { ptr, u64, u64 } buffer { + } + v580 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_011 + mem_copy_val v580, v579 + v581 = get_local __ptr { ptr, u64, u64 }, __anon_011, !509 + mem_copy_val v581, v580 + v582 = const u64 0 + v583 = get_elem_ptr v581, __ptr ptr, v582, !510 + v584 = load v583, !511 + v585 = const u64 1 + v586 = get_elem_ptr v581, __ptr u64, v585, !512 + v587 = load v586, !513 + v588 = const u64 2 + v589 = get_elem_ptr v581, __ptr u64, v588, !514 + v590 = load v589, !515 + v591 = const u64 1 + v592 = add v590, v591, !516 + v593 = cmp gt v592 v587, !517 + cbr v593, encode_76_abi_encode_77_block1(), encode_76_abi_encode_77_block0(v584, v587), !518 -> Block: ARRAY8 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_76_abi_encode_77_block0(v594: ptr, v595: u64): + v596 = add v594, v590, !519 + v597 = cast_ptr v596 to __ptr bool, !520 + store v572 to v597, !521 + v598 = get_local __ptr { ptr, u64, u64 }, __anon_111, !522 + v599 = const u64 0 + v600 = get_elem_ptr v598, __ptr ptr, v599, !523 + store v594 to v600, !524 + v601 = const u64 1 + v602 = get_elem_ptr v598, __ptr u64, v601, !525 + store v595 to v602, !526 + v603 = const u64 2 + v604 = get_elem_ptr v598, __ptr u64, v603, !527 + store v592 to v604, !528 + v605 = asm(buffer: v598) -> __ptr { ptr, u64, u64 } buffer { + } + v606 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_012 + mem_copy_val v606, v605 + v607 = get_local __ptr { { ptr, u64, u64 } }, __anon_211, !530 + v608 = const u64 0 + v609 = get_elem_ptr v607, __ptr { ptr, u64, u64 }, v608, !531 + mem_copy_val v609, v606 + v610 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !532 + mem_copy_val v610, v607 + v611 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !533 + v612 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg85 + mem_copy_val v612, v611 + v613 = get_local __ptr slice, __ret_val55 + v614 = call as_raw_slice_22(v612, v613) + v615 = get_local __ptr slice, _result_______________, !534 + mem_copy_val v615, v613 + v616 = get_local __ptr slice, _result_______________, !535 + v617 = get_local __ptr slice, self_11, !538 + mem_copy_val v617, v616 + v618 = get_local __ptr slice, self_11, !539 + v619 = get_local __ptr slice, slice_7, !540 + mem_copy_val v619, v618 + v620 = get_local __ptr slice, slice_7, !541 + v621 = asm(ptr: v620) -> __ptr { ptr, u64 } ptr { + } + v622 = get_local __ptr { ptr, u64 }, __aggr_memcpy_013 + mem_copy_val v622, v621 + v623 = get_local __ptr { ptr, u64 }, __anon_050, !538 + mem_copy_val v623, v622 + v624 = get_elem_ptr v623, __ptr ptr, v37, !542 + v625 = load v624, !538 + v626 = get_local __ptr slice, _result_______________, !543 + v627 = get_local __ptr slice, __tmp_arg107 + mem_copy_val v627, v626 + v628 = call len_30(v627) + retd v625 v628, !544 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.104 KB] in ??? - Running 1 test, filtered 0 tests + encode_76_abi_encode_77_block1(): + v629 = const u64 2 + v630 = mul v587, v629, !545 + v631 = add v630, v591, !546 + v632 = asm(new_cap: v631, old_ptr: v584, len: v590) -> __ptr u8 hp, !547 { + aloc new_cap + mcp hp old_ptr len + } + br encode_76_abi_encode_77_block0(v632, v631), !548 -tested -- const_of_contract_call + block22(): + v633 = get_local __ptr slice, _method_name, !549 + v634 = get_global __ptr string<11>, __const_global7 + v635 = cast_ptr v634 to ptr, !550 + v636 = get_local __ptr { ptr, u64 }, __anon_16, !550 + v637 = const u64 0 + v638 = get_elem_ptr v636, __ptr ptr, v637 + store v635 to v638, !550 + v639 = const u64 1 + v640 = get_elem_ptr v636, __ptr u64, v639 + v641 = const u64 11 + store v641 to v640, !550 + v642 = get_local __ptr slice, __anon_17, !550 + mem_copy_bytes v642, v636, 16 + v643 = get_local __ptr slice, __tmp_arg15 + mem_copy_val v643, v633 + v644 = get_local __ptr slice, __tmp_arg16 + mem_copy_val v644, v642 + v645 = call eq_11(v643, v644) + cbr v645, block24(), block25(), !551 - test isolated_cost_of_in_array_8 ... ok (???, 14558 gas) + block24(): + v646 = get_local __ptr { ptr }, _buffer, !552 + v647 = get_elem_ptr v646, __ptr ptr, v19, !559 + v648 = load v647, !560 + v649 = asm(ptr: v648, val) -> u64 val, !561 { + lw val ptr i0, !58 + } + v650 = load v647, !560 + v651 = const u64 8, !560 + v652 = add v650, v651, !560 + store v652 to v647, !562 + v653 = const u64 0, !563 + v654 = cmp eq v649 v653, !566 + cbr v654, decode_78_abi_decode_79_abi_decode_80_block0(), decode_78_abi_decode_79_abi_decode_80_block1(), !567 -test result: OK. 1 passed; 0 failed; finished in ??? + decode_78_abi_decode_79_abi_decode_80_block0(): + v655 = get_local __ptr { u64, ( u64 ) }, __anon_001, !569 + v656 = const u64 0 + v657 = get_elem_ptr v655, __ptr u64, v656, !570 + v658 = const u64 0, !568 + store v658 to v657, !571 + v659 = load v647, !574 + v660 = asm(ptr: v659, val) -> u64 val, !575 { + lw val ptr i0, !58 + } + v661 = load v647, !574 + v662 = const u64 8, !574 + v663 = add v661, v662, !574 + store v663 to v647, !576 + v664 = const u64 1 + v665 = const u64 0 + v666 = get_elem_ptr v655, __ptr u64, v664, v665, !577 + store v660 to v666, !578 + v667 = get_local __ptr { { u64, ( u64 ) } }, __anon_012, !579 + v668 = const u64 0 + v669 = get_elem_ptr v667, __ptr { u64, ( u64 ) }, v668, !580 + mem_copy_val v669, v655 + v670 = get_local __ptr { { u64, ( u64 ) } }, args________, !581 + mem_copy_val v670, v667 + v671 = get_local __ptr { { u64, ( u64 ) } }, args________, !582 + v672 = const u64 0 + v673 = get_elem_ptr v671, __ptr { u64, ( u64 ) }, v672, !583 + v674 = get_local __ptr { u64, ( u64 ) }, v_7, !586 + mem_copy_val v674, v673 + v675 = get_local __ptr { u64, ( u64 ) }, v_7, !588 + v676 = get_local __ptr { u64, ( u64 ) }, _result________________, !589 + mem_copy_val v676, v675 + v677 = get_local __ptr { u64, ( u64 ) }, _result________________, !590 + v678 = get_local __ptr { u64, ( u64 ) }, item_6, !593 + mem_copy_val v678, v677 + v679 = get_local __ptr { u64, ( u64 ) }, item_6, !594 + v680 = get_local __ptr { { ptr, u64, u64 } }, __ret_val35 + v681 = call new_21(v680) + v682 = get_local __ptr { u64, ( u64 ) }, self_22, !595 + mem_copy_val v682, v679 + v683 = get_local __ptr { { ptr, u64, u64 } }, buffer_17, !596 + mem_copy_val v683, v680 + v684 = get_local __ptr { u64, ( u64 ) }, self_22, !598 + v685 = get_local __ptr { u64, ( u64 ) }, __matched_value_10, !600 + mem_copy_val v685, v684 + v686 = get_local __ptr { u64, ( u64 ) }, __matched_value_10, !601 + v687 = const u64 0 + v688 = get_elem_ptr v686, __ptr u64, v687, !602 + v689 = load v688, !603 + v690 = const u64 0, !597 + v691 = cmp eq v689 v690, !606 + cbr v691, encode_82_abi_encode_83_block0(), encode_82_abi_encode_83_block1(), !607 - Finished in ??? + decode_78_abi_decode_79_abi_decode_80_block1(): + v692 = const u64 0, !608 + revert v692, !610 -> Block: B256 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_82_abi_encode_83_block0(): + v693 = get_local __ptr { u64, ( u64 ) }, __matched_value_10, !611 + v694 = const u64 1 + v695 = const u64 0 + v696 = get_elem_ptr v693, __ptr u64, v694, v695, !612 + v697 = load v696, !613 + v698 = get_local __ptr { { ptr, u64, u64 } }, buffer_17, !615 + v699 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg62 + mem_copy_val v699, v698 + v700 = get_local __ptr { { ptr, u64, u64 } }, __ret_val11 + v701 = const u64 0, !616 + v702 = call abi_encode_20(v701, v699, v700) + v703 = get_local __ptr { { ptr, u64, u64 } }, buffer__4, !618 + mem_copy_val v703, v700 + v704 = get_local __ptr { { ptr, u64, u64 } }, buffer__4, !620 + v705 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg63 + mem_copy_val v705, v704 + v706 = get_local __ptr { { ptr, u64, u64 } }, __ret_val12 + v707 = call abi_encode_20(v697, v705, v706) + v708 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !622 + mem_copy_val v708, v706 + v709 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !624 + v710 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !626 + mem_copy_val v710, v709 + v711 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !628 + v712 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !629 + mem_copy_val v712, v711 + v713 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !630 + v714 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg86 + mem_copy_val v714, v713 + v715 = get_local __ptr slice, __ret_val56 + v716 = call as_raw_slice_22(v714, v715) + v717 = get_local __ptr slice, _result_________________, !631 + mem_copy_val v717, v715 + v718 = get_local __ptr slice, _result_________________, !632 + v719 = get_local __ptr slice, self_12, !635 + mem_copy_val v719, v718 + v720 = get_local __ptr slice, self_12, !636 + v721 = get_local __ptr slice, slice_8, !637 + mem_copy_val v721, v720 + v722 = get_local __ptr slice, slice_8, !638 + v723 = asm(ptr: v722) -> __ptr { ptr, u64 } ptr { + } + v724 = get_local __ptr { ptr, u64 }, __aggr_memcpy_014 + mem_copy_val v724, v723 + v725 = get_local __ptr { ptr, u64 }, __anon_051, !635 + mem_copy_val v725, v724 + v726 = get_elem_ptr v725, __ptr ptr, v37, !639 + v727 = load v726, !635 + v728 = get_local __ptr slice, _result_________________, !640 + v729 = get_local __ptr slice, __tmp_arg108 + mem_copy_val v729, v728 + v730 = call len_30(v729) + retd v727 v730, !641 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.808 KB] in ??? - Running 1 test, filtered 0 tests + encode_82_abi_encode_83_block1(): + v731 = const u64 14757395258967588866, !599 + revert v731, !642 -tested -- const_of_contract_call + block25(): + v732 = get_local __ptr slice, _method_name, !643 + v733 = get_global __ptr string<15>, __const_global8 + v734 = cast_ptr v733 to ptr, !644 + v735 = get_local __ptr { ptr, u64 }, __anon_18, !644 + v736 = const u64 0 + v737 = get_elem_ptr v735, __ptr ptr, v736 + store v734 to v737, !644 + v738 = const u64 1 + v739 = get_elem_ptr v735, __ptr u64, v738 + v740 = const u64 15 + store v740 to v739, !644 + v741 = get_local __ptr slice, __anon_19, !644 + mem_copy_bytes v741, v735, 16 + v742 = get_local __ptr slice, __tmp_arg17 + mem_copy_val v742, v732 + v743 = get_local __ptr slice, __tmp_arg18 + mem_copy_val v743, v741 + v744 = call eq_11(v742, v743) + cbr v744, block27(), block28(), !645 - test isolated_cost_of_in_b256 ... ok (???, 11220 gas) + block27(): + v745 = get_local __ptr { ptr }, _buffer, !646 + v746 = get_elem_ptr v745, __ptr ptr, v19, !651 + v747 = load v746, !652 + v748 = asm(ptr: v747, val) -> u64 val, !653 { + lw val ptr i0, !58 + } + v749 = load v746, !652 + v750 = const u64 8, !652 + v751 = add v749, v750, !652 + store v751 to v746, !654 + v752 = const u64 0, !655 + v753 = cmp eq v748 v752, !658 + cbr v753, decode_84_abi_decode_85_abi_decode_86_block0(), decode_84_abi_decode_85_abi_decode_86_block1(), !659 -test result: OK. 1 passed; 0 failed; finished in ??? + decode_84_abi_decode_85_abi_decode_86_block0(): + v754 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_002, !661 + v755 = const u64 0 + v756 = get_elem_ptr v754, __ptr u64, v755, !662 + v757 = const u64 0, !660 + store v757 to v756, !663 + v758 = load v746, !666 + v759 = asm(ptr: v758, val) -> u64 val, !667 { + lw val ptr i0, !58 + } + v760 = load v746, !666 + v761 = const u64 8, !666 + v762 = add v760, v761, !666 + store v762 to v746, !668 + v763 = const u64 1 + v764 = const u64 0 + v765 = get_elem_ptr v754, __ptr u64, v763, v764, !669 + store v759 to v765, !670 + v766 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg + mem_copy_val v766, v754 + br decode_84_abi_decode_85_abi_decode_86_block5(v766), !671 - Finished in ??? + decode_84_abi_decode_85_abi_decode_86_block1(): + v767 = const u64 1, !672 + v768 = cmp eq v748 v767, !675 + cbr v768, decode_84_abi_decode_85_abi_decode_86_block2(), decode_84_abi_decode_85_abi_decode_86_block3(), !676 -> Block: BOOL -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + decode_84_abi_decode_85_abi_decode_86_block2(): + v769 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_112, !677 + v770 = const u64 0 + v771 = get_elem_ptr v769, __ptr u64, v770, !678 + v772 = const u64 1, !660 + store v772 to v771, !679 + v773 = load v746, !681 + v774 = asm(ptr: v773, val) -> u64 val, !682 { + lw val ptr i0, !58 + } + v775 = load v746, !681 + v776 = const u64 8, !681 + v777 = add v775, v776, !681 + store v777 to v746, !683 + v778 = const u64 1 + v779 = const u64 1 + v780 = get_elem_ptr v769, __ptr u64, v778, v779, !684 + store v774 to v780, !685 + v781 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg + mem_copy_val v781, v769 + br decode_84_abi_decode_85_abi_decode_86_block5(v781), !686 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.696 KB] in ??? - Running 1 test, filtered 0 tests + decode_84_abi_decode_85_abi_decode_86_block3(): + v782 = const u64 0, !687 + revert v782, !689 -tested -- const_of_contract_call + decode_84_abi_decode_85_abi_decode_86_block5(v783: __ptr { u64, ( u64 | u64 ) }): + v784 = get_local __ptr { { u64, ( u64 | u64 ) } }, __anon_013, !690 + v785 = const u64 0 + v786 = get_elem_ptr v784, __ptr { u64, ( u64 | u64 ) }, v785, !691 + mem_copy_val v786, v783 + v787 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !692 + mem_copy_val v787, v784 + v788 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !693 + v789 = const u64 0 + v790 = get_elem_ptr v788, __ptr { u64, ( u64 | u64 ) }, v789, !694 + v791 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !697 + mem_copy_val v791, v790 + v792 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !699 + v793 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !700 + mem_copy_val v793, v792 + v794 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !701 + v795 = get_local __ptr { u64, ( u64 | u64 ) }, item_7, !704 + mem_copy_val v795, v794 + v796 = get_local __ptr { u64, ( u64 | u64 ) }, item_7, !705 + v797 = get_local __ptr { { ptr, u64, u64 } }, __ret_val36 + v798 = call new_21(v797) + v799 = get_local __ptr { u64, ( u64 | u64 ) }, self_25, !706 + mem_copy_val v799, v796 + v800 = get_local __ptr { { ptr, u64, u64 } }, buffer_21, !707 + mem_copy_val v800, v797 + v801 = get_local __ptr { u64, ( u64 | u64 ) }, self_25, !709 + v802 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !711 + mem_copy_val v802, v801 + v803 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !712 + v804 = const u64 0 + v805 = get_elem_ptr v803, __ptr u64, v804, !713 + v806 = load v805, !714 + v807 = const u64 0, !708 + v808 = cmp eq v806 v807, !717 + cbr v808, encode_88_abi_encode_89_block0(), encode_88_abi_encode_89_block1(), !718 - test isolated_cost_of_in_bool ... ok (???, 11100 gas) + encode_88_abi_encode_89_block0(): + v809 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !719 + v810 = const u64 1 + v811 = const u64 0 + v812 = get_elem_ptr v809, __ptr u64, v810, v811, !720 + v813 = load v812, !721 + v814 = get_local __ptr { { ptr, u64, u64 } }, buffer_21, !723 + v815 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg64 + mem_copy_val v815, v814 + v816 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v817 = const u64 0, !724 + v818 = call abi_encode_20(v817, v815, v816) + v819 = get_local __ptr { { ptr, u64, u64 } }, buffer__5, !726 + mem_copy_val v819, v816 + v820 = get_local __ptr { { ptr, u64, u64 } }, buffer__5, !728 + v821 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg65 + mem_copy_val v821, v820 + v822 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v823 = call abi_encode_20(v813, v821, v822) + v824 = get_local __ptr { { ptr, u64, u64 } }, buffer___0, !730 + mem_copy_val v824, v822 + v825 = get_local __ptr { { ptr, u64, u64 } }, buffer___0, !732 + v826 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg0 + mem_copy_val v826, v825 + br encode_88_abi_encode_89_block5(v826), !733 -test result: OK. 1 passed; 0 failed; finished in ??? + encode_88_abi_encode_89_block1(): + v827 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !734 + v828 = const u64 0 + v829 = get_elem_ptr v827, __ptr u64, v828, !735 + v830 = load v829, !736 + v831 = const u64 1, !708 + v832 = cmp eq v830 v831, !739 + cbr v832, encode_88_abi_encode_89_block2(), encode_88_abi_encode_89_block3(), !740 - Finished in ??? + encode_88_abi_encode_89_block2(): + v833 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !741 + v834 = const u64 1 + v835 = const u64 1 + v836 = get_elem_ptr v833, __ptr u64, v834, v835, !742 + v837 = load v836, !743 + v838 = get_local __ptr { { ptr, u64, u64 } }, buffer_21, !745 + v839 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg66 + mem_copy_val v839, v838 + v840 = get_local __ptr { { ptr, u64, u64 } }, __ret_val15 + v841 = const u64 1, !746 + v842 = call abi_encode_20(v841, v839, v840) + v843 = get_local __ptr { { ptr, u64, u64 } }, buffer____0, !748 + mem_copy_val v843, v840 + v844 = get_local __ptr { { ptr, u64, u64 } }, buffer____0, !750 + v845 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg67 + mem_copy_val v845, v844 + v846 = get_local __ptr { { ptr, u64, u64 } }, __ret_val16 + v847 = call abi_encode_20(v837, v845, v846) + v848 = get_local __ptr { { ptr, u64, u64 } }, buffer_____, !752 + mem_copy_val v848, v846 + v849 = get_local __ptr { { ptr, u64, u64 } }, buffer_____, !754 + v850 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg0 + mem_copy_val v850, v849 + br encode_88_abi_encode_89_block5(v850), !755 -> Block: ENUM_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_88_abi_encode_89_block3(): + v851 = const u64 14757395258967588866, !710 + revert v851, !756 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.008 KB] in ??? - Running 1 test, filtered 0 tests + encode_88_abi_encode_89_block5(v852: __ptr { { ptr, u64, u64 } }): + v853 = get_local __ptr { { ptr, u64, u64 } }, buffer______, !758 + mem_copy_val v853, v852 + v854 = get_local __ptr { { ptr, u64, u64 } }, buffer______, !760 + v855 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !761 + mem_copy_val v855, v854 + v856 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !762 + v857 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg87 + mem_copy_val v857, v856 + v858 = get_local __ptr slice, __ret_val57 + v859 = call as_raw_slice_22(v857, v858) + v860 = get_local __ptr slice, _result___________________, !763 + mem_copy_val v860, v858 + v861 = get_local __ptr slice, _result___________________, !764 + v862 = get_local __ptr slice, self_13, !767 + mem_copy_val v862, v861 + v863 = get_local __ptr slice, self_13, !768 + v864 = get_local __ptr slice, slice_9, !769 + mem_copy_val v864, v863 + v865 = get_local __ptr slice, slice_9, !770 + v866 = asm(ptr: v865) -> __ptr { ptr, u64 } ptr { + } + v867 = get_local __ptr { ptr, u64 }, __aggr_memcpy_015 + mem_copy_val v867, v866 + v868 = get_local __ptr { ptr, u64 }, __anon_052, !767 + mem_copy_val v868, v867 + v869 = get_elem_ptr v868, __ptr ptr, v37, !771 + v870 = load v869, !767 + v871 = get_local __ptr slice, _result___________________, !772 + v872 = get_local __ptr slice, __tmp_arg109 + mem_copy_val v872, v871 + v873 = call len_30(v872) + retd v870 v873, !773 -tested -- const_of_contract_call + block28(): + v874 = get_local __ptr slice, _method_name, !774 + v875 = get_global __ptr string<19>, __const_global9 + v876 = cast_ptr v875 to ptr, !775 + v877 = get_local __ptr { ptr, u64 }, __anon_20, !775 + v878 = const u64 0 + v879 = get_elem_ptr v877, __ptr ptr, v878 + store v876 to v879, !775 + v880 = const u64 1 + v881 = get_elem_ptr v877, __ptr u64, v880 + v882 = const u64 19 + store v882 to v881, !775 + v883 = get_local __ptr slice, __anon_21, !775 + mem_copy_bytes v883, v877, 16 + v884 = get_local __ptr slice, __tmp_arg19 + mem_copy_val v884, v874 + v885 = get_local __ptr slice, __tmp_arg20 + mem_copy_val v885, v883 + v886 = call eq_11(v884, v885) + cbr v886, block30(), block31(), !776 - test in_enum_u64 ... ok (???, 11617 gas) + block30(): + v887 = get_local __ptr { ptr }, _buffer, !777 + v888 = get_elem_ptr v887, __ptr ptr, v19, !782 + v889 = load v888, !783 + v890 = asm(ptr: v889, val) -> u64 val, !784 { + lw val ptr i0, !58 + } + v891 = load v888, !783 + v892 = const u64 8, !783 + v893 = add v891, v892, !783 + store v893 to v888, !785 + v894 = const u64 0, !786 + v895 = cmp eq v890 v894, !789 + cbr v895, decode_90_abi_decode_91_abi_decode_92_block0(), decode_90_abi_decode_91_abi_decode_92_block1(), !790 -test result: OK. 1 passed; 0 failed; finished in ??? + decode_90_abi_decode_91_abi_decode_92_block0(): + v896 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_003, !792 + v897 = const u64 0 + v898 = get_elem_ptr v896, __ptr u64, v897, !793 + v899 = const u64 0, !791 + store v899 to v898, !794 + v900 = load v888, !797 + v901 = asm(ptr: v900, val) -> u64 val, !798 { + lw val ptr i0, !58 + } + v902 = load v888, !797 + v903 = const u64 8, !797 + v904 = add v902, v903, !797 + store v904 to v888, !799 + v905 = const u64 1 + v906 = const u64 0 + v907 = get_elem_ptr v896, __ptr u64, v905, v906, !800 + store v901 to v907, !801 + v908 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg2 + mem_copy_val v908, v896 + br decode_90_abi_decode_91_abi_decode_92_block8(v908), !802 - Finished in ??? + decode_90_abi_decode_91_abi_decode_92_block1(): + v909 = const u64 1, !803 + v910 = cmp eq v890 v909, !806 + cbr v910, decode_90_abi_decode_91_abi_decode_92_block2(), decode_90_abi_decode_91_abi_decode_92_block3(), !807 -> Block: ENUM_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + decode_90_abi_decode_91_abi_decode_92_block2(): + v911 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_113, !808 + v912 = const u64 0 + v913 = get_elem_ptr v911, __ptr u64, v912, !809 + v914 = const u64 1, !791 + store v914 to v913, !810 + v915 = load v888, !813 + v916 = asm(ptr: v915, val) -> u64 val, !814 { + lw val ptr i0, !58 + } + v917 = load v888, !813 + v918 = const u64 8, !813 + v919 = add v917, v918, !813 + store v919 to v888, !815 + v920 = const u64 1 + v921 = const u64 1 + v922 = get_elem_ptr v911, __ptr u64, v920, v921, !816 + store v916 to v922, !817 + v923 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg1 + mem_copy_val v923, v911 + br decode_90_abi_decode_91_abi_decode_92_block7(v923), !818 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.16 KB] in ??? - Running 1 test, filtered 0 tests + decode_90_abi_decode_91_abi_decode_92_block3(): + v924 = const u64 2, !819 + v925 = cmp eq v890 v924, !822 + cbr v925, decode_90_abi_decode_91_abi_decode_92_block4(), decode_90_abi_decode_91_abi_decode_92_block5(), !823 -tested -- const_of_contract_call + decode_90_abi_decode_91_abi_decode_92_block4(): + v926 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_212, !824 + v927 = const u64 0 + v928 = get_elem_ptr v926, __ptr u64, v927, !825 + v929 = const u64 2, !791 + store v929 to v928, !826 + v930 = load v888, !829 + v931 = asm(ptr: v930, val) -> u64 val, !830 { + lw val ptr i0, !58 + } + v932 = load v888, !829 + v933 = const u64 8, !829 + v934 = add v932, v933, !829 + store v934 to v888, !831 + v935 = const u64 1 + v936 = const u64 2 + v937 = get_elem_ptr v926, __ptr u64, v935, v936, !832 + store v931 to v937, !833 + v938 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg1 + mem_copy_val v938, v926 + br decode_90_abi_decode_91_abi_decode_92_block7(v938), !834 - test in_enum_u64_u64 ... ok (???, 11654 gas) + decode_90_abi_decode_91_abi_decode_92_block5(): + v939 = const u64 0, !835 + revert v939, !837 -test result: OK. 1 passed; 0 failed; finished in ??? + decode_90_abi_decode_91_abi_decode_92_block7(v940: __ptr { u64, ( u64 | u64 | u64 ) }): + v941 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg2 + mem_copy_val v941, v940 + br decode_90_abi_decode_91_abi_decode_92_block8(v941), !838 - Finished in ??? + decode_90_abi_decode_91_abi_decode_92_block8(v942: __ptr { u64, ( u64 | u64 | u64 ) }): + v943 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, __anon_014, !839 + v944 = const u64 0 + v945 = get_elem_ptr v943, __ptr { u64, ( u64 | u64 | u64 ) }, v944, !840 + mem_copy_val v945, v942 + v946 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !841 + mem_copy_val v946, v943 + v947 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !842 + v948 = const u64 0 + v949 = get_elem_ptr v947, __ptr { u64, ( u64 | u64 | u64 ) }, v948, !843 + v950 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !846 + mem_copy_val v950, v949 + v951 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !848 + v952 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !849 + mem_copy_val v952, v951 + v953 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !850 + v954 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_8, !853 + mem_copy_val v954, v953 + v955 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_8, !854 + v956 = get_local __ptr { { ptr, u64, u64 } }, __ret_val37 + v957 = call new_21(v956) + v958 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, self_28, !855 + mem_copy_val v958, v955 + v959 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !856 + mem_copy_val v959, v956 + v960 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, self_28, !858 + v961 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !860 + mem_copy_val v961, v960 + v962 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !861 + v963 = const u64 0 + v964 = get_elem_ptr v962, __ptr u64, v963, !862 + v965 = load v964, !863 + v966 = const u64 0, !857 + v967 = cmp eq v965 v966, !866 + cbr v967, encode_94_abi_encode_95_block0(), encode_94_abi_encode_95_block1(), !867 -> Block: ENUM_U64_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_94_abi_encode_95_block0(): + v968 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !868 + v969 = const u64 1 + v970 = const u64 0 + v971 = get_elem_ptr v968, __ptr u64, v969, v970, !869 + v972 = load v971, !870 + v973 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !872 + v974 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg68 + mem_copy_val v974, v973 + v975 = get_local __ptr { { ptr, u64, u64 } }, __ret_val17 + v976 = const u64 0, !873 + v977 = call abi_encode_20(v976, v974, v975) + v978 = get_local __ptr { { ptr, u64, u64 } }, buffer__6, !875 + mem_copy_val v978, v975 + v979 = get_local __ptr { { ptr, u64, u64 } }, buffer__6, !877 + v980 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg69 + mem_copy_val v980, v979 + v981 = get_local __ptr { { ptr, u64, u64 } }, __ret_val18 + v982 = call abi_encode_20(v972, v980, v981) + v983 = get_local __ptr { { ptr, u64, u64 } }, buffer___1, !879 + mem_copy_val v983, v981 + v984 = get_local __ptr { { ptr, u64, u64 } }, buffer___1, !881 + v985 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg4 + mem_copy_val v985, v984 + br encode_94_abi_encode_95_block8(v985), !882 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.344 KB] in ??? - Running 1 test, filtered 0 tests + encode_94_abi_encode_95_block1(): + v986 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !883 + v987 = const u64 0 + v988 = get_elem_ptr v986, __ptr u64, v987, !884 + v989 = load v988, !885 + v990 = const u64 1, !857 + v991 = cmp eq v989 v990, !888 + cbr v991, encode_94_abi_encode_95_block2(), encode_94_abi_encode_95_block3(), !889 -tested -- const_of_contract_call + encode_94_abi_encode_95_block2(): + v992 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !890 + v993 = const u64 1 + v994 = const u64 1 + v995 = get_elem_ptr v992, __ptr u64, v993, v994, !891 + v996 = load v995, !892 + v997 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !894 + v998 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg70 + mem_copy_val v998, v997 + v999 = get_local __ptr { { ptr, u64, u64 } }, __ret_val19 + v1000 = const u64 1, !895 + v1001 = call abi_encode_20(v1000, v998, v999) + v1002 = get_local __ptr { { ptr, u64, u64 } }, buffer____1, !897 + mem_copy_val v1002, v999 + v1003 = get_local __ptr { { ptr, u64, u64 } }, buffer____1, !899 + v1004 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg71 + mem_copy_val v1004, v1003 + v1005 = get_local __ptr { { ptr, u64, u64 } }, __ret_val20 + v1006 = call abi_encode_20(v996, v1004, v1005) + v1007 = get_local __ptr { { ptr, u64, u64 } }, buffer_____0, !901 + mem_copy_val v1007, v1005 + v1008 = get_local __ptr { { ptr, u64, u64 } }, buffer_____0, !903 + v1009 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg3 + mem_copy_val v1009, v1008 + br encode_94_abi_encode_95_block7(v1009), !904 - test in_enum_u64_u64_u64 ... ok (???, 11675 gas) + encode_94_abi_encode_95_block3(): + v1010 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !905 + v1011 = const u64 0 + v1012 = get_elem_ptr v1010, __ptr u64, v1011, !906 + v1013 = load v1012, !907 + v1014 = const u64 2, !857 + v1015 = cmp eq v1013 v1014, !910 + cbr v1015, encode_94_abi_encode_95_block4(), encode_94_abi_encode_95_block5(), !911 -test result: OK. 1 passed; 0 failed; finished in ??? + encode_94_abi_encode_95_block4(): + v1016 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !912 + v1017 = const u64 1 + v1018 = const u64 2 + v1019 = get_elem_ptr v1016, __ptr u64, v1017, v1018, !913 + v1020 = load v1019, !914 + v1021 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !916 + v1022 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg72 + mem_copy_val v1022, v1021 + v1023 = get_local __ptr { { ptr, u64, u64 } }, __ret_val21 + v1024 = const u64 2, !917 + v1025 = call abi_encode_20(v1024, v1022, v1023) + v1026 = get_local __ptr { { ptr, u64, u64 } }, buffer______0, !919 + mem_copy_val v1026, v1023 + v1027 = get_local __ptr { { ptr, u64, u64 } }, buffer______0, !921 + v1028 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg73 + mem_copy_val v1028, v1027 + v1029 = get_local __ptr { { ptr, u64, u64 } }, __ret_val22 + v1030 = call abi_encode_20(v1020, v1028, v1029) + v1031 = get_local __ptr { { ptr, u64, u64 } }, buffer_______, !923 + mem_copy_val v1031, v1029 + v1032 = get_local __ptr { { ptr, u64, u64 } }, buffer_______, !925 + v1033 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg3 + mem_copy_val v1033, v1032 + br encode_94_abi_encode_95_block7(v1033), !926 - Finished in ??? + encode_94_abi_encode_95_block5(): + v1034 = const u64 14757395258967588866, !859 + revert v1034, !927 -> Block: STR0 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_94_abi_encode_95_block7(v1035: __ptr { { ptr, u64, u64 } }): + v1036 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg4 + mem_copy_val v1036, v1035 + br encode_94_abi_encode_95_block8(v1036), !928 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.728 KB] in ??? - Running 1 test, filtered 0 tests + encode_94_abi_encode_95_block8(v1037: __ptr { { ptr, u64, u64 } }): + v1038 = get_local __ptr { { ptr, u64, u64 } }, buffer________, !930 + mem_copy_val v1038, v1037 + v1039 = get_local __ptr { { ptr, u64, u64 } }, buffer________, !932 + v1040 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !933 + mem_copy_val v1040, v1039 + v1041 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !934 + v1042 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg88 + mem_copy_val v1042, v1041 + v1043 = get_local __ptr slice, __ret_val58 + v1044 = call as_raw_slice_22(v1042, v1043) + v1045 = get_local __ptr slice, _result_____________________, !935 + mem_copy_val v1045, v1043 + v1046 = get_local __ptr slice, _result_____________________, !936 + v1047 = get_local __ptr slice, self_15, !939 + mem_copy_val v1047, v1046 + v1048 = get_local __ptr slice, self_15, !940 + v1049 = get_local __ptr slice, slice_10, !941 + mem_copy_val v1049, v1048 + v1050 = get_local __ptr slice, slice_10, !942 + v1051 = asm(ptr: v1050) -> __ptr { ptr, u64 } ptr { + } + v1052 = get_local __ptr { ptr, u64 }, __aggr_memcpy_016 + mem_copy_val v1052, v1051 + v1053 = get_local __ptr { ptr, u64 }, __anon_053, !939 + mem_copy_val v1053, v1052 + v1054 = get_elem_ptr v1053, __ptr ptr, v37, !943 + v1055 = load v1054, !939 + v1056 = get_local __ptr slice, _result_____________________, !944 + v1057 = get_local __ptr slice, __tmp_arg110 + mem_copy_val v1057, v1056 + v1058 = call len_30(v1057) + retd v1055 v1058, !945 -tested -- const_of_contract_call + block31(): + v1059 = get_local __ptr slice, _method_name, !946 + v1060 = get_global __ptr string<8>, __const_global10 + v1061 = cast_ptr v1060 to ptr, !947 + v1062 = get_local __ptr { ptr, u64 }, __anon_22, !947 + v1063 = const u64 0 + v1064 = get_elem_ptr v1062, __ptr ptr, v1063 + store v1061 to v1064, !947 + v1065 = const u64 1 + v1066 = get_elem_ptr v1062, __ptr u64, v1065 + v1067 = const u64 8 + store v1067 to v1066, !947 + v1068 = get_local __ptr slice, __anon_23, !947 + mem_copy_bytes v1068, v1062, 16 + v1069 = get_local __ptr slice, __tmp_arg21 + mem_copy_val v1069, v1059 + v1070 = get_local __ptr slice, __tmp_arg22 + mem_copy_val v1070, v1068 + v1071 = call eq_11(v1069, v1070) + cbr v1071, block33(), block34(), !948 - test isolated_cost_of_in_str_0 ... ok (???, 11250 gas) + block33(): + v1072 = get_local __ptr { ptr }, _buffer, !949 + v1073 = get_local __ptr slice, __ret_val0 + v1074 = const u64 0 + v1075 = call read_bytes_8(v1072, v1074, v1073) + v1076 = get_local __ptr slice, data0, !953 + mem_copy_val v1076, v1073 + v1077 = get_local __ptr slice, data0, !955 + v1078 = get_local __ptr slice, self_16, !958 + mem_copy_val v1078, v1077 + v1079 = get_local __ptr slice, self_16, !959 + v1080 = get_local __ptr slice, slice_11, !960 + mem_copy_val v1080, v1079 + v1081 = get_local __ptr slice, slice_11, !961 + v1082 = asm(ptr: v1081) -> __ptr { ptr, u64 } ptr { + } + v1083 = get_local __ptr { ptr, u64 }, __aggr_memcpy_017 + mem_copy_val v1083, v1082 + v1084 = get_local __ptr { ptr, u64 }, __anon_054, !958 + mem_copy_val v1084, v1083 + v1085 = get_elem_ptr v1084, __ptr ptr, v37, !962 + v1086 = load v1085, !958 + v1087 = asm(s: v1086) -> __ptr string<0> s { + } + v1088 = get_local __ptr string<0>, __aggr_memcpy_018 + mem_copy_val v1088, v1087 + v1089 = get_local __ptr { string<0> }, __anon_015, !963 + v1090 = const u64 0 + v1091 = get_elem_ptr v1089, __ptr string<0>, v1090, !964 + mem_copy_val v1091, v1088 + v1092 = get_local __ptr { string<0> }, args___________, !965 + mem_copy_val v1092, v1089 + v1093 = get_local __ptr { string<0> }, args___________, !966 + v1094 = const u64 0 + v1095 = get_elem_ptr v1093, __ptr string<0>, v1094, !967 + v1096 = get_local __ptr string<0>, v_10, !970 + mem_copy_val v1096, v1095 + v1097 = get_local __ptr string<0>, v_10, !972 + v1098 = get_local __ptr string<0>, _result______________________, !973 + mem_copy_val v1098, v1097 + v1099 = get_local __ptr string<0>, _result______________________, !974 + v1100 = get_local __ptr string<0>, item_9, !977 + mem_copy_val v1100, v1099 + v1101 = get_local __ptr string<0>, item_9, !978 + v1102 = get_local __ptr { { ptr, u64, u64 } }, __ret_val38 + v1103 = call new_21(v1102) + v1104 = get_local __ptr string<0>, self_33, !979 + mem_copy_val v1104, v1101 + v1105 = get_local __ptr { { ptr, u64, u64 } }, buffer_26, !980 + mem_copy_val v1105, v1102 + v1106 = get_local __ptr { { ptr, u64, u64 } }, buffer_26, !982 + v1107 = const u64 0 + v1108 = get_elem_ptr v1106, __ptr { ptr, u64, u64 }, v1107, !983 + v1109 = asm(buffer: v1108) -> __ptr { ptr, u64, u64 } buffer { + } + v1110 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_019 + mem_copy_val v1110, v1109 + v1111 = get_local __ptr { ptr, u64, u64 }, __anon_016, !984 + mem_copy_val v1111, v1110 + v1112 = const u64 0 + v1113 = get_elem_ptr v1111, __ptr ptr, v1112, !985 + v1114 = load v1113, !986 + v1115 = const u64 1 + v1116 = get_elem_ptr v1111, __ptr u64, v1115, !987 + v1117 = load v1116, !988 + v1118 = const u64 2 + v1119 = get_elem_ptr v1111, __ptr u64, v1118, !989 + v1120 = load v1119, !990 + v1121 = get_local __ptr string<0>, self_33, !992 + v1122 = cmp gt v1120 v1117, !993 + cbr v1122, encode_100_abi_encode_101_block1(), encode_100_abi_encode_101_block0(v1114, v1117), !994 -test result: OK. 1 passed; 0 failed; finished in ??? + encode_100_abi_encode_101_block0(v1123: ptr, v1124: u64): + v1125 = get_local __ptr string<0>, __anon_114, !995 + mem_copy_val v1125, v1121 + v1126 = add v1123, v1120, !996 + v1127 = cast_ptr v1126 to __ptr u8, !997 + mem_copy_bytes v1127, v1125, 0, !998 + v1128 = get_local __ptr { ptr, u64, u64 }, __anon_213, !999 + v1129 = const u64 0 + v1130 = get_elem_ptr v1128, __ptr ptr, v1129, !1000 + store v1123 to v1130, !1001 + v1131 = const u64 1 + v1132 = get_elem_ptr v1128, __ptr u64, v1131, !1002 + store v1124 to v1132, !1003 + v1133 = const u64 2 + v1134 = get_elem_ptr v1128, __ptr u64, v1133, !1004 + store v1120 to v1134, !1005 + v1135 = asm(buffer: v1128) -> __ptr { ptr, u64, u64 } buffer { + } + v1136 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_020 + mem_copy_val v1136, v1135 + v1137 = get_local __ptr { { ptr, u64, u64 } }, __anon_311, !1007 + v1138 = const u64 0 + v1139 = get_elem_ptr v1137, __ptr { ptr, u64, u64 }, v1138, !1008 + mem_copy_val v1139, v1136 + v1140 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !1009 + mem_copy_val v1140, v1137 + v1141 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !1010 + v1142 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg89 + mem_copy_val v1142, v1141 + v1143 = get_local __ptr slice, __ret_val59 + v1144 = call as_raw_slice_22(v1142, v1143) + v1145 = get_local __ptr slice, _result_______________________, !1011 + mem_copy_val v1145, v1143 + v1146 = get_local __ptr slice, _result_______________________, !1012 + v1147 = get_local __ptr slice, self_17, !1015 + mem_copy_val v1147, v1146 + v1148 = get_local __ptr slice, self_17, !1016 + v1149 = get_local __ptr slice, slice_12, !1017 + mem_copy_val v1149, v1148 + v1150 = get_local __ptr slice, slice_12, !1018 + v1151 = asm(ptr: v1150) -> __ptr { ptr, u64 } ptr { + } + v1152 = get_local __ptr { ptr, u64 }, __aggr_memcpy_021 + mem_copy_val v1152, v1151 + v1153 = get_local __ptr { ptr, u64 }, __anon_055, !1015 + mem_copy_val v1153, v1152 + v1154 = get_elem_ptr v1153, __ptr ptr, v37, !1019 + v1155 = load v1154, !1015 + v1156 = get_local __ptr slice, _result_______________________, !1020 + v1157 = get_local __ptr slice, __tmp_arg111 + mem_copy_val v1157, v1156 + v1158 = call len_30(v1157) + retd v1155 v1158, !1021 - Finished in ??? + encode_100_abi_encode_101_block1(): + v1159 = const u64 2 + v1160 = mul v1117, v1159, !1022 + v1161 = asm(new_cap: v1160, old_ptr: v1114, len: v1120) -> __ptr u8 hp, !1023 { + aloc new_cap + mcp hp old_ptr len + } + br encode_100_abi_encode_101_block0(v1161, v1160), !1024 -> Block: STR1 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + block34(): + v1162 = get_local __ptr slice, _method_name, !1025 + v1163 = get_global __ptr string<8>, __const_global11 + v1164 = cast_ptr v1163 to ptr, !1026 + v1165 = get_local __ptr { ptr, u64 }, __anon_24, !1026 + v1166 = const u64 0 + v1167 = get_elem_ptr v1165, __ptr ptr, v1166 + store v1164 to v1167, !1026 + v1168 = const u64 1 + v1169 = get_elem_ptr v1165, __ptr u64, v1168 + v1170 = const u64 8 + store v1170 to v1169, !1026 + v1171 = get_local __ptr slice, __anon_25, !1026 + mem_copy_bytes v1171, v1165, 16 + v1172 = get_local __ptr slice, __tmp_arg23 + mem_copy_val v1172, v1162 + v1173 = get_local __ptr slice, __tmp_arg24 + mem_copy_val v1173, v1171 + v1174 = call eq_11(v1172, v1173) + cbr v1174, block36(), block37(), !1027 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.928 KB] in ??? - Running 1 test, filtered 0 tests + block36(): + v1175 = get_local __ptr { ptr }, _buffer, !1028 + v1176 = get_local __ptr slice, __ret_val1 + v1177 = const u64 1 + v1178 = call read_bytes_8(v1175, v1177, v1176) + v1179 = get_local __ptr slice, data1, !1031 + mem_copy_val v1179, v1176 + v1180 = get_local __ptr slice, data1, !1032 + v1181 = get_local __ptr slice, self_19, !1033 + mem_copy_val v1181, v1180 + v1182 = get_local __ptr slice, self_19, !1034 + v1183 = get_local __ptr slice, slice_13, !1035 + mem_copy_val v1183, v1182 + v1184 = get_local __ptr slice, slice_13, !1036 + v1185 = asm(ptr: v1184) -> __ptr { ptr, u64 } ptr { + } + v1186 = get_local __ptr { ptr, u64 }, __aggr_memcpy_022 + mem_copy_val v1186, v1185 + v1187 = get_local __ptr { ptr, u64 }, __anon_056, !1033 + mem_copy_val v1187, v1186 + v1188 = get_elem_ptr v1187, __ptr ptr, v37, !1037 + v1189 = load v1188, !1033 + v1190 = asm(s: v1189) -> __ptr string<1> s { + } + v1191 = get_local __ptr string<1>, __aggr_memcpy_023 + mem_copy_val v1191, v1190 + v1192 = get_local __ptr { string<1> }, __anon_017, !1038 + v1193 = const u64 0 + v1194 = get_elem_ptr v1192, __ptr string<1>, v1193, !1039 + mem_copy_val v1194, v1191 + v1195 = get_local __ptr { string<1> }, args____________, !1040 + mem_copy_val v1195, v1192 + v1196 = get_local __ptr { string<1> }, args____________, !1041 + v1197 = const u64 0 + v1198 = get_elem_ptr v1196, __ptr string<1>, v1197, !1042 + v1199 = get_local __ptr string<1>, v_11, !1045 + mem_copy_val v1199, v1198 + v1200 = get_local __ptr string<1>, v_11, !1047 + v1201 = get_local __ptr string<1>, _result________________________, !1048 + mem_copy_val v1201, v1200 + v1202 = get_local __ptr string<1>, _result________________________, !1049 + v1203 = get_local __ptr string<1>, item_10, !1052 + mem_copy_val v1203, v1202 + v1204 = get_local __ptr string<1>, item_10, !1053 + v1205 = get_local __ptr { { ptr, u64, u64 } }, __ret_val39 + v1206 = call new_21(v1205) + v1207 = get_local __ptr string<1>, self_35, !1054 + mem_copy_val v1207, v1204 + v1208 = get_local __ptr { { ptr, u64, u64 } }, buffer_28, !1055 + mem_copy_val v1208, v1205 + v1209 = get_local __ptr { { ptr, u64, u64 } }, buffer_28, !1056 + v1210 = const u64 0 + v1211 = get_elem_ptr v1209, __ptr { ptr, u64, u64 }, v1210, !1057 + v1212 = asm(buffer: v1211) -> __ptr { ptr, u64, u64 } buffer { + } + v1213 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_024 + mem_copy_val v1213, v1212 + v1214 = get_local __ptr { ptr, u64, u64 }, __anon_018, !1058 + mem_copy_val v1214, v1213 + v1215 = const u64 0 + v1216 = get_elem_ptr v1214, __ptr ptr, v1215, !1059 + v1217 = load v1216, !1060 + v1218 = const u64 1 + v1219 = get_elem_ptr v1214, __ptr u64, v1218, !1061 + v1220 = load v1219, !1062 + v1221 = const u64 2 + v1222 = get_elem_ptr v1214, __ptr u64, v1221, !1063 + v1223 = load v1222, !1064 + v1224 = get_local __ptr string<1>, self_35, !1065 + v1225 = const u64 1 + v1226 = add v1223, v1225, !1066 + v1227 = cmp gt v1226 v1220, !1067 + cbr v1227, encode_106_abi_encode_107_block1(), encode_106_abi_encode_107_block0(v1217, v1220), !1068 -tested -- const_of_contract_call + encode_106_abi_encode_107_block0(v1228: ptr, v1229: u64): + v1230 = get_local __ptr string<1>, __anon_115, !1069 + mem_copy_val v1230, v1224 + v1231 = add v1228, v1223, !1070 + v1232 = cast_ptr v1231 to __ptr u8, !1071 + mem_copy_bytes v1232, v1230, 1, !1072 + v1233 = get_local __ptr { ptr, u64, u64 }, __anon_214, !1073 + v1234 = const u64 0 + v1235 = get_elem_ptr v1233, __ptr ptr, v1234, !1074 + store v1228 to v1235, !1075 + v1236 = const u64 1 + v1237 = get_elem_ptr v1233, __ptr u64, v1236, !1076 + store v1229 to v1237, !1077 + v1238 = const u64 2 + v1239 = get_elem_ptr v1233, __ptr u64, v1238, !1078 + store v1226 to v1239, !1079 + v1240 = asm(buffer: v1233) -> __ptr { ptr, u64, u64 } buffer { + } + v1241 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_025 + mem_copy_val v1241, v1240 + v1242 = get_local __ptr { { ptr, u64, u64 } }, __anon_312, !1080 + v1243 = const u64 0 + v1244 = get_elem_ptr v1242, __ptr { ptr, u64, u64 }, v1243, !1081 + mem_copy_val v1244, v1241 + v1245 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !1082 + mem_copy_val v1245, v1242 + v1246 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !1083 + v1247 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg90 + mem_copy_val v1247, v1246 + v1248 = get_local __ptr slice, __ret_val60 + v1249 = call as_raw_slice_22(v1247, v1248) + v1250 = get_local __ptr slice, _result_________________________, !1084 + mem_copy_val v1250, v1248 + v1251 = get_local __ptr slice, _result_________________________, !1085 + v1252 = get_local __ptr slice, self_20, !1088 + mem_copy_val v1252, v1251 + v1253 = get_local __ptr slice, self_20, !1089 + v1254 = get_local __ptr slice, slice_14, !1090 + mem_copy_val v1254, v1253 + v1255 = get_local __ptr slice, slice_14, !1091 + v1256 = asm(ptr: v1255) -> __ptr { ptr, u64 } ptr { + } + v1257 = get_local __ptr { ptr, u64 }, __aggr_memcpy_026 + mem_copy_val v1257, v1256 + v1258 = get_local __ptr { ptr, u64 }, __anon_057, !1088 + mem_copy_val v1258, v1257 + v1259 = get_elem_ptr v1258, __ptr ptr, v37, !1092 + v1260 = load v1259, !1088 + v1261 = get_local __ptr slice, _result_________________________, !1093 + v1262 = get_local __ptr slice, __tmp_arg112 + mem_copy_val v1262, v1261 + v1263 = call len_30(v1262) + retd v1260 v1263, !1094 - test isolated_cost_of_in_str_1 ... ok (???, 11411 gas) + encode_106_abi_encode_107_block1(): + v1264 = const u64 2 + v1265 = mul v1220, v1264, !1095 + v1266 = add v1265, v1225, !1096 + v1267 = asm(new_cap: v1266, old_ptr: v1217, len: v1223) -> __ptr u8 hp, !1097 { + aloc new_cap + mcp hp old_ptr len + } + br encode_106_abi_encode_107_block0(v1267, v1266), !1098 -test result: OK. 1 passed; 0 failed; finished in ??? + block37(): + v1268 = get_local __ptr slice, _method_name, !1099 + v1269 = get_global __ptr string<9>, __const_global12 + v1270 = cast_ptr v1269 to ptr, !1100 + v1271 = get_local __ptr { ptr, u64 }, __anon_26, !1100 + v1272 = const u64 0 + v1273 = get_elem_ptr v1271, __ptr ptr, v1272 + store v1270 to v1273, !1100 + v1274 = const u64 1 + v1275 = get_elem_ptr v1271, __ptr u64, v1274 + v1276 = const u64 9 + store v1276 to v1275, !1100 + v1277 = get_local __ptr slice, __anon_27, !1100 + mem_copy_bytes v1277, v1271, 16 + v1278 = get_local __ptr slice, __tmp_arg25 + mem_copy_val v1278, v1268 + v1279 = get_local __ptr slice, __tmp_arg26 + mem_copy_val v1279, v1277 + v1280 = call eq_11(v1278, v1279) + cbr v1280, block39(), block40(), !1101 - Finished in ??? + block39(): + v1281 = get_local __ptr { ptr }, _buffer, !1102 + v1282 = get_local __ptr slice, __ret_val2 + v1283 = const u64 16 + v1284 = call read_bytes_8(v1281, v1283, v1282) + v1285 = get_local __ptr slice, data2, !1105 + mem_copy_val v1285, v1282 + v1286 = get_local __ptr slice, data2, !1106 + v1287 = get_local __ptr slice, self_21, !1107 + mem_copy_val v1287, v1286 + v1288 = get_local __ptr slice, self_21, !1108 + v1289 = get_local __ptr slice, slice_15, !1109 + mem_copy_val v1289, v1288 + v1290 = get_local __ptr slice, slice_15, !1110 + v1291 = asm(ptr: v1290) -> __ptr { ptr, u64 } ptr { + } + v1292 = get_local __ptr { ptr, u64 }, __aggr_memcpy_027 + mem_copy_val v1292, v1291 + v1293 = get_local __ptr { ptr, u64 }, __anon_058, !1107 + mem_copy_val v1293, v1292 + v1294 = get_elem_ptr v1293, __ptr ptr, v37, !1111 + v1295 = load v1294, !1107 + v1296 = asm(s: v1295) -> __ptr string<16> s { + } + v1297 = get_local __ptr string<16>, __aggr_memcpy_028 + mem_copy_val v1297, v1296 + v1298 = get_local __ptr { string<16> }, __anon_019, !1112 + v1299 = const u64 0 + v1300 = get_elem_ptr v1298, __ptr string<16>, v1299, !1113 + mem_copy_val v1300, v1297 + v1301 = get_local __ptr { string<16> }, args_____________, !1114 + mem_copy_val v1301, v1298 + v1302 = get_local __ptr { string<16> }, args_____________, !1115 + v1303 = const u64 0 + v1304 = get_elem_ptr v1302, __ptr string<16>, v1303, !1116 + v1305 = get_local __ptr string<16>, v_12, !1119 + mem_copy_val v1305, v1304 + v1306 = get_local __ptr string<16>, v_12, !1121 + v1307 = get_local __ptr string<16>, _result__________________________, !1122 + mem_copy_val v1307, v1306 + v1308 = get_local __ptr string<16>, _result__________________________, !1123 + v1309 = get_local __ptr string<16>, item_11, !1126 + mem_copy_val v1309, v1308 + v1310 = get_local __ptr string<16>, item_11, !1127 + v1311 = get_local __ptr { { ptr, u64, u64 } }, __ret_val40 + v1312 = call new_21(v1311) + v1313 = get_local __ptr string<16>, self_37, !1128 + mem_copy_val v1313, v1310 + v1314 = get_local __ptr { { ptr, u64, u64 } }, buffer_31, !1129 + mem_copy_val v1314, v1311 + v1315 = get_local __ptr { { ptr, u64, u64 } }, buffer_31, !1130 + v1316 = const u64 0 + v1317 = get_elem_ptr v1315, __ptr { ptr, u64, u64 }, v1316, !1131 + v1318 = asm(buffer: v1317) -> __ptr { ptr, u64, u64 } buffer { + } + v1319 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_029 + mem_copy_val v1319, v1318 + v1320 = get_local __ptr { ptr, u64, u64 }, __anon_020, !1132 + mem_copy_val v1320, v1319 + v1321 = const u64 0 + v1322 = get_elem_ptr v1320, __ptr ptr, v1321, !1133 + v1323 = load v1322, !1134 + v1324 = const u64 1 + v1325 = get_elem_ptr v1320, __ptr u64, v1324, !1135 + v1326 = load v1325, !1136 + v1327 = const u64 2 + v1328 = get_elem_ptr v1320, __ptr u64, v1327, !1137 + v1329 = load v1328, !1138 + v1330 = get_local __ptr string<16>, self_37, !1139 + v1331 = const u64 16 + v1332 = add v1329, v1331, !1140 + v1333 = cmp gt v1332 v1326, !1141 + cbr v1333, encode_112_abi_encode_113_block1(), encode_112_abi_encode_113_block0(v1323, v1326), !1142 -> Block: STR16 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_112_abi_encode_113_block0(v1334: ptr, v1335: u64): + v1336 = get_local __ptr string<16>, __anon_116, !1143 + mem_copy_val v1336, v1330 + v1337 = add v1334, v1329, !1144 + v1338 = cast_ptr v1337 to __ptr u8, !1145 + mem_copy_bytes v1338, v1336, 16, !1146 + v1339 = get_local __ptr { ptr, u64, u64 }, __anon_215, !1147 + v1340 = const u64 0 + v1341 = get_elem_ptr v1339, __ptr ptr, v1340, !1148 + store v1334 to v1341, !1149 + v1342 = const u64 1 + v1343 = get_elem_ptr v1339, __ptr u64, v1342, !1150 + store v1335 to v1343, !1151 + v1344 = const u64 2 + v1345 = get_elem_ptr v1339, __ptr u64, v1344, !1152 + store v1332 to v1345, !1153 + v1346 = asm(buffer: v1339) -> __ptr { ptr, u64, u64 } buffer { + } + v1347 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_030 + mem_copy_val v1347, v1346 + v1348 = get_local __ptr { { ptr, u64, u64 } }, __anon_313, !1154 + v1349 = const u64 0 + v1350 = get_elem_ptr v1348, __ptr { ptr, u64, u64 }, v1349, !1155 + mem_copy_val v1350, v1347 + v1351 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !1156 + mem_copy_val v1351, v1348 + v1352 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !1157 + v1353 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg91 + mem_copy_val v1353, v1352 + v1354 = get_local __ptr slice, __ret_val61 + v1355 = call as_raw_slice_22(v1353, v1354) + v1356 = get_local __ptr slice, _result___________________________, !1158 + mem_copy_val v1356, v1354 + v1357 = get_local __ptr slice, _result___________________________, !1159 + v1358 = get_local __ptr slice, self_23, !1162 + mem_copy_val v1358, v1357 + v1359 = get_local __ptr slice, self_23, !1163 + v1360 = get_local __ptr slice, slice_16, !1164 + mem_copy_val v1360, v1359 + v1361 = get_local __ptr slice, slice_16, !1165 + v1362 = asm(ptr: v1361) -> __ptr { ptr, u64 } ptr { + } + v1363 = get_local __ptr { ptr, u64 }, __aggr_memcpy_031 + mem_copy_val v1363, v1362 + v1364 = get_local __ptr { ptr, u64 }, __anon_059, !1162 + mem_copy_val v1364, v1363 + v1365 = get_elem_ptr v1364, __ptr ptr, v37, !1166 + v1366 = load v1365, !1162 + v1367 = get_local __ptr slice, _result___________________________, !1167 + v1368 = get_local __ptr slice, __tmp_arg113 + mem_copy_val v1368, v1367 + v1369 = call len_30(v1368) + retd v1366 v1369, !1168 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.976 KB] in ??? - Running 1 test, filtered 0 tests + encode_112_abi_encode_113_block1(): + v1370 = const u64 2 + v1371 = mul v1326, v1370, !1169 + v1372 = add v1371, v1331, !1170 + v1373 = asm(new_cap: v1372, old_ptr: v1323, len: v1329) -> __ptr u8 hp, !1171 { + aloc new_cap + mcp hp old_ptr len + } + br encode_112_abi_encode_113_block0(v1373, v1372), !1172 -tested -- const_of_contract_call + block40(): + v1374 = get_local __ptr slice, _method_name, !1173 + v1375 = get_global __ptr string<9>, __const_global13 + v1376 = cast_ptr v1375 to ptr, !1174 + v1377 = get_local __ptr { ptr, u64 }, __anon_28, !1174 + v1378 = const u64 0 + v1379 = get_elem_ptr v1377, __ptr ptr, v1378 + store v1376 to v1379, !1174 + v1380 = const u64 1 + v1381 = get_elem_ptr v1377, __ptr u64, v1380 + v1382 = const u64 9 + store v1382 to v1381, !1174 + v1383 = get_local __ptr slice, __anon_29, !1174 + mem_copy_bytes v1383, v1377, 16 + v1384 = get_local __ptr slice, __tmp_arg27 + mem_copy_val v1384, v1374 + v1385 = get_local __ptr slice, __tmp_arg28 + mem_copy_val v1385, v1383 + v1386 = call eq_11(v1384, v1385) + cbr v1386, block42(), block43(), !1175 - test isolated_cost_of_in_str_16 ... ok (???, 11425 gas) + block42(): + v1387 = get_local __ptr { ptr }, _buffer, !1176 + v1388 = get_local __ptr slice, __ret_val3 + v1389 = const u64 32 + v1390 = call read_bytes_8(v1387, v1389, v1388) + v1391 = get_local __ptr slice, data3, !1179 + mem_copy_val v1391, v1388 + v1392 = get_local __ptr slice, data3, !1180 + v1393 = get_local __ptr slice, self_24, !1181 + mem_copy_val v1393, v1392 + v1394 = get_local __ptr slice, self_24, !1182 + v1395 = get_local __ptr slice, slice_17, !1183 + mem_copy_val v1395, v1394 + v1396 = get_local __ptr slice, slice_17, !1184 + v1397 = asm(ptr: v1396) -> __ptr { ptr, u64 } ptr { + } + v1398 = get_local __ptr { ptr, u64 }, __aggr_memcpy_032 + mem_copy_val v1398, v1397 + v1399 = get_local __ptr { ptr, u64 }, __anon_060, !1181 + mem_copy_val v1399, v1398 + v1400 = get_elem_ptr v1399, __ptr ptr, v37, !1185 + v1401 = load v1400, !1181 + v1402 = asm(s: v1401) -> __ptr string<32> s { + } + v1403 = get_local __ptr string<32>, __aggr_memcpy_033 + mem_copy_val v1403, v1402 + v1404 = get_local __ptr { string<32> }, __anon_021, !1186 + v1405 = const u64 0 + v1406 = get_elem_ptr v1404, __ptr string<32>, v1405, !1187 + mem_copy_val v1406, v1403 + v1407 = get_local __ptr { string<32> }, args______________, !1188 + mem_copy_val v1407, v1404 + v1408 = get_local __ptr { string<32> }, args______________, !1189 + v1409 = const u64 0 + v1410 = get_elem_ptr v1408, __ptr string<32>, v1409, !1190 + v1411 = get_local __ptr string<32>, v_13, !1193 + mem_copy_val v1411, v1410 + v1412 = get_local __ptr string<32>, v_13, !1195 + v1413 = get_local __ptr string<32>, _result____________________________, !1196 + mem_copy_val v1413, v1412 + v1414 = get_local __ptr string<32>, _result____________________________, !1197 + v1415 = get_local __ptr string<32>, item_12, !1200 + mem_copy_val v1415, v1414 + v1416 = get_local __ptr string<32>, item_12, !1201 + v1417 = get_local __ptr { { ptr, u64, u64 } }, __ret_val41 + v1418 = call new_21(v1417) + v1419 = get_local __ptr string<32>, self_39, !1202 + mem_copy_val v1419, v1416 + v1420 = get_local __ptr { { ptr, u64, u64 } }, buffer_33, !1203 + mem_copy_val v1420, v1417 + v1421 = get_local __ptr { { ptr, u64, u64 } }, buffer_33, !1204 + v1422 = const u64 0 + v1423 = get_elem_ptr v1421, __ptr { ptr, u64, u64 }, v1422, !1205 + v1424 = asm(buffer: v1423) -> __ptr { ptr, u64, u64 } buffer { + } + v1425 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_034 + mem_copy_val v1425, v1424 + v1426 = get_local __ptr { ptr, u64, u64 }, __anon_022, !1206 + mem_copy_val v1426, v1425 + v1427 = const u64 0 + v1428 = get_elem_ptr v1426, __ptr ptr, v1427, !1207 + v1429 = load v1428, !1208 + v1430 = const u64 1 + v1431 = get_elem_ptr v1426, __ptr u64, v1430, !1209 + v1432 = load v1431, !1210 + v1433 = const u64 2 + v1434 = get_elem_ptr v1426, __ptr u64, v1433, !1211 + v1435 = load v1434, !1212 + v1436 = get_local __ptr string<32>, self_39, !1213 + v1437 = const u64 32 + v1438 = add v1435, v1437, !1214 + v1439 = cmp gt v1438 v1432, !1215 + cbr v1439, encode_118_abi_encode_119_block1(), encode_118_abi_encode_119_block0(v1429, v1432), !1216 -test result: OK. 1 passed; 0 failed; finished in ??? + encode_118_abi_encode_119_block0(v1440: ptr, v1441: u64): + v1442 = get_local __ptr string<32>, __anon_117, !1217 + mem_copy_val v1442, v1436 + v1443 = add v1440, v1435, !1218 + v1444 = cast_ptr v1443 to __ptr u8, !1219 + mem_copy_bytes v1444, v1442, 32, !1220 + v1445 = get_local __ptr { ptr, u64, u64 }, __anon_216, !1221 + v1446 = const u64 0 + v1447 = get_elem_ptr v1445, __ptr ptr, v1446, !1222 + store v1440 to v1447, !1223 + v1448 = const u64 1 + v1449 = get_elem_ptr v1445, __ptr u64, v1448, !1224 + store v1441 to v1449, !1225 + v1450 = const u64 2 + v1451 = get_elem_ptr v1445, __ptr u64, v1450, !1226 + store v1438 to v1451, !1227 + v1452 = asm(buffer: v1445) -> __ptr { ptr, u64, u64 } buffer { + } + v1453 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_035 + mem_copy_val v1453, v1452 + v1454 = get_local __ptr { { ptr, u64, u64 } }, __anon_314, !1228 + v1455 = const u64 0 + v1456 = get_elem_ptr v1454, __ptr { ptr, u64, u64 }, v1455, !1229 + mem_copy_val v1456, v1453 + v1457 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !1230 + mem_copy_val v1457, v1454 + v1458 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !1231 + v1459 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg92 + mem_copy_val v1459, v1458 + v1460 = get_local __ptr slice, __ret_val62 + v1461 = call as_raw_slice_22(v1459, v1460) + v1462 = get_local __ptr slice, _result_____________________________, !1232 + mem_copy_val v1462, v1460 + v1463 = get_local __ptr slice, _result_____________________________, !1233 + v1464 = get_local __ptr slice, self_26, !1236 + mem_copy_val v1464, v1463 + v1465 = get_local __ptr slice, self_26, !1237 + v1466 = get_local __ptr slice, slice_18, !1238 + mem_copy_val v1466, v1465 + v1467 = get_local __ptr slice, slice_18, !1239 + v1468 = asm(ptr: v1467) -> __ptr { ptr, u64 } ptr { + } + v1469 = get_local __ptr { ptr, u64 }, __aggr_memcpy_036 + mem_copy_val v1469, v1468 + v1470 = get_local __ptr { ptr, u64 }, __anon_061, !1236 + mem_copy_val v1470, v1469 + v1471 = get_elem_ptr v1470, __ptr ptr, v37, !1240 + v1472 = load v1471, !1236 + v1473 = get_local __ptr slice, _result_____________________________, !1241 + v1474 = get_local __ptr slice, __tmp_arg114 + mem_copy_val v1474, v1473 + v1475 = call len_30(v1474) + retd v1472 v1475, !1242 - Finished in ??? + encode_118_abi_encode_119_block1(): + v1476 = const u64 2 + v1477 = mul v1432, v1476, !1243 + v1478 = add v1477, v1437, !1244 + v1479 = asm(new_cap: v1478, old_ptr: v1429, len: v1435) -> __ptr u8 hp, !1245 { + aloc new_cap + mcp hp old_ptr len + } + br encode_118_abi_encode_119_block0(v1479, v1478), !1246 -> Block: STR32 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + block43(): + v1480 = get_local __ptr slice, _method_name, !1247 + v1481 = get_global __ptr string<8>, __const_global14 + v1482 = cast_ptr v1481 to ptr, !1248 + v1483 = get_local __ptr { ptr, u64 }, __anon_30, !1248 + v1484 = const u64 0 + v1485 = get_elem_ptr v1483, __ptr ptr, v1484 + store v1482 to v1485, !1248 + v1486 = const u64 1 + v1487 = get_elem_ptr v1483, __ptr u64, v1486 + v1488 = const u64 8 + store v1488 to v1487, !1248 + v1489 = get_local __ptr slice, __anon_31, !1248 + mem_copy_bytes v1489, v1483, 16 + v1490 = get_local __ptr slice, __tmp_arg29 + mem_copy_val v1490, v1480 + v1491 = get_local __ptr slice, __tmp_arg30 + mem_copy_val v1491, v1489 + v1492 = call eq_11(v1490, v1491) + cbr v1492, block45(), block46(), !1249 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.992 KB] in ??? - Running 1 test, filtered 0 tests + block45(): + v1493 = get_local __ptr { ptr }, _buffer, !1250 + v1494 = get_local __ptr slice, __ret_val4 + v1495 = const u64 8 + v1496 = call read_bytes_8(v1493, v1495, v1494) + v1497 = get_local __ptr slice, data4, !1253 + mem_copy_val v1497, v1494 + v1498 = get_local __ptr slice, data4, !1254 + v1499 = get_local __ptr slice, self_27, !1255 + mem_copy_val v1499, v1498 + v1500 = get_local __ptr slice, self_27, !1256 + v1501 = get_local __ptr slice, slice_19, !1257 + mem_copy_val v1501, v1500 + v1502 = get_local __ptr slice, slice_19, !1258 + v1503 = asm(ptr: v1502) -> __ptr { ptr, u64 } ptr { + } + v1504 = get_local __ptr { ptr, u64 }, __aggr_memcpy_037 + mem_copy_val v1504, v1503 + v1505 = get_local __ptr { ptr, u64 }, __anon_062, !1255 + mem_copy_val v1505, v1504 + v1506 = get_elem_ptr v1505, __ptr ptr, v37, !1259 + v1507 = load v1506, !1255 + v1508 = asm(s: v1507) -> __ptr string<8> s { + } + v1509 = get_local __ptr string<8>, __aggr_memcpy_038 + mem_copy_val v1509, v1508 + v1510 = get_local __ptr { string<8> }, __anon_023, !1260 + v1511 = const u64 0 + v1512 = get_elem_ptr v1510, __ptr string<8>, v1511, !1261 + mem_copy_val v1512, v1509 + v1513 = get_local __ptr { string<8> }, args_______________, !1262 + mem_copy_val v1513, v1510 + v1514 = get_local __ptr { string<8> }, args_______________, !1263 + v1515 = const u64 0 + v1516 = get_elem_ptr v1514, __ptr string<8>, v1515, !1264 + v1517 = get_local __ptr string<8>, v_14, !1267 + mem_copy_val v1517, v1516 + v1518 = get_local __ptr string<8>, v_14, !1269 + v1519 = get_local __ptr string<8>, _result______________________________, !1270 + mem_copy_val v1519, v1518 + v1520 = get_local __ptr string<8>, _result______________________________, !1271 + v1521 = get_local __ptr string<8>, item_13, !1274 + mem_copy_val v1521, v1520 + v1522 = get_local __ptr string<8>, item_13, !1275 + v1523 = get_local __ptr { { ptr, u64, u64 } }, __ret_val42 + v1524 = call new_21(v1523) + v1525 = get_local __ptr string<8>, self_42, !1276 + mem_copy_val v1525, v1522 + v1526 = get_local __ptr { { ptr, u64, u64 } }, buffer_35, !1277 + mem_copy_val v1526, v1523 + v1527 = get_local __ptr { { ptr, u64, u64 } }, buffer_35, !1278 + v1528 = const u64 0 + v1529 = get_elem_ptr v1527, __ptr { ptr, u64, u64 }, v1528, !1279 + v1530 = asm(buffer: v1529) -> __ptr { ptr, u64, u64 } buffer { + } + v1531 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_039 + mem_copy_val v1531, v1530 + v1532 = get_local __ptr { ptr, u64, u64 }, __anon_024, !1280 + mem_copy_val v1532, v1531 + v1533 = const u64 0 + v1534 = get_elem_ptr v1532, __ptr ptr, v1533, !1281 + v1535 = load v1534, !1282 + v1536 = const u64 1 + v1537 = get_elem_ptr v1532, __ptr u64, v1536, !1283 + v1538 = load v1537, !1284 + v1539 = const u64 2 + v1540 = get_elem_ptr v1532, __ptr u64, v1539, !1285 + v1541 = load v1540, !1286 + v1542 = get_local __ptr string<8>, self_42, !1287 + v1543 = const u64 8 + v1544 = add v1541, v1543, !1288 + v1545 = cmp gt v1544 v1538, !1289 + cbr v1545, encode_124_abi_encode_125_block1(), encode_124_abi_encode_125_block0(v1535, v1538), !1290 -tested -- const_of_contract_call + encode_124_abi_encode_125_block0(v1546: ptr, v1547: u64): + v1548 = get_local __ptr string<8>, __anon_118, !1291 + mem_copy_val v1548, v1542 + v1549 = add v1546, v1541, !1292 + v1550 = cast_ptr v1549 to __ptr u8, !1293 + mem_copy_bytes v1550, v1548, 8, !1294 + v1551 = get_local __ptr { ptr, u64, u64 }, __anon_217, !1295 + v1552 = const u64 0 + v1553 = get_elem_ptr v1551, __ptr ptr, v1552, !1296 + store v1546 to v1553, !1297 + v1554 = const u64 1 + v1555 = get_elem_ptr v1551, __ptr u64, v1554, !1298 + store v1547 to v1555, !1299 + v1556 = const u64 2 + v1557 = get_elem_ptr v1551, __ptr u64, v1556, !1300 + store v1544 to v1557, !1301 + v1558 = asm(buffer: v1551) -> __ptr { ptr, u64, u64 } buffer { + } + v1559 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_040 + mem_copy_val v1559, v1558 + v1560 = get_local __ptr { { ptr, u64, u64 } }, __anon_315, !1302 + v1561 = const u64 0 + v1562 = get_elem_ptr v1560, __ptr { ptr, u64, u64 }, v1561, !1303 + mem_copy_val v1562, v1559 + v1563 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !1304 + mem_copy_val v1563, v1560 + v1564 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !1305 + v1565 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg93 + mem_copy_val v1565, v1564 + v1566 = get_local __ptr slice, __ret_val63 + v1567 = call as_raw_slice_22(v1565, v1566) + v1568 = get_local __ptr slice, _result_______________________________, !1306 + mem_copy_val v1568, v1566 + v1569 = get_local __ptr slice, _result_______________________________, !1307 + v1570 = get_local __ptr slice, self_29, !1310 + mem_copy_val v1570, v1569 + v1571 = get_local __ptr slice, self_29, !1311 + v1572 = get_local __ptr slice, slice_20, !1312 + mem_copy_val v1572, v1571 + v1573 = get_local __ptr slice, slice_20, !1313 + v1574 = asm(ptr: v1573) -> __ptr { ptr, u64 } ptr { + } + v1575 = get_local __ptr { ptr, u64 }, __aggr_memcpy_041 + mem_copy_val v1575, v1574 + v1576 = get_local __ptr { ptr, u64 }, __anon_063, !1310 + mem_copy_val v1576, v1575 + v1577 = get_elem_ptr v1576, __ptr ptr, v37, !1314 + v1578 = load v1577, !1310 + v1579 = get_local __ptr slice, _result_______________________________, !1315 + v1580 = get_local __ptr slice, __tmp_arg115 + mem_copy_val v1580, v1579 + v1581 = call len_30(v1580) + retd v1578 v1581, !1316 - test isolated_cost_of_in_str_32 ... ok (???, 11431 gas) + encode_124_abi_encode_125_block1(): + v1582 = const u64 2 + v1583 = mul v1538, v1582, !1317 + v1584 = add v1583, v1543, !1318 + v1585 = asm(new_cap: v1584, old_ptr: v1535, len: v1541) -> __ptr u8 hp, !1319 { + aloc new_cap + mcp hp old_ptr len + } + br encode_124_abi_encode_125_block0(v1585, v1584), !1320 -test result: OK. 1 passed; 0 failed; finished in ??? + block46(): + v1586 = get_local __ptr slice, _method_name, !1321 + v1587 = get_global __ptr string<13>, __const_global15 + v1588 = cast_ptr v1587 to ptr, !1322 + v1589 = get_local __ptr { ptr, u64 }, __anon_32, !1322 + v1590 = const u64 0 + v1591 = get_elem_ptr v1589, __ptr ptr, v1590 + store v1588 to v1591, !1322 + v1592 = const u64 1 + v1593 = get_elem_ptr v1589, __ptr u64, v1592 + v1594 = const u64 13 + store v1594 to v1593, !1322 + v1595 = get_local __ptr slice, __anon_33, !1322 + mem_copy_bytes v1595, v1589, 16 + v1596 = get_local __ptr slice, __tmp_arg31 + mem_copy_val v1596, v1586 + v1597 = get_local __ptr slice, __tmp_arg32 + mem_copy_val v1597, v1595 + v1598 = call eq_11(v1596, v1597) + cbr v1598, block48(), block49(), !1323 - Finished in ??? + block48(): + v1599 = get_local __ptr { ptr }, _buffer, !1324 + v1600 = get_elem_ptr v1599, __ptr ptr, v19, !1329 + v1601 = load v1600, !1330 + v1602 = asm(ptr: v1601, val) -> u64 val, !1331 { + lw val ptr i0, !58 + } + v1603 = load v1600, !1330 + v1604 = const u64 8, !1330 + v1605 = add v1603, v1604, !1330 + store v1605 to v1600, !1332 + v1606 = get_local __ptr { u64 }, __anon_004, !1334 + v1607 = const u64 0 + v1608 = get_elem_ptr v1606, __ptr u64, v1607, !1335 + store v1602 to v1608, !1336 + v1609 = get_local __ptr { { u64 } }, __anon_025, !1337 + v1610 = const u64 0 + v1611 = get_elem_ptr v1609, __ptr { u64 }, v1610, !1338 + mem_copy_val v1611, v1606 + v1612 = get_local __ptr { { u64 } }, args________________, !1339 + mem_copy_val v1612, v1609 + v1613 = get_local __ptr { { u64 } }, args________________, !1340 + v1614 = const u64 0 + v1615 = get_elem_ptr v1613, __ptr { u64 }, v1614, !1341 + v1616 = get_local __ptr { u64 }, v_15, !1344 + mem_copy_val v1616, v1615 + v1617 = get_local __ptr { u64 }, v_15, !1346 + v1618 = get_local __ptr { u64 }, _result________________________________, !1347 + mem_copy_val v1618, v1617 + v1619 = get_local __ptr { u64 }, _result________________________________, !1348 + v1620 = get_local __ptr { u64 }, __tmp_arg130 + mem_copy_val v1620, v1619 + v1621 = get_local __ptr slice, __ret_val77 + v1622 = call encode_130(v1620, v1621) + v1623 = get_local __ptr slice, _result_________________________________, !1349 + mem_copy_val v1623, v1621 + v1624 = get_local __ptr slice, _result_________________________________, !1350 + v1625 = get_local __ptr slice, self_30, !1353 + mem_copy_val v1625, v1624 + v1626 = get_local __ptr slice, self_30, !1354 + v1627 = get_local __ptr slice, slice_21, !1355 + mem_copy_val v1627, v1626 + v1628 = get_local __ptr slice, slice_21, !1356 + v1629 = asm(ptr: v1628) -> __ptr { ptr, u64 } ptr { + } + v1630 = get_local __ptr { ptr, u64 }, __aggr_memcpy_042 + mem_copy_val v1630, v1629 + v1631 = get_local __ptr { ptr, u64 }, __anon_064, !1353 + mem_copy_val v1631, v1630 + v1632 = get_elem_ptr v1631, __ptr ptr, v37, !1357 + v1633 = load v1632, !1353 + v1634 = get_local __ptr slice, _result_________________________________, !1358 + v1635 = get_local __ptr slice, __tmp_arg116 + mem_copy_val v1635, v1634 + v1636 = call len_30(v1635) + retd v1633 v1636, !1359 -> Block: STR8 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + block49(): + v1637 = get_local __ptr slice, _method_name, !1360 + v1638 = get_global __ptr string<17>, __const_global16 + v1639 = cast_ptr v1638 to ptr, !1361 + v1640 = get_local __ptr { ptr, u64 }, __anon_34, !1361 + v1641 = const u64 0 + v1642 = get_elem_ptr v1640, __ptr ptr, v1641 + store v1639 to v1642, !1361 + v1643 = const u64 1 + v1644 = get_elem_ptr v1640, __ptr u64, v1643 + v1645 = const u64 17 + store v1645 to v1644, !1361 + v1646 = get_local __ptr slice, __anon_35, !1361 + mem_copy_bytes v1646, v1640, 16 + v1647 = get_local __ptr slice, __tmp_arg33 + mem_copy_val v1647, v1637 + v1648 = get_local __ptr slice, __tmp_arg34 + mem_copy_val v1648, v1646 + v1649 = call eq_11(v1647, v1648) + cbr v1649, block51(), block52(), !1362 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.944 KB] in ??? - Running 1 test, filtered 0 tests + block51(): + v1650 = get_local __ptr { ptr }, _buffer, !1363 + v1651 = get_elem_ptr v1650, __ptr ptr, v19, !1368 + v1652 = load v1651, !1369 + v1653 = asm(ptr: v1652, val) -> u64 val, !1370 { + lw val ptr i0, !58 + } + v1654 = load v1651, !1369 + v1655 = const u64 8, !1369 + v1656 = add v1654, v1655, !1369 + store v1656 to v1651, !1371 + v1657 = load v1651, !1374 + v1658 = asm(ptr: v1657, val) -> u64 val, !1375 { + lw val ptr i0, !58 + } + v1659 = load v1651, !1374 + v1660 = const u64 8, !1374 + v1661 = add v1659, v1660, !1374 + store v1661 to v1651, !1376 + v1662 = get_local __ptr { u64, u64 }, __anon_005, !1378 + v1663 = const u64 0 + v1664 = get_elem_ptr v1662, __ptr u64, v1663, !1379 + store v1653 to v1664, !1380 + v1665 = const u64 1 + v1666 = get_elem_ptr v1662, __ptr u64, v1665, !1381 + store v1658 to v1666, !1382 + v1667 = get_local __ptr { { u64, u64 } }, __anon_026, !1383 + v1668 = const u64 0 + v1669 = get_elem_ptr v1667, __ptr { u64, u64 }, v1668, !1384 + mem_copy_val v1669, v1662 + v1670 = get_local __ptr { { u64, u64 } }, args_________________, !1385 + mem_copy_val v1670, v1667 + v1671 = get_local __ptr { { u64, u64 } }, args_________________, !1386 + v1672 = const u64 0 + v1673 = get_elem_ptr v1671, __ptr { u64, u64 }, v1672, !1387 + v1674 = get_local __ptr { u64, u64 }, v_16, !1390 + mem_copy_val v1674, v1673 + v1675 = get_local __ptr { u64, u64 }, v_16, !1392 + v1676 = get_local __ptr { u64, u64 }, _result__________________________________, !1393 + mem_copy_val v1676, v1675 + v1677 = get_local __ptr { u64, u64 }, _result__________________________________, !1394 + v1678 = get_local __ptr { u64, u64 }, __tmp_arg134 + mem_copy_val v1678, v1677 + v1679 = get_local __ptr slice, __ret_val81 + v1680 = call encode_158(v1678, v1679) + v1681 = get_local __ptr slice, _result___________________________________, !1395 + mem_copy_val v1681, v1679 + v1682 = get_local __ptr slice, _result___________________________________, !1396 + v1683 = get_local __ptr slice, self_31, !1399 + mem_copy_val v1683, v1682 + v1684 = get_local __ptr slice, self_31, !1400 + v1685 = get_local __ptr slice, slice_22, !1401 + mem_copy_val v1685, v1684 + v1686 = get_local __ptr slice, slice_22, !1402 + v1687 = asm(ptr: v1686) -> __ptr { ptr, u64 } ptr { + } + v1688 = get_local __ptr { ptr, u64 }, __aggr_memcpy_043 + mem_copy_val v1688, v1687 + v1689 = get_local __ptr { ptr, u64 }, __anon_065, !1399 + mem_copy_val v1689, v1688 + v1690 = get_elem_ptr v1689, __ptr ptr, v37, !1403 + v1691 = load v1690, !1399 + v1692 = get_local __ptr slice, _result___________________________________, !1404 + v1693 = get_local __ptr slice, __tmp_arg117 + mem_copy_val v1693, v1692 + v1694 = call len_30(v1693) + retd v1691 v1694, !1405 -tested -- const_of_contract_call + block52(): + v1695 = get_local __ptr slice, _method_name, !1406 + v1696 = get_global __ptr string<21>, __const_global17 + v1697 = cast_ptr v1696 to ptr, !1407 + v1698 = get_local __ptr { ptr, u64 }, __anon_36, !1407 + v1699 = const u64 0 + v1700 = get_elem_ptr v1698, __ptr ptr, v1699 + store v1697 to v1700, !1407 + v1701 = const u64 1 + v1702 = get_elem_ptr v1698, __ptr u64, v1701 + v1703 = const u64 21 + store v1703 to v1702, !1407 + v1704 = get_local __ptr slice, __anon_37, !1407 + mem_copy_bytes v1704, v1698, 16 + v1705 = get_local __ptr slice, __tmp_arg35 + mem_copy_val v1705, v1695 + v1706 = get_local __ptr slice, __tmp_arg36 + mem_copy_val v1706, v1704 + v1707 = call eq_11(v1705, v1706) + cbr v1707, block54(), block55(), !1408 - test isolated_cost_of_in_str_8 ... ok (???, 11421 gas) + block54(): + v1708 = get_local __ptr { ptr }, _buffer, !1409 + v1709 = get_elem_ptr v1708, __ptr ptr, v19, !1414 + v1710 = load v1709, !1415 + v1711 = asm(ptr: v1710, val) -> u64 val, !1416 { + lw val ptr i0, !58 + } + v1712 = load v1709, !1415 + v1713 = const u64 8, !1415 + v1714 = add v1712, v1713, !1415 + store v1714 to v1709, !1417 + v1715 = load v1709, !1420 + v1716 = asm(ptr: v1715, val) -> u64 val, !1421 { + lw val ptr i0, !58 + } + v1717 = load v1709, !1420 + v1718 = const u64 8, !1420 + v1719 = add v1717, v1718, !1420 + store v1719 to v1709, !1422 + v1720 = load v1709, !1425 + v1721 = asm(ptr: v1720, val) -> u64 val, !1426 { + lw val ptr i0, !58 + } + v1722 = load v1709, !1425 + v1723 = const u64 8, !1425 + v1724 = add v1722, v1723, !1425 + store v1724 to v1709, !1427 + v1725 = get_local __ptr { u64, u64, u64 }, __anon_006, !1429 + v1726 = const u64 0 + v1727 = get_elem_ptr v1725, __ptr u64, v1726, !1430 + store v1711 to v1727, !1431 + v1728 = const u64 1 + v1729 = get_elem_ptr v1725, __ptr u64, v1728, !1432 + store v1716 to v1729, !1433 + v1730 = const u64 2 + v1731 = get_elem_ptr v1725, __ptr u64, v1730, !1434 + store v1721 to v1731, !1435 + v1732 = get_local __ptr { { u64, u64, u64 } }, __anon_027, !1436 + v1733 = const u64 0 + v1734 = get_elem_ptr v1732, __ptr { u64, u64, u64 }, v1733, !1437 + mem_copy_val v1734, v1725 + v1735 = get_local __ptr { { u64, u64, u64 } }, args__________________, !1438 + mem_copy_val v1735, v1732 + v1736 = get_local __ptr { { u64, u64, u64 } }, args__________________, !1439 + v1737 = const u64 0 + v1738 = get_elem_ptr v1736, __ptr { u64, u64, u64 }, v1737, !1440 + v1739 = get_local __ptr { u64, u64, u64 }, v_17, !1443 + mem_copy_val v1739, v1738 + v1740 = get_local __ptr { u64, u64, u64 }, v_17, !1445 + v1741 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !1446 + mem_copy_val v1741, v1740 + v1742 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !1447 + v1743 = get_local __ptr { u64, u64, u64 }, __tmp_arg132 + mem_copy_val v1743, v1742 + v1744 = get_local __ptr slice, __ret_val79 + v1745 = call encode_142(v1743, v1744) + v1746 = get_local __ptr slice, _result_____________________________________, !1448 + mem_copy_val v1746, v1744 + v1747 = get_local __ptr slice, _result_____________________________________, !1449 + v1748 = get_local __ptr slice, self_32, !1452 + mem_copy_val v1748, v1747 + v1749 = get_local __ptr slice, self_32, !1453 + v1750 = get_local __ptr slice, slice_23, !1454 + mem_copy_val v1750, v1749 + v1751 = get_local __ptr slice, slice_23, !1455 + v1752 = asm(ptr: v1751) -> __ptr { ptr, u64 } ptr { + } + v1753 = get_local __ptr { ptr, u64 }, __aggr_memcpy_044 + mem_copy_val v1753, v1752 + v1754 = get_local __ptr { ptr, u64 }, __anon_066, !1452 + mem_copy_val v1754, v1753 + v1755 = get_elem_ptr v1754, __ptr ptr, v37, !1456 + v1756 = load v1755, !1452 + v1757 = get_local __ptr slice, _result_____________________________________, !1457 + v1758 = get_local __ptr slice, __tmp_arg118 + mem_copy_val v1758, v1757 + v1759 = call len_30(v1758) + retd v1756 v1759, !1458 -test result: OK. 1 passed; 0 failed; finished in ??? + block55(): + v1760 = get_local __ptr slice, _method_name, !1459 + v1761 = get_global __ptr string<10>, __const_global18 + v1762 = cast_ptr v1761 to ptr, !1460 + v1763 = get_local __ptr { ptr, u64 }, __anon_38, !1460 + v1764 = const u64 0 + v1765 = get_elem_ptr v1763, __ptr ptr, v1764 + store v1762 to v1765, !1460 + v1766 = const u64 1 + v1767 = get_elem_ptr v1763, __ptr u64, v1766 + v1768 = const u64 10 + store v1768 to v1767, !1460 + v1769 = get_local __ptr slice, __anon_39, !1460 + mem_copy_bytes v1769, v1763, 16 + v1770 = get_local __ptr slice, __tmp_arg37 + mem_copy_val v1770, v1760 + v1771 = get_local __ptr slice, __tmp_arg38 + mem_copy_val v1771, v1769 + v1772 = call eq_11(v1770, v1771) + cbr v1772, block57(), block58(), !1461 - Finished in ??? + block57(): + v1773 = get_local __ptr { () }, __anon_028, !1464 + v1774 = const u64 0 + v1775 = get_elem_ptr v1773, __ptr (), v1774, !1465 + v1776 = const unit () + store v1776 to v1775, !1466 + v1777 = get_local __ptr { () }, args___________________, !1467 + mem_copy_val v1777, v1773 + v1778 = asm() -> ptr zero, !1468 { + } + v1779 = const u64 0, !1469 + retd v1778 v1779, !1470 -> Block: STRUCT_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + block58(): + v1780 = get_local __ptr slice, _method_name, !1471 + v1781 = get_global __ptr string<10>, __const_global19 + v1782 = cast_ptr v1781 to ptr, !1472 + v1783 = get_local __ptr { ptr, u64 }, __anon_40, !1472 + v1784 = const u64 0 + v1785 = get_elem_ptr v1783, __ptr ptr, v1784 + store v1782 to v1785, !1472 + v1786 = const u64 1 + v1787 = get_elem_ptr v1783, __ptr u64, v1786 + v1788 = const u64 10 + store v1788 to v1787, !1472 + v1789 = get_local __ptr slice, __anon_41, !1472 + mem_copy_bytes v1789, v1783, 16 + v1790 = get_local __ptr slice, __tmp_arg39 + mem_copy_val v1790, v1780 + v1791 = get_local __ptr slice, __tmp_arg40 + mem_copy_val v1791, v1789 + v1792 = call eq_11(v1790, v1791) + cbr v1792, block60(), block61(), !1473 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.824 KB] in ??? - Running 1 test, filtered 0 tests + block60(): + v1793 = get_local __ptr { ptr }, _buffer, !1474 + v1794 = get_elem_ptr v1793, __ptr ptr, v19, !1477 + v1795 = load v1794, !1478 + v1796 = asm(ptr: v1795, val) -> u64 val, !1479 { + lw val ptr i0, !58 + } + v1797 = load v1794, !1478 + v1798 = const u64 8, !1478 + v1799 = add v1797, v1798, !1478 + store v1799 to v1794, !1480 + v1800 = get_local __ptr { u64 }, __anon_007, !1481 + v1801 = const u64 0 + v1802 = get_elem_ptr v1800, __ptr u64, v1801, !1482 + store v1796 to v1802, !1483 + v1803 = get_local __ptr { { u64 } }, __anon_029, !1484 + v1804 = const u64 0 + v1805 = get_elem_ptr v1803, __ptr { u64 }, v1804, !1485 + mem_copy_val v1805, v1800 + v1806 = get_local __ptr { { u64 } }, args____________________, !1486 + mem_copy_val v1806, v1803 + v1807 = get_local __ptr { { u64 } }, args____________________, !1487 + v1808 = const u64 0 + v1809 = get_elem_ptr v1807, __ptr { u64 }, v1808, !1488 + v1810 = get_local __ptr { u64 }, v_19, !1491 + mem_copy_val v1810, v1809 + v1811 = get_local __ptr { u64 }, v_19, !1492 + v1812 = get_local __ptr { u64 }, _result_______________________________________, !1493 + mem_copy_val v1812, v1811 + v1813 = get_local __ptr { u64 }, _result_______________________________________, !1494 + v1814 = get_local __ptr { u64 }, __tmp_arg131 + mem_copy_val v1814, v1813 + v1815 = get_local __ptr slice, __ret_val78 + v1816 = call encode_130(v1814, v1815) + v1817 = get_local __ptr slice, _result________________________________________, !1495 + mem_copy_val v1817, v1815 + v1818 = get_local __ptr slice, _result________________________________________, !1496 + v1819 = get_local __ptr slice, self_34, !1499 + mem_copy_val v1819, v1818 + v1820 = get_local __ptr slice, self_34, !1500 + v1821 = get_local __ptr slice, slice_24, !1501 + mem_copy_val v1821, v1820 + v1822 = get_local __ptr slice, slice_24, !1502 + v1823 = asm(ptr: v1822) -> __ptr { ptr, u64 } ptr { + } + v1824 = get_local __ptr { ptr, u64 }, __aggr_memcpy_045 + mem_copy_val v1824, v1823 + v1825 = get_local __ptr { ptr, u64 }, __anon_067, !1499 + mem_copy_val v1825, v1824 + v1826 = get_elem_ptr v1825, __ptr ptr, v37, !1503 + v1827 = load v1826, !1499 + v1828 = get_local __ptr slice, _result________________________________________, !1504 + v1829 = get_local __ptr slice, __tmp_arg119 + mem_copy_val v1829, v1828 + v1830 = call len_30(v1829) + retd v1827 v1830, !1505 -tested -- const_of_contract_call + block61(): + v1831 = get_local __ptr slice, _method_name, !1506 + v1832 = get_global __ptr string<10>, __const_global20 + v1833 = cast_ptr v1832 to ptr, !1507 + v1834 = get_local __ptr { ptr, u64 }, __anon_42, !1507 + v1835 = const u64 0 + v1836 = get_elem_ptr v1834, __ptr ptr, v1835 + store v1833 to v1836, !1507 + v1837 = const u64 1 + v1838 = get_elem_ptr v1834, __ptr u64, v1837 + v1839 = const u64 10 + store v1839 to v1838, !1507 + v1840 = get_local __ptr slice, __anon_43, !1507 + mem_copy_bytes v1840, v1834, 16 + v1841 = get_local __ptr slice, __tmp_arg41 + mem_copy_val v1841, v1831 + v1842 = get_local __ptr slice, __tmp_arg42 + mem_copy_val v1842, v1840 + v1843 = call eq_11(v1841, v1842) + cbr v1843, block63(), block64(), !1508 - test in_struct_u64 ... ok (???, 11211 gas) + block63(): + v1844 = get_local __ptr { ptr }, _buffer, !1509 + v1845 = get_elem_ptr v1844, __ptr ptr, v19, !1514 + v1846 = load v1845, !1515 + v1847 = asm(ptr: v1846, val) -> u64 val, !1516 { + lw val ptr i0, !58 + } + v1848 = load v1845, !1515 + v1849 = const u64 8, !1515 + v1850 = add v1848, v1849, !1515 + store v1850 to v1845, !1517 + v1851 = load v1845, !1520 + v1852 = asm(ptr: v1851, val) -> u64 val, !1521 { + lw val ptr i0, !58 + } + v1853 = load v1845, !1520 + v1854 = const u64 8, !1520 + v1855 = add v1853, v1854, !1520 + store v1855 to v1845, !1522 + v1856 = get_local __ptr { u64, u64 }, __anon_008, !1524 + v1857 = const u64 0 + v1858 = get_elem_ptr v1856, __ptr u64, v1857, !1525 + store v1847 to v1858, !1526 + v1859 = const u64 1 + v1860 = get_elem_ptr v1856, __ptr u64, v1859, !1527 + store v1852 to v1860, !1528 + v1861 = get_local __ptr { { u64, u64 } }, __anon_030, !1529 + v1862 = const u64 0 + v1863 = get_elem_ptr v1861, __ptr { u64, u64 }, v1862, !1530 + mem_copy_val v1863, v1856 + v1864 = get_local __ptr { { u64, u64 } }, args_____________________, !1531 + mem_copy_val v1864, v1861 + v1865 = get_local __ptr { { u64, u64 } }, args_____________________, !1532 + v1866 = const u64 0 + v1867 = get_elem_ptr v1865, __ptr { u64, u64 }, v1866, !1533 + v1868 = get_local __ptr { u64, u64 }, v_20, !1536 + mem_copy_val v1868, v1867 + v1869 = get_local __ptr { u64, u64 }, v_20, !1537 + v1870 = get_local __ptr { u64, u64 }, _result_________________________________________, !1538 + mem_copy_val v1870, v1869 + v1871 = get_local __ptr { u64, u64 }, _result_________________________________________, !1539 + v1872 = get_local __ptr { u64, u64 }, __tmp_arg135 + mem_copy_val v1872, v1871 + v1873 = get_local __ptr slice, __ret_val82 + v1874 = call encode_158(v1872, v1873) + v1875 = get_local __ptr slice, _result__________________________________________, !1540 + mem_copy_val v1875, v1873 + v1876 = get_local __ptr slice, _result__________________________________________, !1541 + v1877 = get_local __ptr slice, self_36, !1544 + mem_copy_val v1877, v1876 + v1878 = get_local __ptr slice, self_36, !1545 + v1879 = get_local __ptr slice, slice_25, !1546 + mem_copy_val v1879, v1878 + v1880 = get_local __ptr slice, slice_25, !1547 + v1881 = asm(ptr: v1880) -> __ptr { ptr, u64 } ptr { + } + v1882 = get_local __ptr { ptr, u64 }, __aggr_memcpy_046 + mem_copy_val v1882, v1881 + v1883 = get_local __ptr { ptr, u64 }, __anon_068, !1544 + mem_copy_val v1883, v1882 + v1884 = get_elem_ptr v1883, __ptr ptr, v37, !1548 + v1885 = load v1884, !1544 + v1886 = get_local __ptr slice, _result__________________________________________, !1549 + v1887 = get_local __ptr slice, __tmp_arg120 + mem_copy_val v1887, v1886 + v1888 = call len_30(v1887) + retd v1885 v1888, !1550 -test result: OK. 1 passed; 0 failed; finished in ??? + block64(): + v1889 = get_local __ptr slice, _method_name, !1551 + v1890 = get_global __ptr string<10>, __const_global21 + v1891 = cast_ptr v1890 to ptr, !1552 + v1892 = get_local __ptr { ptr, u64 }, __anon_44, !1552 + v1893 = const u64 0 + v1894 = get_elem_ptr v1892, __ptr ptr, v1893 + store v1891 to v1894, !1552 + v1895 = const u64 1 + v1896 = get_elem_ptr v1892, __ptr u64, v1895 + v1897 = const u64 10 + store v1897 to v1896, !1552 + v1898 = get_local __ptr slice, __anon_45, !1552 + mem_copy_bytes v1898, v1892, 16 + v1899 = get_local __ptr slice, __tmp_arg43 + mem_copy_val v1899, v1889 + v1900 = get_local __ptr slice, __tmp_arg44 + mem_copy_val v1900, v1898 + v1901 = call eq_11(v1899, v1900) + cbr v1901, block66(), block67(), !1553 - Finished in ??? + block66(): + v1902 = get_local __ptr { ptr }, _buffer, !1554 + v1903 = get_elem_ptr v1902, __ptr ptr, v19, !1559 + v1904 = load v1903, !1560 + v1905 = asm(ptr: v1904, val) -> u64 val, !1561 { + lw val ptr i0, !58 + } + v1906 = load v1903, !1560 + v1907 = const u64 8, !1560 + v1908 = add v1906, v1907, !1560 + store v1908 to v1903, !1562 + v1909 = load v1903, !1565 + v1910 = asm(ptr: v1909, val) -> u64 val, !1566 { + lw val ptr i0, !58 + } + v1911 = load v1903, !1565 + v1912 = const u64 8, !1565 + v1913 = add v1911, v1912, !1565 + store v1913 to v1903, !1567 + v1914 = load v1903, !1570 + v1915 = asm(ptr: v1914, val) -> u64 val, !1571 { + lw val ptr i0, !58 + } + v1916 = load v1903, !1570 + v1917 = const u64 8, !1570 + v1918 = add v1916, v1917, !1570 + store v1918 to v1903, !1572 + v1919 = get_local __ptr { u64, u64, u64 }, __anon_009, !1574 + v1920 = const u64 0 + v1921 = get_elem_ptr v1919, __ptr u64, v1920, !1575 + store v1905 to v1921, !1576 + v1922 = const u64 1 + v1923 = get_elem_ptr v1919, __ptr u64, v1922, !1577 + store v1910 to v1923, !1578 + v1924 = const u64 2 + v1925 = get_elem_ptr v1919, __ptr u64, v1924, !1579 + store v1915 to v1925, !1580 + v1926 = get_local __ptr { { u64, u64, u64 } }, __anon_031, !1581 + v1927 = const u64 0 + v1928 = get_elem_ptr v1926, __ptr { u64, u64, u64 }, v1927, !1582 + mem_copy_val v1928, v1919 + v1929 = get_local __ptr { { u64, u64, u64 } }, args______________________, !1583 + mem_copy_val v1929, v1926 + v1930 = get_local __ptr { { u64, u64, u64 } }, args______________________, !1584 + v1931 = const u64 0 + v1932 = get_elem_ptr v1930, __ptr { u64, u64, u64 }, v1931, !1585 + v1933 = get_local __ptr { u64, u64, u64 }, v_21, !1588 + mem_copy_val v1933, v1932 + v1934 = get_local __ptr { u64, u64, u64 }, v_21, !1589 + v1935 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !1590 + mem_copy_val v1935, v1934 + v1936 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !1591 + v1937 = get_local __ptr { u64, u64, u64 }, __tmp_arg133 + mem_copy_val v1937, v1936 + v1938 = get_local __ptr slice, __ret_val80 + v1939 = call encode_142(v1937, v1938) + v1940 = get_local __ptr slice, _result____________________________________________, !1592 + mem_copy_val v1940, v1938 + v1941 = get_local __ptr slice, _result____________________________________________, !1593 + v1942 = get_local __ptr slice, self_38, !1596 + mem_copy_val v1942, v1941 + v1943 = get_local __ptr slice, self_38, !1597 + v1944 = get_local __ptr slice, slice_26, !1598 + mem_copy_val v1944, v1943 + v1945 = get_local __ptr slice, slice_26, !1599 + v1946 = asm(ptr: v1945) -> __ptr { ptr, u64 } ptr { + } + v1947 = get_local __ptr { ptr, u64 }, __aggr_memcpy_047 + mem_copy_val v1947, v1946 + v1948 = get_local __ptr { ptr, u64 }, __anon_069, !1596 + mem_copy_val v1948, v1947 + v1949 = get_elem_ptr v1948, __ptr ptr, v37, !1600 + v1950 = load v1949, !1596 + v1951 = get_local __ptr slice, _result____________________________________________, !1601 + v1952 = get_local __ptr slice, __tmp_arg121 + mem_copy_val v1952, v1951 + v1953 = call len_30(v1952) + retd v1950 v1953, !1602 -> Block: STRUCT_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + block67(): + v1954 = get_local __ptr slice, _method_name, !1603 + v1955 = get_global __ptr string<10>, __const_global22 + v1956 = cast_ptr v1955 to ptr, !1604 + v1957 = get_local __ptr { ptr, u64 }, __anon_46, !1604 + v1958 = const u64 0 + v1959 = get_elem_ptr v1957, __ptr ptr, v1958 + store v1956 to v1959, !1604 + v1960 = const u64 1 + v1961 = get_elem_ptr v1957, __ptr u64, v1960 + v1962 = const u64 10 + store v1962 to v1961, !1604 + v1963 = get_local __ptr slice, __anon_47, !1604 + mem_copy_bytes v1963, v1957, 16 + v1964 = get_local __ptr slice, __tmp_arg45 + mem_copy_val v1964, v1954 + v1965 = get_local __ptr slice, __tmp_arg46 + mem_copy_val v1965, v1963 + v1966 = call eq_11(v1964, v1965) + cbr v1966, block69(), block70(), !1605 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.96 KB] in ??? - Running 1 test, filtered 0 tests + block69(): + v1967 = get_local __ptr { ptr }, _buffer, !1606 + v1968 = get_elem_ptr v1967, __ptr ptr, v19, !1611 + v1969 = load v1968, !1612 + v1970 = asm(ptr: v1969, val) -> u64 val, !1613 { + lw val ptr i0, !58 + } + v1971 = load v1968, !1612 + v1972 = const u64 8, !1612 + v1973 = add v1971, v1972, !1612 + store v1973 to v1968, !1614 + v1974 = load v1968, !1617 + v1975 = asm(ptr: v1974, val) -> u64 val, !1618 { + lw val ptr i0, !58 + } + v1976 = load v1968, !1617 + v1977 = const u64 8, !1617 + v1978 = add v1976, v1977, !1617 + store v1978 to v1968, !1619 + v1979 = load v1968, !1622 + v1980 = asm(ptr: v1979, val) -> u64 val, !1623 { + lw val ptr i0, !58 + } + v1981 = load v1968, !1622 + v1982 = const u64 8, !1622 + v1983 = add v1981, v1982, !1622 + store v1983 to v1968, !1624 + v1984 = load v1968, !1627 + v1985 = asm(ptr: v1984, val) -> u64 val, !1628 { + lw val ptr i0, !58 + } + v1986 = load v1968, !1627 + v1987 = const u64 8, !1627 + v1988 = add v1986, v1987, !1627 + store v1988 to v1968, !1629 + v1989 = get_local __ptr { u64, u64, u64, u64 }, __anon_0010, !1631 + v1990 = const u64 0 + v1991 = get_elem_ptr v1989, __ptr u64, v1990, !1632 + store v1970 to v1991, !1633 + v1992 = const u64 1 + v1993 = get_elem_ptr v1989, __ptr u64, v1992, !1634 + store v1975 to v1993, !1635 + v1994 = const u64 2 + v1995 = get_elem_ptr v1989, __ptr u64, v1994, !1636 + store v1980 to v1995, !1637 + v1996 = const u64 3 + v1997 = get_elem_ptr v1989, __ptr u64, v1996, !1638 + store v1985 to v1997, !1639 + v1998 = get_local __ptr { { u64, u64, u64, u64 } }, __anon_032, !1640 + v1999 = const u64 0 + v2000 = get_elem_ptr v1998, __ptr { u64, u64, u64, u64 }, v1999, !1641 + mem_copy_val v2000, v1989 + v2001 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !1642 + mem_copy_val v2001, v1998 + v2002 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !1643 + v2003 = const u64 0 + v2004 = get_elem_ptr v2002, __ptr { u64, u64, u64, u64 }, v2003, !1644 + v2005 = get_local __ptr { u64, u64, u64, u64 }, v_22, !1647 + mem_copy_val v2005, v2004 + v2006 = get_local __ptr { u64, u64, u64, u64 }, v_22, !1649 + v2007 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !1650 + mem_copy_val v2007, v2006 + v2008 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !1651 + v2009 = get_local __ptr { u64, u64, u64, u64 }, item_14, !1654 + mem_copy_val v2009, v2008 + v2010 = get_local __ptr { u64, u64, u64, u64 }, item_14, !1655 + v2011 = get_local __ptr { { ptr, u64, u64 } }, __ret_val43 + v2012 = call new_21(v2011) + v2013 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1656 + mem_copy_val v2013, v2010 + v2014 = get_local __ptr { { ptr, u64, u64 } }, buffer_44, !1657 + mem_copy_val v2014, v2011 + v2015 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1659 + v2016 = const u64 0 + v2017 = get_elem_ptr v2015, __ptr u64, v2016, !1661 + v2018 = load v2017, !1662 + v2019 = get_local __ptr { { ptr, u64, u64 } }, buffer_44, !1664 + v2020 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg74 + mem_copy_val v2020, v2019 + v2021 = get_local __ptr { { ptr, u64, u64 } }, __ret_val23 + v2022 = call abi_encode_20(v2018, v2020, v2021) + v2023 = get_local __ptr { { ptr, u64, u64 } }, buffer__7, !1666 + mem_copy_val v2023, v2021 + v2024 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1668 + v2025 = const u64 1 + v2026 = get_elem_ptr v2024, __ptr u64, v2025, !1670 + v2027 = load v2026, !1671 + v2028 = get_local __ptr { { ptr, u64, u64 } }, buffer__7, !1673 + v2029 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg75 + mem_copy_val v2029, v2028 + v2030 = get_local __ptr { { ptr, u64, u64 } }, __ret_val24 + v2031 = call abi_encode_20(v2027, v2029, v2030) + v2032 = get_local __ptr { { ptr, u64, u64 } }, buffer___2, !1675 + mem_copy_val v2032, v2030 + v2033 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1677 + v2034 = const u64 2 + v2035 = get_elem_ptr v2033, __ptr u64, v2034, !1679 + v2036 = load v2035, !1680 + v2037 = get_local __ptr { { ptr, u64, u64 } }, buffer___2, !1682 + v2038 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg76 + mem_copy_val v2038, v2037 + v2039 = get_local __ptr { { ptr, u64, u64 } }, __ret_val25 + v2040 = call abi_encode_20(v2036, v2038, v2039) + v2041 = get_local __ptr { { ptr, u64, u64 } }, buffer____2, !1684 + mem_copy_val v2041, v2039 + v2042 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1686 + v2043 = const u64 3 + v2044 = get_elem_ptr v2042, __ptr u64, v2043, !1688 + v2045 = load v2044, !1689 + v2046 = get_local __ptr { { ptr, u64, u64 } }, buffer____2, !1691 + v2047 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg77 + mem_copy_val v2047, v2046 + v2048 = get_local __ptr { { ptr, u64, u64 } }, __ret_val26 + v2049 = call abi_encode_20(v2045, v2047, v2048) + v2050 = get_local __ptr { { ptr, u64, u64 } }, buffer_____1, !1693 + mem_copy_val v2050, v2048 + v2051 = get_local __ptr { { ptr, u64, u64 } }, buffer_____1, !1695 + v2052 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !1696 + mem_copy_val v2052, v2051 + v2053 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !1697 + v2054 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg94 + mem_copy_val v2054, v2053 + v2055 = get_local __ptr slice, __ret_val64 + v2056 = call as_raw_slice_22(v2054, v2055) + v2057 = get_local __ptr slice, _result______________________________________________, !1698 + mem_copy_val v2057, v2055 + v2058 = get_local __ptr slice, _result______________________________________________, !1699 + v2059 = get_local __ptr slice, self_40, !1702 + mem_copy_val v2059, v2058 + v2060 = get_local __ptr slice, self_40, !1703 + v2061 = get_local __ptr slice, slice_27, !1704 + mem_copy_val v2061, v2060 + v2062 = get_local __ptr slice, slice_27, !1705 + v2063 = asm(ptr: v2062) -> __ptr { ptr, u64 } ptr { + } + v2064 = get_local __ptr { ptr, u64 }, __aggr_memcpy_048 + mem_copy_val v2064, v2063 + v2065 = get_local __ptr { ptr, u64 }, __anon_070, !1702 + mem_copy_val v2065, v2064 + v2066 = get_elem_ptr v2065, __ptr ptr, v37, !1706 + v2067 = load v2066, !1702 + v2068 = get_local __ptr slice, _result______________________________________________, !1707 + v2069 = get_local __ptr slice, __tmp_arg122 + mem_copy_val v2069, v2068 + v2070 = call len_30(v2069) + retd v2067 v2070, !1708 -tested -- const_of_contract_call + block70(): + v2071 = get_local __ptr slice, _method_name, !1709 + v2072 = get_global __ptr string<6>, __const_global23 + v2073 = cast_ptr v2072 to ptr, !1710 + v2074 = get_local __ptr { ptr, u64 }, __anon_48, !1710 + v2075 = const u64 0 + v2076 = get_elem_ptr v2074, __ptr ptr, v2075 + store v2073 to v2076, !1710 + v2077 = const u64 1 + v2078 = get_elem_ptr v2074, __ptr u64, v2077 + v2079 = const u64 6 + store v2079 to v2078, !1710 + v2080 = get_local __ptr slice, __anon_49, !1710 + mem_copy_bytes v2080, v2074, 16 + v2081 = get_local __ptr slice, __tmp_arg47 + mem_copy_val v2081, v2071 + v2082 = get_local __ptr slice, __tmp_arg48 + mem_copy_val v2082, v2080 + v2083 = call eq_11(v2081, v2082) + cbr v2083, block72(), block73(), !1711 - test in_struct_u64_u64 ... ok (???, 11561 gas) + block72(): + v2084 = get_local __ptr { ptr }, _buffer, !1712 + v2085 = call read_72(v2084), !1717 + v2086 = asm(input: v2085) -> u64 input, !1721 { + } + v2087 = call read_72(v2084), !1724 + v2088 = asm(input: v2087) -> u64 input, !1727 { + } + v2089 = const u64 8, !1728 + v2090 = lsh v2086, v2089, !1731 + v2091 = const u64 65535, !1733 + v2092 = and v2090, v2091, !1734 + v2093 = or v2092, v2088, !1737 + v2094 = get_local __ptr { u64 }, __anon_033, !1738 + v2095 = const u64 0 + v2096 = get_elem_ptr v2094, __ptr u64, v2095, !1739 + store v2093 to v2096, !1740 + v2097 = get_local __ptr { u64 }, args________________________, !1741 + mem_copy_val v2097, v2094 + v2098 = get_local __ptr { u64 }, args________________________, !1742 + v2099 = const u64 0 + v2100 = get_elem_ptr v2098, __ptr u64, v2099, !1743 + v2101 = get_local __ptr { { ptr, u64, u64 } }, __ret_val44 + v2102 = call new_21(v2101) + v2103 = get_local __ptr { { ptr, u64, u64 } }, buffer_46, !1746 + mem_copy_val v2103, v2101 + v2104 = get_local __ptr { { ptr, u64, u64 } }, buffer_46, !1748 + v2105 = const u64 0 + v2106 = get_elem_ptr v2104, __ptr { ptr, u64, u64 }, v2105, !1749 + v2107 = asm(buffer: v2106) -> __ptr { ptr, u64, u64 } buffer { + } + v2108 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_049 + mem_copy_val v2108, v2107 + v2109 = get_local __ptr { ptr, u64, u64 }, __anon_034, !1750 + mem_copy_val v2109, v2108 + v2110 = const u64 0 + v2111 = get_elem_ptr v2109, __ptr ptr, v2110, !1751 + v2112 = load v2111, !1752 + v2113 = const u64 1 + v2114 = get_elem_ptr v2109, __ptr u64, v2113, !1753 + v2115 = load v2114, !1754 + v2116 = const u64 2 + v2117 = get_elem_ptr v2109, __ptr u64, v2116, !1755 + v2118 = load v2117, !1756 + v2119 = const u64 2 + v2120 = add v2118, v2119, !1757 + v2121 = cmp gt v2120 v2115, !1758 + cbr v2121, encode_180_abi_encode_181_block1(), encode_180_abi_encode_181_block0(v2112, v2115), !1759 -test result: OK. 1 passed; 0 failed; finished in ??? + encode_180_abi_encode_181_block0(v2122: ptr, v2123: u64): + v2124 = get_local __ptr u64, __anon_119, !1760 + mem_copy_val v2124, v2100 + v2125 = const u64 6 + v2126 = add v2124, v2125, !1761 + v2127 = cast_ptr v2126 to __ptr u8, !1762 + v2128 = add v2122, v2118, !1763 + v2129 = cast_ptr v2128 to __ptr u8, !1764 + mem_copy_bytes v2129, v2127, 2, !1765 + v2130 = get_local __ptr { ptr, u64, u64 }, __anon_218, !1766 + v2131 = const u64 0 + v2132 = get_elem_ptr v2130, __ptr ptr, v2131, !1767 + store v2122 to v2132, !1768 + v2133 = const u64 1 + v2134 = get_elem_ptr v2130, __ptr u64, v2133, !1769 + store v2123 to v2134, !1770 + v2135 = const u64 2 + v2136 = get_elem_ptr v2130, __ptr u64, v2135, !1771 + store v2120 to v2136, !1772 + v2137 = asm(buffer: v2130) -> __ptr { ptr, u64, u64 } buffer { + } + v2138 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_050 + mem_copy_val v2138, v2137 + v2139 = get_local __ptr { { ptr, u64, u64 } }, __anon_316, !1774 + v2140 = const u64 0 + v2141 = get_elem_ptr v2139, __ptr { ptr, u64, u64 }, v2140, !1775 + mem_copy_val v2141, v2138 + v2142 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !1776 + mem_copy_val v2142, v2139 + v2143 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !1777 + v2144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg95 + mem_copy_val v2144, v2143 + v2145 = get_local __ptr slice, __ret_val65 + v2146 = call as_raw_slice_22(v2144, v2145) + v2147 = get_local __ptr slice, _result________________________________________________, !1778 + mem_copy_val v2147, v2145 + v2148 = get_local __ptr slice, _result________________________________________________, !1779 + v2149 = get_local __ptr slice, self_41, !1782 + mem_copy_val v2149, v2148 + v2150 = get_local __ptr slice, self_41, !1783 + v2151 = get_local __ptr slice, slice_28, !1784 + mem_copy_val v2151, v2150 + v2152 = get_local __ptr slice, slice_28, !1785 + v2153 = asm(ptr: v2152) -> __ptr { ptr, u64 } ptr { + } + v2154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_051 + mem_copy_val v2154, v2153 + v2155 = get_local __ptr { ptr, u64 }, __anon_071, !1782 + mem_copy_val v2155, v2154 + v2156 = get_elem_ptr v2155, __ptr ptr, v37, !1786 + v2157 = load v2156, !1782 + v2158 = get_local __ptr slice, _result________________________________________________, !1787 + v2159 = get_local __ptr slice, __tmp_arg123 + mem_copy_val v2159, v2158 + v2160 = call len_30(v2159) + retd v2157 v2160, !1788 - Finished in ??? + encode_180_abi_encode_181_block1(): + v2161 = const u64 2 + v2162 = mul v2115, v2161, !1789 + v2163 = add v2162, v2119, !1790 + v2164 = asm(new_cap: v2163, old_ptr: v2112, len: v2118) -> __ptr u8 hp, !1791 { + aloc new_cap + mcp hp old_ptr len + } + br encode_180_abi_encode_181_block0(v2164, v2163), !1792 -> Block: STRUCT_U64_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + block73(): + v2165 = get_local __ptr slice, _method_name, !1793 + v2166 = get_global __ptr string<7>, __const_global24 + v2167 = cast_ptr v2166 to ptr, !1794 + v2168 = get_local __ptr { ptr, u64 }, __anon_50, !1794 + v2169 = const u64 0 + v2170 = get_elem_ptr v2168, __ptr ptr, v2169 + store v2167 to v2170, !1794 + v2171 = const u64 1 + v2172 = get_elem_ptr v2168, __ptr u64, v2171 + v2173 = const u64 7 + store v2173 to v2172, !1794 + v2174 = get_local __ptr slice, __anon_51, !1794 + mem_copy_bytes v2174, v2168, 16 + v2175 = get_local __ptr slice, __tmp_arg49 + mem_copy_val v2175, v2165 + v2176 = get_local __ptr slice, __tmp_arg50 + mem_copy_val v2176, v2174 + v2177 = call eq_11(v2175, v2176) + cbr v2177, block75(), block76(), !1795 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.032 KB] in ??? - Running 1 test, filtered 0 tests + block75(): + v2178 = get_local __ptr { ptr }, _buffer, !1796 + v2179 = const u64 0 + v2180 = get_elem_ptr v2178, __ptr ptr, v2179, !1801 + v2181 = load v2180, !1802 + v2182 = asm(ptr: v2181) -> __ptr u256 ptr { + } + v2183 = get_local __ptr u256, __aggr_memcpy_052 + mem_copy_val v2183, v2182 + v2184 = get_local __ptr u256, v0, !1803 + mem_copy_val v2184, v2183 + v2185 = load v2180, !1804 + v2186 = const u64 32, !1805 + v2187 = add v2185, v2186, !1806 + store v2187 to v2180, !1807 + v2188 = get_local __ptr u256, v0, !1808 + v2189 = get_local __ptr { u256 }, __anon_035, !1809 + v2190 = const u64 0 + v2191 = get_elem_ptr v2189, __ptr u256, v2190, !1810 + mem_copy_val v2191, v2188 + v2192 = get_local __ptr { u256 }, args_________________________, !1811 + mem_copy_val v2192, v2189 + v2193 = get_local __ptr { u256 }, args_________________________, !1812 + v2194 = const u64 0 + v2195 = get_elem_ptr v2193, __ptr u256, v2194, !1813 + v2196 = get_local __ptr u256, v_24, !1816 + mem_copy_val v2196, v2195 + v2197 = get_local __ptr u256, v_24, !1818 + v2198 = get_local __ptr u256, _result_________________________________________________, !1819 + mem_copy_val v2198, v2197 + v2199 = get_local __ptr u256, _result_________________________________________________, !1820 + v2200 = get_local __ptr u256, item_16, !1823 + mem_copy_val v2200, v2199 + v2201 = get_local __ptr u256, item_16, !1824 + v2202 = get_local __ptr { { ptr, u64, u64 } }, __ret_val45 + v2203 = call new_21(v2202) + v2204 = get_local __ptr u256, self_56, !1825 + mem_copy_val v2204, v2201 + v2205 = get_local __ptr { { ptr, u64, u64 } }, buffer_48, !1826 + mem_copy_val v2205, v2202 + v2206 = get_local __ptr { { ptr, u64, u64 } }, buffer_48, !1828 + v2207 = const u64 0 + v2208 = get_elem_ptr v2206, __ptr { ptr, u64, u64 }, v2207, !1829 + v2209 = asm(buffer: v2208) -> __ptr { ptr, u64, u64 } buffer { + } + v2210 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_053 + mem_copy_val v2210, v2209 + v2211 = get_local __ptr { ptr, u64, u64 }, __anon_036, !1830 + mem_copy_val v2211, v2210 + v2212 = const u64 0 + v2213 = get_elem_ptr v2211, __ptr ptr, v2212, !1831 + v2214 = load v2213, !1832 + v2215 = const u64 1 + v2216 = get_elem_ptr v2211, __ptr u64, v2215, !1833 + v2217 = load v2216, !1834 + v2218 = const u64 2 + v2219 = get_elem_ptr v2211, __ptr u64, v2218, !1835 + v2220 = load v2219, !1836 + v2221 = get_local __ptr u256, self_56, !1838 + v2222 = const u64 32 + v2223 = add v2220, v2222, !1839 + v2224 = cmp gt v2223 v2217, !1840 + cbr v2224, encode_187_abi_encode_188_block1(), encode_187_abi_encode_188_block0(v2214, v2217), !1841 -tested -- const_of_contract_call + encode_187_abi_encode_188_block0(v2225: ptr, v2226: u64): + v2227 = get_local __ptr u256, __anon_120, !1842 + mem_copy_val v2227, v2221 + v2228 = add v2225, v2220, !1843 + v2229 = cast_ptr v2228 to __ptr u8, !1844 + mem_copy_bytes v2229, v2227, 32, !1845 + v2230 = get_local __ptr { ptr, u64, u64 }, __anon_219, !1846 + v2231 = const u64 0 + v2232 = get_elem_ptr v2230, __ptr ptr, v2231, !1847 + store v2225 to v2232, !1848 + v2233 = const u64 1 + v2234 = get_elem_ptr v2230, __ptr u64, v2233, !1849 + store v2226 to v2234, !1850 + v2235 = const u64 2 + v2236 = get_elem_ptr v2230, __ptr u64, v2235, !1851 + store v2223 to v2236, !1852 + v2237 = asm(buffer: v2230) -> __ptr { ptr, u64, u64 } buffer { + } + v2238 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_054 + mem_copy_val v2238, v2237 + v2239 = get_local __ptr { { ptr, u64, u64 } }, __anon_317, !1854 + v2240 = const u64 0 + v2241 = get_elem_ptr v2239, __ptr { ptr, u64, u64 }, v2240, !1855 + mem_copy_val v2241, v2238 + v2242 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !1856 + mem_copy_val v2242, v2239 + v2243 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !1857 + v2244 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg96 + mem_copy_val v2244, v2243 + v2245 = get_local __ptr slice, __ret_val66 + v2246 = call as_raw_slice_22(v2244, v2245) + v2247 = get_local __ptr slice, _result__________________________________________________, !1858 + mem_copy_val v2247, v2245 + v2248 = get_local __ptr slice, _result__________________________________________________, !1859 + v2249 = get_local __ptr slice, self_43, !1862 + mem_copy_val v2249, v2248 + v2250 = get_local __ptr slice, self_43, !1863 + v2251 = get_local __ptr slice, slice_29, !1864 + mem_copy_val v2251, v2250 + v2252 = get_local __ptr slice, slice_29, !1865 + v2253 = asm(ptr: v2252) -> __ptr { ptr, u64 } ptr { + } + v2254 = get_local __ptr { ptr, u64 }, __aggr_memcpy_055 + mem_copy_val v2254, v2253 + v2255 = get_local __ptr { ptr, u64 }, __anon_072, !1862 + mem_copy_val v2255, v2254 + v2256 = get_elem_ptr v2255, __ptr ptr, v37, !1866 + v2257 = load v2256, !1862 + v2258 = get_local __ptr slice, _result__________________________________________________, !1867 + v2259 = get_local __ptr slice, __tmp_arg124 + mem_copy_val v2259, v2258 + v2260 = call len_30(v2259) + retd v2257 v2260, !1868 - test in_struct_u64_u64_u64 ... ok (???, 11829 gas) + encode_187_abi_encode_188_block1(): + v2261 = const u64 2 + v2262 = mul v2217, v2261, !1869 + v2263 = add v2262, v2222, !1870 + v2264 = asm(new_cap: v2263, old_ptr: v2214, len: v2220) -> __ptr u8 hp, !1871 { + aloc new_cap + mcp hp old_ptr len + } + br encode_187_abi_encode_188_block0(v2264, v2263), !1872 -test result: OK. 1 passed; 0 failed; finished in ??? + block76(): + v2265 = get_local __ptr slice, _method_name, !1873 + v2266 = get_global __ptr string<6>, __const_global25 + v2267 = cast_ptr v2266 to ptr, !1874 + v2268 = get_local __ptr { ptr, u64 }, __anon_52, !1874 + v2269 = const u64 0 + v2270 = get_elem_ptr v2268, __ptr ptr, v2269 + store v2267 to v2270, !1874 + v2271 = const u64 1 + v2272 = get_elem_ptr v2268, __ptr u64, v2271 + v2273 = const u64 6 + store v2273 to v2272, !1874 + v2274 = get_local __ptr slice, __anon_53, !1874 + mem_copy_bytes v2274, v2268, 16 + v2275 = get_local __ptr slice, __tmp_arg51 + mem_copy_val v2275, v2265 + v2276 = get_local __ptr slice, __tmp_arg52 + mem_copy_val v2276, v2274 + v2277 = call eq_11(v2275, v2276) + cbr v2277, block78(), block79(), !1875 - Finished in ??? + block78(): + v2278 = get_local __ptr { ptr }, _buffer, !1876 + v2279 = call read_72(v2278), !1881 + v2280 = asm(input: v2279) -> u64 input, !1884 { + } + v2281 = call read_72(v2278), !1887 + v2282 = asm(input: v2281) -> u64 input, !1890 { + } + v2283 = call read_72(v2278), !1893 + v2284 = asm(input: v2283) -> u64 input, !1896 { + } + v2285 = call read_72(v2278), !1899 + v2286 = asm(input: v2285) -> u64 input, !1902 { + } + v2287 = const u64 24, !1903 + v2288 = lsh v2280, v2287, !1906 + v2289 = const u64 4294967295, !1907 + v2290 = and v2288, v2289, !1908 + v2291 = const u64 16, !1909 + v2292 = lsh v2282, v2291, !1912 + v2293 = and v2292, v2289, !1913 + v2294 = or v2290, v2293, !1916 + v2295 = const u64 8, !1917 + v2296 = lsh v2284, v2295, !1920 + v2297 = and v2296, v2289, !1921 + v2298 = or v2294, v2297, !1924 + v2299 = or v2298, v2286, !1927 + v2300 = get_local __ptr { u64 }, __anon_037, !1928 + v2301 = const u64 0 + v2302 = get_elem_ptr v2300, __ptr u64, v2301, !1929 + store v2299 to v2302, !1930 + v2303 = get_local __ptr { u64 }, args__________________________, !1931 + mem_copy_val v2303, v2300 + v2304 = get_local __ptr { u64 }, args__________________________, !1932 + v2305 = const u64 0 + v2306 = get_elem_ptr v2304, __ptr u64, v2305, !1933 + v2307 = get_local __ptr { { ptr, u64, u64 } }, __ret_val46 + v2308 = call new_21(v2307) + v2309 = get_local __ptr { { ptr, u64, u64 } }, buffer_50, !1936 + mem_copy_val v2309, v2307 + v2310 = get_local __ptr { { ptr, u64, u64 } }, buffer_50, !1938 + v2311 = const u64 0 + v2312 = get_elem_ptr v2310, __ptr { ptr, u64, u64 }, v2311, !1939 + v2313 = asm(buffer: v2312) -> __ptr { ptr, u64, u64 } buffer { + } + v2314 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_056 + mem_copy_val v2314, v2313 + v2315 = get_local __ptr { ptr, u64, u64 }, __anon_038, !1940 + mem_copy_val v2315, v2314 + v2316 = const u64 0 + v2317 = get_elem_ptr v2315, __ptr ptr, v2316, !1941 + v2318 = load v2317, !1942 + v2319 = const u64 1 + v2320 = get_elem_ptr v2315, __ptr u64, v2319, !1943 + v2321 = load v2320, !1944 + v2322 = const u64 2 + v2323 = get_elem_ptr v2315, __ptr u64, v2322, !1945 + v2324 = load v2323, !1946 + v2325 = const u64 4 + v2326 = add v2324, v2325, !1947 + v2327 = cmp gt v2326 v2321, !1948 + cbr v2327, encode_197_abi_encode_198_block1(), encode_197_abi_encode_198_block0(v2318, v2321), !1949 -> Block: TUPLE0 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_197_abi_encode_198_block0(v2328: ptr, v2329: u64): + v2330 = get_local __ptr u64, __anon_121, !1950 + mem_copy_val v2330, v2306 + v2331 = const u64 4 + v2332 = add v2330, v2331, !1951 + v2333 = cast_ptr v2332 to __ptr u8, !1952 + v2334 = add v2328, v2324, !1953 + v2335 = cast_ptr v2334 to __ptr u8, !1954 + mem_copy_bytes v2335, v2333, 4, !1955 + v2336 = get_local __ptr { ptr, u64, u64 }, __anon_220, !1956 + v2337 = const u64 0 + v2338 = get_elem_ptr v2336, __ptr ptr, v2337, !1957 + store v2328 to v2338, !1958 + v2339 = const u64 1 + v2340 = get_elem_ptr v2336, __ptr u64, v2339, !1959 + store v2329 to v2340, !1960 + v2341 = const u64 2 + v2342 = get_elem_ptr v2336, __ptr u64, v2341, !1961 + store v2326 to v2342, !1962 + v2343 = asm(buffer: v2336) -> __ptr { ptr, u64, u64 } buffer { + } + v2344 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_057 + mem_copy_val v2344, v2343 + v2345 = get_local __ptr { { ptr, u64, u64 } }, __anon_318, !1964 + v2346 = const u64 0 + v2347 = get_elem_ptr v2345, __ptr { ptr, u64, u64 }, v2346, !1965 + mem_copy_val v2347, v2344 + v2348 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !1966 + mem_copy_val v2348, v2345 + v2349 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !1967 + v2350 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg97 + mem_copy_val v2350, v2349 + v2351 = get_local __ptr slice, __ret_val67 + v2352 = call as_raw_slice_22(v2350, v2351) + v2353 = get_local __ptr slice, _result____________________________________________________, !1968 + mem_copy_val v2353, v2351 + v2354 = get_local __ptr slice, _result____________________________________________________, !1969 + v2355 = get_local __ptr slice, self_44, !1972 + mem_copy_val v2355, v2354 + v2356 = get_local __ptr slice, self_44, !1973 + v2357 = get_local __ptr slice, slice_30, !1974 + mem_copy_val v2357, v2356 + v2358 = get_local __ptr slice, slice_30, !1975 + v2359 = asm(ptr: v2358) -> __ptr { ptr, u64 } ptr { + } + v2360 = get_local __ptr { ptr, u64 }, __aggr_memcpy_058 + mem_copy_val v2360, v2359 + v2361 = get_local __ptr { ptr, u64 }, __anon_073, !1972 + mem_copy_val v2361, v2360 + v2362 = get_elem_ptr v2361, __ptr ptr, v37, !1976 + v2363 = load v2362, !1972 + v2364 = get_local __ptr slice, _result____________________________________________________, !1977 + v2365 = get_local __ptr slice, __tmp_arg125 + mem_copy_val v2365, v2364 + v2366 = call len_30(v2365) + retd v2363 v2366, !1978 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.12 KB] in ??? - Running 1 test, filtered 0 tests + encode_197_abi_encode_198_block1(): + v2367 = const u64 2 + v2368 = mul v2321, v2367, !1979 + v2369 = add v2368, v2325, !1980 + v2370 = asm(new_cap: v2369, old_ptr: v2318, len: v2324) -> __ptr u8 hp, !1981 { + aloc new_cap + mcp hp old_ptr len + } + br encode_197_abi_encode_198_block0(v2370, v2369), !1982 -tested -- const_of_contract_call + block79(): + v2371 = get_local __ptr slice, _method_name, !1983 + v2372 = get_global __ptr string<6>, __const_global26 + v2373 = cast_ptr v2372 to ptr, !1984 + v2374 = get_local __ptr { ptr, u64 }, __anon_54, !1984 + v2375 = const u64 0 + v2376 = get_elem_ptr v2374, __ptr ptr, v2375 + store v2373 to v2376, !1984 + v2377 = const u64 1 + v2378 = get_elem_ptr v2374, __ptr u64, v2377 + v2379 = const u64 6 + store v2379 to v2378, !1984 + v2380 = get_local __ptr slice, __anon_55, !1984 + mem_copy_bytes v2380, v2374, 16 + v2381 = get_local __ptr slice, __tmp_arg53 + mem_copy_val v2381, v2371 + v2382 = get_local __ptr slice, __tmp_arg54 + mem_copy_val v2382, v2380 + v2383 = call eq_11(v2381, v2382) + cbr v2383, block81(), block82(), !1985 - test isolated_cost_of_in_tuple_0 ... ok (???, 10630 gas) + block81(): + v2384 = get_local __ptr { ptr }, _buffer, !1986 + v2385 = get_elem_ptr v2384, __ptr ptr, v19, !1989 + v2386 = load v2385, !1990 + v2387 = asm(ptr: v2386, val) -> u64 val, !1991 { + lw val ptr i0, !58 + } + v2388 = load v2385, !1990 + v2389 = const u64 8, !1990 + v2390 = add v2388, v2389, !1990 + store v2390 to v2385, !1992 + v2391 = get_local __ptr { u64 }, __anon_039, !1993 + v2392 = get_elem_ptr v2391, __ptr u64, v1801, !1994 + store v2387 to v2392, !1995 + v2393 = get_local __ptr { u64 }, args___________________________, !1996 + mem_copy_val v2393, v2391 + v2394 = get_local __ptr { u64 }, args___________________________, !1997 + v2395 = const u64 0 + v2396 = get_elem_ptr v2394, __ptr u64, v2395, !1998 + v2397 = load v2396 + v2398 = get_local __ptr { { ptr, u64, u64 } }, __ret_val47 + v2399 = call new_21(v2398) + v2400 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg78 + mem_copy_val v2400, v2398 + v2401 = get_local __ptr { { ptr, u64, u64 } }, __ret_val27 + v2402 = call abi_encode_20(v2397, v2400, v2401) + v2403 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !2001 + mem_copy_val v2403, v2401 + v2404 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !2002 + v2405 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg98 + mem_copy_val v2405, v2404 + v2406 = get_local __ptr slice, __ret_val68 + v2407 = call as_raw_slice_22(v2405, v2406) + v2408 = get_local __ptr slice, _result______________________________________________________, !2003 + mem_copy_val v2408, v2406 + v2409 = get_local __ptr slice, _result______________________________________________________, !2004 + v2410 = get_local __ptr slice, self_45, !2007 + mem_copy_val v2410, v2409 + v2411 = get_local __ptr slice, self_45, !2008 + v2412 = get_local __ptr slice, slice_31, !2009 + mem_copy_val v2412, v2411 + v2413 = get_local __ptr slice, slice_31, !2010 + v2414 = asm(ptr: v2413) -> __ptr { ptr, u64 } ptr { + } + v2415 = get_local __ptr { ptr, u64 }, __aggr_memcpy_059 + mem_copy_val v2415, v2414 + v2416 = get_local __ptr { ptr, u64 }, __anon_074, !2007 + mem_copy_val v2416, v2415 + v2417 = get_elem_ptr v2416, __ptr ptr, v37, !2011 + v2418 = load v2417, !2007 + v2419 = get_local __ptr slice, _result______________________________________________________, !2012 + v2420 = get_local __ptr slice, __tmp_arg126 + mem_copy_val v2420, v2419 + v2421 = call len_30(v2420) + retd v2418 v2421, !2013 -test result: OK. 1 passed; 0 failed; finished in ??? + block82(): + v2422 = get_local __ptr slice, _method_name, !2014 + v2423 = get_global __ptr string<5>, __const_global27 + v2424 = cast_ptr v2423 to ptr, !2015 + v2425 = get_local __ptr { ptr, u64 }, __anon_56, !2015 + v2426 = const u64 0 + v2427 = get_elem_ptr v2425, __ptr ptr, v2426 + store v2424 to v2427, !2015 + v2428 = const u64 1 + v2429 = get_elem_ptr v2425, __ptr u64, v2428 + v2430 = const u64 5 + store v2430 to v2429, !2015 + v2431 = get_local __ptr slice, __anon_57, !2015 + mem_copy_bytes v2431, v2425, 16 + v2432 = get_local __ptr slice, __tmp_arg55 + mem_copy_val v2432, v2422 + v2433 = get_local __ptr slice, __tmp_arg56 + mem_copy_val v2433, v2431 + v2434 = call eq_11(v2432, v2433) + cbr v2434, block84(), block85(), !2016 - Finished in ??? + block84(): + v2435 = get_local __ptr { ptr }, _buffer, !2017 + v2436 = call read_72(v2435), !2022 + v2437 = get_local __ptr { u8 }, __anon_040, !2023 + v2438 = const u64 0 + v2439 = get_elem_ptr v2437, __ptr u8, v2438, !2024 + store v2436 to v2439, !2025 + v2440 = get_local __ptr { u8 }, args____________________________, !2026 + mem_copy_val v2440, v2437 + v2441 = get_local __ptr { u8 }, args____________________________, !2027 + v2442 = const u64 0 + v2443 = get_elem_ptr v2441, __ptr u8, v2442, !2028 + v2444 = load v2443 + v2445 = get_local __ptr { { ptr, u64, u64 } }, __ret_val48 + v2446 = call new_21(v2445) + v2447 = get_local __ptr { { ptr, u64, u64 } }, buffer_53, !2031 + mem_copy_val v2447, v2445 + v2448 = get_local __ptr { { ptr, u64, u64 } }, buffer_53, !2033 + v2449 = const u64 0 + v2450 = get_elem_ptr v2448, __ptr { ptr, u64, u64 }, v2449, !2034 + v2451 = asm(buffer: v2450) -> __ptr { ptr, u64, u64 } buffer { + } + v2452 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_060 + mem_copy_val v2452, v2451 + v2453 = get_local __ptr { ptr, u64, u64 }, __anon_041, !2035 + mem_copy_val v2453, v2452 + v2454 = const u64 0 + v2455 = get_elem_ptr v2453, __ptr ptr, v2454, !2036 + v2456 = load v2455, !2037 + v2457 = const u64 1 + v2458 = get_elem_ptr v2453, __ptr u64, v2457, !2038 + v2459 = load v2458, !2039 + v2460 = const u64 2 + v2461 = get_elem_ptr v2453, __ptr u64, v2460, !2040 + v2462 = load v2461, !2041 + v2463 = const u64 1 + v2464 = add v2462, v2463, !2042 + v2465 = cmp gt v2464 v2459, !2043 + cbr v2465, encode_205_abi_encode_206_block1(), encode_205_abi_encode_206_block0(v2456, v2459), !2044 -> Block: TUPLE1 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + encode_205_abi_encode_206_block0(v2466: ptr, v2467: u64): + v2468 = add v2466, v2462, !2045 + v2469 = cast_ptr v2468 to __ptr u8, !2046 + store v2444 to v2469, !2047 + v2470 = get_local __ptr { ptr, u64, u64 }, __anon_122, !2048 + v2471 = const u64 0 + v2472 = get_elem_ptr v2470, __ptr ptr, v2471, !2049 + store v2466 to v2472, !2050 + v2473 = const u64 1 + v2474 = get_elem_ptr v2470, __ptr u64, v2473, !2051 + store v2467 to v2474, !2052 + v2475 = const u64 2 + v2476 = get_elem_ptr v2470, __ptr u64, v2475, !2053 + store v2464 to v2476, !2054 + v2477 = asm(buffer: v2470) -> __ptr { ptr, u64, u64 } buffer { + } + v2478 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_061 + mem_copy_val v2478, v2477 + v2479 = get_local __ptr { { ptr, u64, u64 } }, __anon_221, !2056 + v2480 = const u64 0 + v2481 = get_elem_ptr v2479, __ptr { ptr, u64, u64 }, v2480, !2057 + mem_copy_val v2481, v2478 + v2482 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !2058 + mem_copy_val v2482, v2479 + v2483 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !2059 + v2484 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg99 + mem_copy_val v2484, v2483 + v2485 = get_local __ptr slice, __ret_val69 + v2486 = call as_raw_slice_22(v2484, v2485) + v2487 = get_local __ptr slice, _result________________________________________________________, !2060 + mem_copy_val v2487, v2485 + v2488 = get_local __ptr slice, _result________________________________________________________, !2061 + v2489 = get_local __ptr slice, self_46, !2064 + mem_copy_val v2489, v2488 + v2490 = get_local __ptr slice, self_46, !2065 + v2491 = get_local __ptr slice, slice_32, !2066 + mem_copy_val v2491, v2490 + v2492 = get_local __ptr slice, slice_32, !2067 + v2493 = asm(ptr: v2492) -> __ptr { ptr, u64 } ptr { + } + v2494 = get_local __ptr { ptr, u64 }, __aggr_memcpy_062 + mem_copy_val v2494, v2493 + v2495 = get_local __ptr { ptr, u64 }, __anon_075, !2064 + mem_copy_val v2495, v2494 + v2496 = get_elem_ptr v2495, __ptr ptr, v37, !2068 + v2497 = load v2496, !2064 + v2498 = get_local __ptr slice, _result________________________________________________________, !2069 + v2499 = get_local __ptr slice, __tmp_arg127 + mem_copy_val v2499, v2498 + v2500 = call len_30(v2499) + retd v2497 v2500, !2070 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.768 KB] in ??? - Running 1 test, filtered 0 tests + encode_205_abi_encode_206_block1(): + v2501 = const u64 2 + v2502 = mul v2459, v2501, !2071 + v2503 = add v2502, v2463, !2072 + v2504 = asm(new_cap: v2503, old_ptr: v2456, len: v2462) -> __ptr u8 hp, !2073 { + aloc new_cap + mcp hp old_ptr len + } + br encode_205_abi_encode_206_block0(v2504, v2503), !2074 -tested -- const_of_contract_call + block85(): + v2505 = const u64 123, !2075 + revert v2505, !2076 + } - test isolated_cost_of_in_tuple_1 ... ok (???, 11172 gas) + pub fn read_bytes_8(self !2077: __ptr { ptr }, count !2078: u64, __ret_value: __ptr slice) -> (), !2081 { + local mut slice __aggr_memcpy_0 + local { ptr, u64 } __anon_0 + local slice slice -test result: OK. 1 passed; 0 failed; finished in ??? + entry(self: __ptr { ptr }, count: u64, __ret_value: __ptr slice): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr ptr, v0, !53 + v2 = get_local __ptr { ptr, u64 }, __anon_0, !2082 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr ptr, v3, !2082 + mem_copy_val v4, v1 + v5 = const u64 1 + v6 = get_elem_ptr v2, __ptr u64, v5, !2082 + store count to v6, !2082 + v7 = asm(ptr: v2) -> __ptr slice ptr { + } + v8 = get_local __ptr slice, __aggr_memcpy_0 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, slice, !2083 + mem_copy_val v9, v8 + v10 = load v1 + v11 = add v10, count + store v11 to v1, !2084 + v12 = get_local __ptr slice, slice, !2085 + mem_copy_val __ret_value, v12 + v13 = const unit () + ret () v13 + } - Finished in ??? + pub fn eq_11(self: __ptr slice, other: __ptr slice) -> bool, !2089 { + local slice __tmp_arg + local slice __tmp_arg0 + local slice __tmp_arg1 + local slice __tmp_arg2 + local slice __tmp_arg3 + local slice other_ + local slice self_ -> Block: TUPLE2 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + entry(self: __ptr slice, other: __ptr slice): + v0 = get_local __ptr slice, self_ + mem_copy_val v0, self + v1 = get_local __ptr slice, other_ + mem_copy_val v1, other + v2 = get_local __ptr slice, self_, !2090 + v3 = get_local __ptr slice, __tmp_arg + mem_copy_val v3, v2 + v4 = call len_14(v3) + v5 = get_local __ptr slice, other_, !2091 + v6 = get_local __ptr slice, __tmp_arg0 + mem_copy_val v6, v5 + v7 = call len_14(v6) + v8 = cmp eq v4 v7, !2096 + v9 = const bool false, !2097 + v10 = cmp eq v8 v9, !2100 + v11 = const bool false, !2101 + cbr v10, block2(v11), block1(), !2092 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.944 KB] in ??? - Running 1 test, filtered 0 tests + block1(): + v12 = get_local __ptr slice, self_, !2102 + v13 = get_local __ptr slice, __tmp_arg2 + mem_copy_val v13, v12 + v14 = call as_ptr_15(v13) + v15 = get_local __ptr slice, other_, !2103 + v16 = get_local __ptr slice, __tmp_arg3 + mem_copy_val v16, v15 + v17 = call as_ptr_15(v16) + v18 = get_local __ptr slice, self_, !2104 + v19 = get_local __ptr slice, __tmp_arg1 + mem_copy_val v19, v18 + v20 = call len_14(v19) + v21 = asm(r1: v14, r2: v17, r3: v20, r4) -> bool r4, !2105 { + meq r4 r1 r2 r3, !2106 + } + br block2(v21) -tested -- const_of_contract_call + block2(v22: bool): + ret bool v22 + } - test isolated_cost_of_in_tuple_2 ... ok (???, 11560 gas) + pub fn len_14(self: __ptr slice) -> u64, !2110 { + local slice self_ -test result: OK. 1 passed; 0 failed; finished in ??? + entry(self: __ptr slice): + v0 = get_local __ptr slice, self_ + mem_copy_val v0, self + v1 = get_local __ptr slice, self_, !2111 + v2 = asm(s: v1) -> __ptr { ptr, u64 } s { + } + v3 = const u64 1 + v4 = get_elem_ptr v2, __ptr u64, v3 + v5 = load v4 + ret u64 v5 + } - Finished in ??? + pub fn as_ptr_15(self: __ptr slice) -> ptr, !2114 { + local slice self_ -> Block: TUPLE3 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + entry(self: __ptr slice): + v0 = get_local __ptr slice, self_ + mem_copy_val v0, self + v1 = get_local __ptr slice, self_, !2115 + v2 = asm(s: v1) -> __ptr { ptr, u64 } s { + } + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr ptr, v3 + v5 = load v4 + ret ptr v5 + } -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.016 KB] in ??? - Running 1 test, filtered 0 tests + pub fn abi_decode_18(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 0]) -> (), !2120 { + local [u8; 0] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 0] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 -tested -- const_of_contract_call + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 0]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 0, !2121 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2123 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2124 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 0], __anon_0, !2125 + mem_clear_val v13 + v14 = get_local __ptr [u8; 0], array, !2126 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 0], array, !2127 + v16 = cast_ptr v15 to __ptr [u64; 0] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 0 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2129 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2130 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !2131 + br while(v30) - test isolated_cost_of_in_tuple_3 ... ok (???, 11829 gas) + while(v31: u64): + v32 = const u64 0 + v33 = cmp lt v31 v32, !2134 + cbr v33, while_body(), end_while() -test result: OK. 1 passed; 0 failed; finished in ??? + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !2135 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2136 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2137 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !2140 + v51 = load v50, !2141 + v52 = asm(ptr: v51, val) -> u64 val, !2142 { + lw val ptr i0, !58 + } + v53 = load v50, !2141 + v54 = const u64 8, !2141 + v55 = add v53, v54, !2141 + store v55 to v50, !2143 + store v52 to v48, !2144 + v56 = const u64 1, !2145 + v57 = add v31, v56, !2148 + br while(v57) - Finished in ??? + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } -> Block: TUPLE4 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + pub fn abi_encode_20(self !2149: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !2152 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local { ptr, u64, u64 } __anon_1 + local { { ptr, u64, u64 } } __anon_2 + local { { ptr, u64, u64 } } buffer_ -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.08 KB] in ??? - Running 1 test, filtered 0 tests + entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2153 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !428 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v5, v4 + v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v6, v5 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr ptr, v7 + v9 = load v8 + v10 = const u64 1 + v11 = get_elem_ptr v6, __ptr u64, v10 + v12 = load v11 + v13 = const u64 2 + v14 = get_elem_ptr v6, __ptr u64, v13 + v15 = load v14 + v16 = const u64 8 + v17 = add v15, v16 + v18 = cmp gt v17 v12 + cbr v18, block1(), block0(v9, v12) -tested -- const_of_contract_call + block0(v19: ptr, v20: u64): + v21 = add v19, v15 + v22 = cast_ptr v21 to __ptr u64 + store self to v22 + v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 + v24 = const u64 0 + v25 = get_elem_ptr v23, __ptr ptr, v24 + store v19 to v25 + v26 = const u64 1 + v27 = get_elem_ptr v23, __ptr u64, v26 + store v20 to v27 + v28 = const u64 2 + v29 = get_elem_ptr v23, __ptr u64, v28 + store v17 to v29 + v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { + } + v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v31, v30 + v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !2154 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 + mem_copy_val v34, v31 + mem_copy_val __ret_value, v32 + v35 = const unit () + ret () v35 - test isolated_cost_of_in_tuple_4 ... ok (???, 12097 gas) + block1(): + v36 = const u64 2 + v37 = mul v12, v36 + v38 = add v37, v16 + v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v39, v38) + } -test result: OK. 1 passed; 0 failed; finished in ??? + pub fn new_21(__ret_value: __ptr { { ptr, u64, u64 } }) -> (), !2157 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local { ptr, u64, u64 } __anon_0 + local { { ptr, u64, u64 } } __anon_1 - Finished in ??? + entry(__ret_value: __ptr { { ptr, u64, u64 } }): + v0 = const u64 1024 + v1 = asm(cap: v0) -> ptr hp { + aloc cap + } + v2 = get_local __ptr { ptr, u64, u64 }, __anon_0 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr ptr, v3 + store v1 to v4 + v5 = const u64 1 + v6 = get_elem_ptr v2, __ptr u64, v5 + store v0 to v6 + v7 = const u64 2 + v8 = get_elem_ptr v2, __ptr u64, v7 + v9 = const u64 0 + store v9 to v8 + v10 = asm(buffer: v2) -> __ptr { ptr, u64, u64 } buffer { + } + v11 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v11, v10 + v12 = get_local __ptr { { ptr, u64, u64 } }, __anon_1, !2158 + v13 = const u64 0 + v14 = get_elem_ptr v12, __ptr { ptr, u64, u64 }, v13 + mem_copy_val v14, v11 + mem_copy_val __ret_value, v12 + v15 = const unit () + ret () v15 + } -> Block: U16 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + pub fn as_raw_slice_22(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice) -> (), !2161 { + local mut slice __aggr_memcpy_00 + local { ptr, u64 } __anon_1 + local { { ptr, u64, u64 } } self_ -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.72 KB] in ??? - Running 1 test, filtered 0 tests + entry(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, self_, !2162 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !428 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + v7 = load v6 + v8 = const u64 2 + v9 = get_elem_ptr v4, __ptr u64, v8 + v10 = load v9 + v11 = get_local __ptr { ptr, u64 }, __anon_1 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr ptr, v12 + v14 = get_elem_ptr v13, __ptr ptr, + store v7 to v14 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15 + v17 = get_elem_ptr v16, __ptr u64, + store v10 to v17 + v18 = asm(s: v11) -> __ptr slice s { + } + v19 = get_local __ptr slice, __aggr_memcpy_00 + mem_copy_val v19, v18 + mem_copy_val __ret_value, v19 + v20 = const unit () + ret () v20 + } -tested -- const_of_contract_call + pub fn len_30(self: __ptr slice) -> u64, !2165 { + local slice slice_ - test isolated_cost_of_in_u16 ... ok (???, 11232 gas) + entry(self: __ptr slice): + v0 = get_local __ptr slice, slice_, !2168 + mem_copy_val v0, self + v1 = get_local __ptr slice, slice_, !2169 + v2 = asm(ptr: v1) -> __ptr { ptr, u64 } ptr { + } + v3 = const u64 1 + v4 = get_elem_ptr v2, __ptr u64, v3 + v5 = load v4 + ret u64 v5 + } -test result: OK. 1 passed; 0 failed; finished in ??? + pub fn abi_decode_34(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 1]) -> (), !2170 { + local [u8; 1] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 1] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 - Finished in ??? + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 1]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 1, !2121 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2171 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2172 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 1], __anon_0, !2125 + mem_clear_val v13 + v14 = get_local __ptr [u8; 1], array, !2126 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 1], array, !2127 + v16 = cast_ptr v15 to __ptr [u64; 1] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 1 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2173 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2174 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !2131 + br while(v30) -> Block: U256 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + while(v31: u64): + v32 = const u64 1 + v33 = cmp lt v31 v32, !2175 + cbr v33, while_body(), end_while() -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.808 KB] in ??? - Running 1 test, filtered 0 tests + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !2135 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2176 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2177 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !2178 + v51 = load v50, !2179 + v52 = asm(ptr: v51, val) -> u64 val, !2180 { + lw val ptr i0, !58 + } + v53 = load v50, !2179 + v54 = const u64 8, !2179 + v55 = add v53, v54, !2179 + store v55 to v50, !2181 + store v52 to v48, !2144 + v56 = const u64 1, !2145 + v57 = add v31, v56, !2182 + br while(v57) -tested -- const_of_contract_call + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } - test isolated_cost_of_in_u256 ... ok (???, 11220 gas) + pub fn abi_decode_40(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 16]) -> (), !2183 { + local [u8; 16] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 16] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 -test result: OK. 1 passed; 0 failed; finished in ??? + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 16]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 16, !2121 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2184 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2185 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 16], __anon_0, !2125 + mem_clear_val v13 + v14 = get_local __ptr [u8; 16], array, !2126 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 16], array, !2127 + v16 = cast_ptr v15 to __ptr [u64; 16] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 16 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2186 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2187 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !2131 + br while(v30) - Finished in ??? + while(v31: u64): + v32 = const u64 16 + v33 = cmp lt v31 v32, !2188 + cbr v33, while_body(), end_while() -> Block: U32 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !2135 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2189 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2190 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !2191 + v51 = load v50, !2192 + v52 = asm(ptr: v51, val) -> u64 val, !2193 { + lw val ptr i0, !58 + } + v53 = load v50, !2192 + v54 = const u64 8, !2192 + v55 = add v53, v54, !2192 + store v55 to v50, !2194 + store v52 to v48, !2144 + v56 = const u64 1, !2145 + v57 = add v31, v56, !2195 + br while(v57) -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.832 KB] in ??? - Running 1 test, filtered 0 tests + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } -tested -- const_of_contract_call + pub fn abi_decode_46(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 32]) -> (), !2196 { + local [u8; 32] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 32] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 - test isolated_cost_of_in_u32 ... ok (???, 11475 gas) + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 32]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 32, !2121 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2197 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2198 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 32], __anon_0, !2125 + mem_clear_val v13 + v14 = get_local __ptr [u8; 32], array, !2126 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 32], array, !2127 + v16 = cast_ptr v15 to __ptr [u64; 32] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 32 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2199 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2200 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !2131 + br while(v30) -test result: OK. 1 passed; 0 failed; finished in ??? + while(v31: u64): + v32 = const u64 32 + v33 = cmp lt v31 v32, !2201 + cbr v33, while_body(), end_while() - Finished in ??? + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !2135 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2202 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2203 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !2204 + v51 = load v50, !2205 + v52 = asm(ptr: v51, val) -> u64 val, !2206 { + lw val ptr i0, !58 + } + v53 = load v50, !2205 + v54 = const u64 8, !2205 + v55 = add v53, v54, !2205 + store v55 to v50, !2207 + store v52 to v48, !2144 + v56 = const u64 1, !2145 + v57 = add v31, v56, !2208 + br while(v57) -> Block: U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.624 KB] in ??? - Running 1 test, filtered 0 tests + pub fn abi_decode_52(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 64]) -> (), !2209 { + local [u8; 64] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 64] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 -tested -- const_of_contract_call + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 64]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 64, !2121 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2210 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2211 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 64], __anon_0, !2125 + mem_clear_val v13 + v14 = get_local __ptr [u8; 64], array, !2126 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 64], array, !2127 + v16 = cast_ptr v15 to __ptr [u64; 64] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 64 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2212 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2213 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !2131 + br while(v30) - test isolated_cost_of_in_u64 ... ok (???, 11059 gas) + while(v31: u64): + v32 = const u64 64 + v33 = cmp lt v31 v32, !2214 + cbr v33, while_body(), end_while() -test result: OK. 1 passed; 0 failed; finished in ??? + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !2135 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2215 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2216 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !2217 + v51 = load v50, !2218 + v52 = asm(ptr: v51, val) -> u64 val, !2219 { + lw val ptr i0, !58 + } + v53 = load v50, !2218 + v54 = const u64 8, !2218 + v55 = add v53, v54, !2218 + store v55 to v50, !2220 + store v52 to v48, !2144 + v56 = const u64 1, !2145 + v57 = add v31, v56, !2221 + br while(v57) - Finished in ??? + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } -> Block: U8 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + pub fn abi_decode_58(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 8]) -> (), !2222 { + local [u8; 8] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 8] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.664 KB] in ??? - Running 1 test, filtered 0 tests + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 8]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 8, !2121 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2223 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2224 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 8], __anon_0, !2125 + mem_clear_val v13 + v14 = get_local __ptr [u8; 8], array, !2126 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 8], array, !2127 + v16 = cast_ptr v15 to __ptr [u64; 8] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 8 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2225 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2226 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !2131 + br while(v30) -tested -- const_of_contract_call + while(v31: u64): + v32 = const u64 8 + v33 = cmp lt v31 v32, !2227 + cbr v33, while_body(), end_while() - test isolated_cost_of_in_u8 ... ok (???, 11085 gas) + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !2135 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2228 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2229 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !2230 + v51 = load v50, !2231 + v52 = asm(ptr: v51, val) -> u64 val, !2232 { + lw val ptr i0, !58 + } + v53 = load v50, !2231 + v54 = const u64 8, !2231 + v55 = add v53, v54, !2231 + store v55 to v50, !2233 + store v52 to v48, !2144 + v56 = const u64 1, !2145 + v57 = add v31, v56, !2234 + br while(v57) -test result: OK. 1 passed; 0 failed; finished in ??? + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } - Finished in ??? -======= - test cost_of_in_bool ... ok (???, 3371 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_u8 ... ok (???, 5610 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 + pub fn encode_60(item: __ptr [u64; 8], __ret_value: __ptr slice) -> (), !2237 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local slice __ret_val1 + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 8] self_ + + entry(item: __ptr [u64; 8], __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v1 = call new_21(v0) + v2 = get_local __ptr [u64; 8], self_, !2238 + mem_copy_val v2, item + v3 = const u64 0 + v4 = const u64 0 + v5 = get_elem_ptr v0, __ptr ptr, v3, v4 + v6 = load v5 + v7 = const u64 0 + v8 = const u64 1 + v9 = get_elem_ptr v0, __ptr u64, v7, v8 + v10 = load v9 + v11 = const u64 0 + v12 = const u64 2 + v13 = get_elem_ptr v0, __ptr u64, v11, v12 + v14 = load v13 + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2239 + v16 = const u64 0 + v17 = const u64 0 + v18 = get_elem_ptr v15, __ptr ptr, v16, v17 + store v6 to v18 + v19 = const u64 0 + v20 = const u64 1 + v21 = get_elem_ptr v15, __ptr u64, v19, v20 + store v10 to v21 + v22 = const u64 0 + v23 = const u64 2 + v24 = get_elem_ptr v15, __ptr u64, v22, v23 + store v14 to v24 + v25 = const u64 0, !119 + br abi_encode_61_while(v25), !2238 + + abi_encode_61_while(v26: u64): + v27 = const u64 8 + v28 = cmp lt v26 v27, !2240 + cbr v28, abi_encode_61_while_body(), abi_encode_61_end_while(), !2238 + + abi_encode_61_while_body(): + v29 = get_local __ptr [u64; 8], self_, !2241 + v30 = get_elem_ptr v29, __ptr u64, v26, !2242 + v31 = load v30, !2238 + v32 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2243 + v33 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v34 = call abi_encode_20(v31, v32, v33) + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2244 + mem_copy_val v35, v33 + v36 = const u64 1, !134 + v37 = add v26, v36, !2245 + br abi_encode_61_while(v37), !2238 + + abi_encode_61_end_while(): + v38 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2246 + v39 = get_local __ptr slice, __ret_val1 + v40 = call as_raw_slice_22(v38, v39) + mem_copy_val __ret_value, v39 + v41 = const unit () + ret () v41 + } + + pub fn read_72(self !2247: __ptr { ptr }) -> u8, !2250 { + entry(self: __ptr { ptr }): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr ptr, v0, !53 + v2 = load v1 + v3 = asm(ptr: v2, val) -> u8 val, !2251 { + lb val ptr i0, !2252 + } + v4 = load v1 + v5 = const u64 1 + v6 = add v4, v5 + store v6 to v1, !2253 + ret u8 v3 + } + + pub fn encode_130(item: __ptr { u64 }, __ret_value: __ptr slice) -> (), !2254 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local slice __ret_val1 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + + entry(item: __ptr { u64 }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2255 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr u64, v3, !2257 + v5 = load v4, !2255 + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v7 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v8 = call abi_encode_20(v5, v6, v7) + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2259 + mem_copy_val v9, v7 + v10 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v11 = get_local __ptr slice, __ret_val1 + v12 = call as_raw_slice_22(v10, v11) + mem_copy_val __ret_value, v11 + v13 = const unit () + ret () v13 + } + + pub fn encode_142(item: __ptr { u64, u64, u64 }, __ret_value: __ptr slice) -> (), !2260 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local slice __ret_val3 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer___ + local { { ptr, u64, u64 } } buffer____ + + entry(item: __ptr { u64, u64, u64 }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2261 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr u64, v3, !2263 + v5 = load v4, !2261 + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v7 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v8 = call abi_encode_20(v5, v6, v7) + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2265 + mem_copy_val v9, v7 + v10 = const u64 1 + v11 = get_elem_ptr item, __ptr u64, v10, !2267 + v12 = load v11, !2261 + v13 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v14 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v15 = call abi_encode_20(v12, v13, v14) + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !2269 + mem_copy_val v16, v14 + v17 = const u64 2 + v18 = get_elem_ptr item, __ptr u64, v17, !2271 + v19 = load v18, !2261 + v20 = get_local __ptr { { ptr, u64, u64 } }, buffer___ + v21 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v22 = call abi_encode_20(v19, v20, v21) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !2273 + mem_copy_val v23, v21 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer____ + v25 = get_local __ptr slice, __ret_val3 + v26 = call as_raw_slice_22(v24, v25) + mem_copy_val __ret_value, v25 + v27 = const unit () + ret () v27 + } + + pub fn encode_158(item: __ptr { u64, u64 }, __ret_value: __ptr slice) -> (), !2274 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val2 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer___ + + entry(item: __ptr { u64, u64 }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2275 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr u64, v3, !2277 + v5 = load v4, !2275 + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v7 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v8 = call abi_encode_20(v5, v6, v7) + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2279 + mem_copy_val v9, v7 + v10 = const u64 1 + v11 = get_elem_ptr item, __ptr u64, v10, !2281 + v12 = load v11, !2275 + v13 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v14 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v15 = call abi_encode_20(v12, v13, v14) + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !2283 + mem_copy_val v16, v14 + v17 = get_local __ptr { { ptr, u64, u64 } }, buffer___ + v18 = get_local __ptr slice, __ret_val2 + v19 = call as_raw_slice_22(v17, v18) + mem_copy_val __ret_value, v18 + v20 = const unit () + ret () v20 + } +} + +!0 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main..sw" +!1 = span !0 1 8828 +!2 = fn_name_span !0 8 15 +!3 = (!1 !2) +!4 = span !0 50 87 +!5 = fn_call_path_span !0 50 85 +!6 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/codec.sw" +!7 = span !6 1259 1300 +!8 = (!4 !5 !7) +!9 = span !6 1320 1359 +!10 = fn_call_path_span !6 1324 1327 +!11 = (!4 !5 !9 !10) +!12 = (!4 !5 !9 !10) +!13 = span !6 1379 1396 +!14 = fn_call_path_span !6 1383 1387 +!15 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_ptr.sw" +!16 = span !15 2650 2739 +!17 = (!4 !5 !13 !14 !16) +!18 = span !15 2688 2701 +!19 = span !6 1439 1497 +!20 = (!4 !5 !19) +!21 = span !6 1407 1508 +!22 = (!4 !5 !21) +!23 = (!4 !5) +!24 = (!4 !5 !21) +!25 = span !0 32 88 +!26 = span !0 120 147 +!27 = fn_call_path_span !0 120 138 +!28 = span !6 140299 140335 +!29 = fn_call_path_span !6 140299 140333 +!30 = span !6 882 923 +!31 = (!26 !27 !28 !29 !30) +!32 = span !6 943 981 +!33 = fn_call_path_span !6 947 950 +!34 = (!26 !27 !28 !29 !32 !33) +!35 = (!26 !27 !28 !29 !32 !33) +!36 = span !6 1001 1018 +!37 = fn_call_path_span !6 1005 1009 +!38 = (!26 !27 !28 !29 !36 !37 !16) +!39 = span !6 1061 1119 +!40 = (!26 !27 !28 !29 !39) +!41 = span !6 1029 1130 +!42 = (!26 !27 !28 !29 !41) +!43 = (!26 !27 !28 !29) +!44 = (!26 !27 !28 !29 !41) +!45 = span !6 140282 140336 +!46 = (!26 !27 !45) +!47 = span !6 140355 140361 +!48 = (!26 !27 !47) +!49 = span !6 140341 140362 +!50 = fn_call_path_span !6 140341 140354 +!51 = span !6 73247 73275 +!52 = fn_call_path_span !6 73254 73266 +!53 = span !6 625 637 +!54 = (!26 !27 !49 !50 !51 !52 !53) +!55 = (!26 !27 !49 !50 !51 !52) +!56 = span !6 2766 2847 +!57 = (!26 !27 !49 !50 !51 !52 !56) +!58 = span !6 2804 2817 +!59 = span !6 2857 2896 +!60 = (!26 !27 !49 !50 !51 !52 !59) +!61 = span !6 73285 73319 +!62 = (!26 !27 !49 !50 !61) +!63 = span !6 73336 73340 +!64 = (!26 !27 !49 !50 !63) +!65 = span !6 73336 73346 +!66 = fn_call_path_span !6 73341 73344 +!67 = (!26 !27 !49 !50 !65 !66) +!68 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_slice.sw" +!69 = span !68 2922 2926 +!70 = (!26 !27 !49 !50 !65 !66 !69) +!71 = span !68 2911 2927 +!72 = fn_call_path_span !68 2911 2921 +!73 = (!26 !27 !49 !50 !65 !66 !71 !72) +!74 = span !68 1633 1638 +!75 = (!26 !27 !49 !50 !65 !66 !71 !72 !74) +!76 = span !68 2928 2929 +!77 = (!26 !27 !49 !50 !65 !66 !76) +!78 = span !6 73335 73352 +!79 = (!26 !27 !49 !50 !78) +!80 = (!26 !27 !49 !50 !78) +!81 = (!26 !27 !49 !50 !78) +!82 = (!26 !27 !49 !50 !78) +!83 = span !0 101 148 +!84 = span !0 164 176 +!85 = span !0 180 192 +!86 = span !0 164 192 +!87 = span !0 219 226 +!88 = span !0 219 250 +!89 = fn_call_path_span !0 227 233 +!90 = span !6 3959 3978 +!91 = fn_call_path_span !6 3959 3972 +!92 = span !6 115441 115466 +!93 = (!88 !89 !90 !91 !92) +!94 = (!88 !89 !90 !91 !92) +!95 = span !0 195 251 +!96 = span !0 324 328 +!97 = span !0 329 330 +!98 = span !0 296 331 +!99 = fn_call_path_span !0 296 323 +!100 = (!98 !99) +!101 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw" +!102 = span !101 4062 4063 +!103 = (!98 !99 !102) +!104 = span !0 272 332 +!105 = span !0 377 384 +!106 = span !0 358 385 +!107 = fn_call_path_span !0 358 364 +!108 = (!106 !107) +!109 = span !6 70852 70856 +!110 = (!106 !107 !109) +!111 = span !6 70852 70882 +!112 = fn_call_path_span !6 70857 70867 +!113 = (!106 !107 !111 !112) +!114 = (!106 !107 !111 !112) +!115 = span !6 20784 20790 +!116 = (!106 !107 !111 !112 !115) +!117 = span !6 20767 20791 +!118 = (!106 !107 !111 !112 !117) +!119 = span !6 20812 20813 +!120 = (!106 !107 !111 !112) +!121 = span !6 20830 20835 +!122 = fn_call_path_span !6 20832 20833 +!123 = (!106 !107 !111 !112 !121 !122) +!124 = (!106 !107 !111 !112) +!125 = span !6 20859 20863 +!126 = (!106 !107 !111 !112 !125) +!127 = span !6 20859 20866 +!128 = (!106 !107 !111 !112 !127) +!129 = (!106 !107 !111 !112) +!130 = span !6 20878 20884 +!131 = (!106 !107 !111 !112 !130) +!132 = span !6 20850 20885 +!133 = (!106 !107 !111 !112 !132) +!134 = span !6 20904 20905 +!135 = span !6 20899 20905 +!136 = fn_call_path_span !6 20901 20903 +!137 = (!106 !107 !111 !112 !135 !136) +!138 = (!106 !107 !111 !112) +!139 = span !6 20927 20933 +!140 = (!106 !107 !111 !112 !139) +!141 = span !6 70839 70883 +!142 = (!106 !107 !141) +!143 = span !6 70888 70894 +!144 = (!106 !107 !143) +!145 = span !0 333 386 +!146 = span !0 422 429 +!147 = span !0 422 435 +!148 = fn_call_path_span !0 430 433 +!149 = (!147 !148) +!150 = (!147 !148 !69) +!151 = (!147 !148 !71 !72) +!152 = (!147 !148 !71 !72 !74) +!153 = (!147 !148 !76) +!154 = span !0 437 444 +!155 = span !0 407 457 +!156 = span !0 464 476 +!157 = span !0 480 492 +!158 = span !0 464 492 +!159 = span !0 519 526 +!160 = span !0 519 550 +!161 = fn_call_path_span !0 527 533 +!162 = (!160 !161 !90 !91 !92) +!163 = (!160 !161 !90 !91 !92) +!164 = span !0 495 551 +!165 = span !0 624 628 +!166 = span !0 629 630 +!167 = span !0 596 631 +!168 = fn_call_path_span !0 596 623 +!169 = (!167 !168) +!170 = span !101 4156 4157 +!171 = (!167 !168 !170) +!172 = span !0 572 632 +!173 = span !0 677 684 +!174 = span !0 658 685 +!175 = fn_call_path_span !0 658 664 +!176 = (!174 !175) +!177 = (!174 !175 !109) +!178 = (!174 !175 !111 !112) +!179 = (!174 !175 !111 !112) +!180 = (!174 !175 !111 !112 !115) +!181 = (!174 !175 !111 !112 !117) +!182 = (!174 !175 !111 !112) +!183 = (!174 !175 !111 !112 !121 !122) +!184 = (!174 !175 !111 !112) +!185 = (!174 !175 !111 !112 !125) +!186 = (!174 !175 !111 !112 !127) +!187 = (!174 !175 !111 !112) +!188 = (!174 !175 !111 !112 !130) +!189 = (!174 !175 !111 !112 !132) +!190 = (!174 !175 !111 !112 !135 !136) +!191 = (!174 !175 !111 !112) +!192 = (!174 !175 !111 !112 !139) +!193 = (!174 !175 !141) +!194 = (!174 !175 !143) +!195 = span !0 633 686 +!196 = span !0 722 729 +!197 = span !0 722 735 +!198 = fn_call_path_span !0 730 733 +!199 = (!197 !198) +!200 = (!197 !198 !69) +!201 = (!197 !198 !71 !72) +!202 = (!197 !198 !71 !72 !74) +!203 = (!197 !198 !76) +!204 = span !0 737 744 +!205 = span !0 707 757 +!206 = span !0 764 776 +!207 = span !0 780 793 +!208 = span !0 764 793 +!209 = span !0 821 828 +!210 = span !0 821 853 +!211 = fn_call_path_span !0 829 835 +!212 = (!210 !211 !90 !91 !92) +!213 = (!210 !211 !90 !91 !92) +!214 = span !0 796 854 +!215 = span !0 929 933 +!216 = span !0 934 935 +!217 = span !0 900 936 +!218 = fn_call_path_span !0 900 928 +!219 = (!217 !218) +!220 = span !101 4359 4360 +!221 = (!217 !218 !220) +!222 = span !0 875 937 +!223 = span !0 983 990 +!224 = span !0 963 991 +!225 = fn_call_path_span !0 963 969 +!226 = (!224 !225) +!227 = (!224 !225 !109) +!228 = (!224 !225 !111 !112) +!229 = (!224 !225 !111 !112) +!230 = (!224 !225 !111 !112 !115) +!231 = (!224 !225 !111 !112 !117) +!232 = (!224 !225 !111 !112) +!233 = (!224 !225 !111 !112 !121 !122) +!234 = (!224 !225 !111 !112) +!235 = (!224 !225 !111 !112 !125) +!236 = (!224 !225 !111 !112 !127) +!237 = (!224 !225 !111 !112) +!238 = (!224 !225 !111 !112 !130) +!239 = (!224 !225 !111 !112 !132) +!240 = (!224 !225 !111 !112 !135 !136) +!241 = (!224 !225 !111 !112) +!242 = (!224 !225 !111 !112 !139) +!243 = (!224 !225 !141) +!244 = (!224 !225 !143) +!245 = span !0 938 992 +!246 = span !0 1028 1035 +!247 = span !0 1028 1041 +!248 = fn_call_path_span !0 1036 1039 +!249 = (!247 !248) +!250 = (!247 !248 !69) +!251 = (!247 !248 !71 !72) +!252 = (!247 !248 !71 !72 !74) +!253 = (!247 !248 !76) +!254 = span !0 1043 1050 +!255 = span !0 1013 1063 +!256 = span !0 1070 1082 +!257 = span !0 1086 1099 +!258 = span !0 1070 1099 +!259 = span !0 1127 1134 +!260 = span !0 1127 1159 +!261 = fn_call_path_span !0 1135 1141 +!262 = (!260 !261 !90 !91 !92) +!263 = (!260 !261 !90 !91 !92) +!264 = span !0 1102 1160 +!265 = span !0 1235 1239 +!266 = span !0 1240 1241 +!267 = span !0 1206 1242 +!268 = fn_call_path_span !0 1206 1234 +!269 = (!267 !268) +!270 = span !101 4458 4459 +!271 = (!267 !268 !270) +!272 = span !0 1181 1243 +!273 = span !0 1289 1296 +!274 = span !0 1269 1297 +!275 = fn_call_path_span !0 1269 1275 +!276 = (!274 !275) +!277 = (!274 !275 !109) +!278 = (!274 !275 !111 !112) +!279 = (!274 !275 !111 !112) +!280 = (!274 !275 !111 !112 !115) +!281 = (!274 !275 !111 !112 !117) +!282 = (!274 !275 !111 !112) +!283 = (!274 !275 !111 !112 !121 !122) +!284 = (!274 !275 !111 !112) +!285 = (!274 !275 !111 !112 !125) +!286 = (!274 !275 !111 !112 !127) +!287 = (!274 !275 !111 !112) +!288 = (!274 !275 !111 !112 !130) +!289 = (!274 !275 !111 !112 !132) +!290 = (!274 !275 !111 !112 !135 !136) +!291 = (!274 !275 !111 !112) +!292 = (!274 !275 !111 !112 !139) +!293 = (!274 !275 !141) +!294 = (!274 !275 !143) +!295 = span !0 1244 1298 +!296 = span !0 1334 1341 +!297 = span !0 1334 1347 +!298 = fn_call_path_span !0 1342 1345 +!299 = (!297 !298) +!300 = (!297 !298 !69) +!301 = (!297 !298 !71 !72) +!302 = (!297 !298 !71 !72 !74) +!303 = (!297 !298 !76) +!304 = span !0 1349 1356 +!305 = span !0 1319 1369 +!306 = span !0 1376 1388 +!307 = span !0 1392 1405 +!308 = span !0 1376 1405 +!309 = span !0 1433 1440 +!310 = span !0 1433 1465 +!311 = fn_call_path_span !0 1441 1447 +!312 = (!310 !311 !90 !91 !92) +!313 = (!310 !311 !90 !91 !92) +!314 = span !0 1408 1466 +!315 = span !0 1541 1545 +!316 = span !0 1546 1547 +!317 = span !0 1512 1548 +!318 = fn_call_path_span !0 1512 1540 +!319 = (!317 !318) +!320 = span !101 4557 4558 +!321 = (!317 !318 !320) +!322 = span !0 1487 1549 +!323 = span !0 1595 1602 +!324 = span !0 1575 1603 +!325 = fn_call_path_span !0 1575 1581 +!326 = (!324 !325) +!327 = (!324 !325 !109) +!328 = (!324 !325 !111 !112) +!329 = (!324 !325 !111 !112) +!330 = (!324 !325 !111 !112 !115) +!331 = (!324 !325 !111 !112 !117) +!332 = (!324 !325 !111 !112) +!333 = (!324 !325 !111 !112 !121 !122) +!334 = (!324 !325 !111 !112) +!335 = (!324 !325 !111 !112 !125) +!336 = (!324 !325 !111 !112 !127) +!337 = (!324 !325 !111 !112) +!338 = (!324 !325 !111 !112 !130) +!339 = (!324 !325 !111 !112 !132) +!340 = (!324 !325 !111 !112 !135 !136) +!341 = (!324 !325 !111 !112) +!342 = (!324 !325 !111 !112 !139) +!343 = (!324 !325 !141) +!344 = (!324 !325 !143) +!345 = span !0 1550 1604 +!346 = span !0 1640 1647 +!347 = span !0 1640 1653 +!348 = fn_call_path_span !0 1648 1651 +!349 = (!347 !348) +!350 = (!347 !348 !69) +!351 = (!347 !348 !71 !72) +!352 = (!347 !348 !71 !72 !74) +!353 = (!347 !348 !76) +!354 = span !0 1655 1662 +!355 = span !0 1625 1675 +!356 = span !0 1682 1694 +!357 = span !0 1698 1710 +!358 = span !0 1682 1710 +!359 = span !0 1737 1744 +!360 = span !0 1737 1768 +!361 = fn_call_path_span !0 1745 1751 +!362 = (!360 !361 !90 !91 !92) +!363 = (!360 !361 !90 !91 !92) +!364 = span !0 1713 1769 +!365 = span !0 1842 1846 +!366 = span !0 1847 1848 +!367 = span !0 1814 1849 +!368 = fn_call_path_span !0 1814 1841 +!369 = (!367 !368) +!370 = span !101 4257 4258 +!371 = (!367 !368 !370) +!372 = span !101 4261 4262 +!373 = (!367 !368 !372) +!374 = span !0 1790 1850 +!375 = span !0 1895 1902 +!376 = span !0 1851 1904 +!377 = span !0 1940 1947 +!378 = span !0 1940 1953 +!379 = fn_call_path_span !0 1948 1951 +!380 = (!378 !379) +!381 = (!378 !379 !69) +!382 = (!378 !379 !71 !72) +!383 = (!378 !379 !71 !72 !74) +!384 = (!378 !379 !76) +!385 = span !0 1955 1962 +!386 = span !0 1925 1975 +!387 = span !0 1982 1994 +!388 = span !0 1998 2007 +!389 = span !0 1982 2007 +!390 = span !0 2030 2037 +!391 = span !0 2030 2057 +!392 = fn_call_path_span !0 2038 2044 +!393 = span !6 115442 115463 +!394 = fn_call_path_span !6 115442 115455 +!395 = span !6 71642 71672 +!396 = fn_call_path_span !6 71649 71662 +!397 = (!391 !392 !90 !91 !393 !394 !395 !396 !53) +!398 = (!391 !392 !90 !91 !393 !394 !395 !396) +!399 = span !6 2972 3030 +!400 = (!391 !392 !90 !91 !393 !394 !395 !396 !399) +!401 = (!391 !392 !90 !91 !393 !394 !395 !396) +!402 = (!391 !392 !90 !91 !393 !394 !395 !396) +!403 = (!391 !392 !90 !91 !393 !394 !395 !396) +!404 = span !6 3039 3079 +!405 = (!391 !392 !90 !91 !393 !394 !395 !396 !404) +!406 = span !6 3089 3090 +!407 = (!391 !392 !90 !91 !393 !394 !395 !396 !406) +!408 = (!391 !392 !90 !91 !92) +!409 = (!391 !392 !90 !91 !92) +!410 = span !0 2010 2058 +!411 = span !0 2124 2128 +!412 = span !0 2129 2130 +!413 = span !0 2099 2131 +!414 = fn_call_path_span !0 2099 2123 +!415 = (!413 !414) +!416 = span !101 3540 3541 +!417 = (!413 !414 !416) +!418 = span !0 2079 2132 +!419 = span !0 2173 2180 +!420 = span !0 2158 2181 +!421 = fn_call_path_span !0 2158 2164 +!422 = (!420 !421) +!423 = (!420 !421 !109) +!424 = (!420 !421 !111 !112) +!425 = (!420 !421 !111 !112) +!426 = span !6 4411 4417 +!427 = (!420 !421 !111 !112 !426) +!428 = span !6 87 114 +!429 = (!420 !421 !111 !112 !428) +!430 = (!420 !421 !111 !112) +!431 = (!420 !421 !111 !112) +!432 = (!420 !421 !111 !112) +!433 = (!420 !421 !111 !112) +!434 = (!420 !421 !111 !112) +!435 = (!420 !421 !111 !112) +!436 = (!420 !421 !111 !112) +!437 = span !6 4426 4430 +!438 = (!420 !421 !111 !112 !437) +!439 = (!420 !421 !111 !112) +!440 = (!420 !421 !111 !112) +!441 = (!420 !421 !111 !112) +!442 = (!420 !421 !111 !112) +!443 = (!420 !421 !111 !112) +!444 = (!420 !421 !111 !112) +!445 = (!420 !421 !111 !112) +!446 = (!420 !421 !111 !112) +!447 = (!420 !421 !111 !112) +!448 = (!420 !421 !111 !112) +!449 = (!420 !421 !111 !112) +!450 = (!420 !421 !111 !112) +!451 = (!420 !421 !111 !112) +!452 = (!420 !421 !111 !112) +!453 = span !6 4359 4442 +!454 = (!420 !421 !111 !112 !453) +!455 = (!420 !421 !111 !112) +!456 = (!420 !421 !141) +!457 = (!420 !421 !143) +!458 = span !0 2133 2182 +!459 = span !0 2218 2225 +!460 = span !0 2218 2231 +!461 = fn_call_path_span !0 2226 2229 +!462 = (!460 !461) +!463 = (!460 !461 !69) +!464 = (!460 !461 !71 !72) +!465 = (!460 !461 !71 !72 !74) +!466 = (!460 !461 !76) +!467 = span !0 2233 2240 +!468 = span !0 2203 2253 +!469 = (!420 !421 !111 !112) +!470 = (!420 !421 !111 !112) +!471 = (!420 !421 !111 !112) +!472 = (!420 !421 !111 !112) +!473 = span !0 2260 2272 +!474 = span !0 2276 2285 +!475 = span !0 2260 2285 +!476 = span !0 2308 2315 +!477 = span !0 2308 2335 +!478 = fn_call_path_span !0 2316 2322 +!479 = span !6 72847 72866 +!480 = fn_call_path_span !6 72854 72858 +!481 = (!477 !478 !90 !91 !393 !394 !479 !480) +!482 = span !6 72881 72882 +!483 = span !6 72881 72892 +!484 = fn_call_path_span !6 72881 72892 +!485 = (!477 !478 !90 !91 !393 !394 !483 !484) +!486 = span !6 72886 72891 +!487 = (!477 !478 !90 !91 !393 !394 !483) +!488 = span !6 72905 72906 +!489 = span !6 72905 72915 +!490 = fn_call_path_span !6 72905 72915 +!491 = (!477 !478 !90 !91 !393 !394 !489 !490) +!492 = span !6 72910 72914 +!493 = (!477 !478 !90 !91 !393 !394 !489) +!494 = span !6 72942 72943 +!495 = span !6 72933 72944 +!496 = (!477 !478 !90 !91 !393 !394 !495) +!497 = (!477 !478 !90 !91 !92) +!498 = (!477 !478 !90 !91 !92) +!499 = (!477 !478 !90 !91 !92) +!500 = span !0 2288 2336 +!501 = span !0 2402 2406 +!502 = span !0 2407 2408 +!503 = span !0 2436 2459 +!504 = fn_call_path_span !0 2436 2442 +!505 = (!503 !504 !111 !112) +!506 = span !6 4213 4219 +!507 = (!503 !504 !111 !112 !506) +!508 = (!503 !504 !111 !112 !428) +!509 = (!503 !504 !111 !112) +!510 = (!503 !504 !111 !112) +!511 = (!503 !504 !111 !112) +!512 = (!503 !504 !111 !112) +!513 = (!503 !504 !111 !112) +!514 = (!503 !504 !111 !112) +!515 = (!503 !504 !111 !112) +!516 = (!503 !504 !111 !112) +!517 = (!503 !504 !111 !112) +!518 = (!503 !504 !111 !112) +!519 = (!503 !504 !111 !112) +!520 = (!503 !504 !111 !112) +!521 = (!503 !504 !111 !112) +!522 = (!503 !504 !111 !112) +!523 = (!503 !504 !111 !112) +!524 = (!503 !504 !111 !112) +!525 = (!503 !504 !111 !112) +!526 = (!503 !504 !111 !112) +!527 = (!503 !504 !111 !112) +!528 = (!503 !504 !111 !112) +!529 = span !6 4161 4244 +!530 = (!503 !504 !111 !112 !529) +!531 = (!503 !504 !111 !112) +!532 = (!503 !504 !141) +!533 = (!503 !504 !143) +!534 = span !0 2411 2460 +!535 = span !0 2496 2503 +!536 = span !0 2496 2509 +!537 = fn_call_path_span !0 2504 2507 +!538 = (!536 !537) +!539 = (!536 !537 !69) +!540 = (!536 !537 !71 !72) +!541 = (!536 !537 !71 !72 !74) +!542 = (!536 !537 !76) +!543 = span !0 2511 2518 +!544 = span !0 2481 2531 +!545 = (!503 !504 !111 !112) +!546 = (!503 !504 !111 !112) +!547 = (!503 !504 !111 !112) +!548 = (!503 !504 !111 !112) +!549 = span !0 2538 2550 +!550 = span !0 2554 2567 +!551 = span !0 2538 2567 +!552 = span !0 2593 2600 +!553 = span !0 2593 2623 +!554 = fn_call_path_span !0 2601 2607 +!555 = span !0 245 267 +!556 = fn_call_path_span !0 252 258 +!557 = span !6 71904 71932 +!558 = fn_call_path_span !6 71911 71923 +!559 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558 !53) +!560 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558) +!561 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558 !56) +!562 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558 !59) +!563 = span !0 285 286 +!564 = span !0 285 318 +!565 = fn_call_path_span !0 285 318 +!566 = (!553 !554 !90 !91 !393 !394 !564 !565) +!567 = (!553 !554 !90 !91 !393 !394 !564) +!568 = span !101 274 293 +!569 = (!553 !554 !90 !91 !393 !394 !568) +!570 = (!553 !554 !90 !91 !393 !394 !568) +!571 = (!553 !554 !90 !91 !393 !394 !568) +!572 = span !0 296 316 +!573 = fn_call_path_span !0 303 309 +!574 = (!553 !554 !90 !91 !393 !394 !572 !573 !90 !91 !557 !558) +!575 = (!553 !554 !90 !91 !393 !394 !572 !573 !90 !91 !557 !558 !56) +!576 = (!553 !554 !90 !91 !393 !394 !572 !573 !90 !91 !557 !558 !59) +!577 = (!553 !554 !90 !91 !393 !394 !568) +!578 = (!553 !554 !90 !91 !393 !394 !568) +!579 = (!553 !554 !90 !91 !92) +!580 = (!553 !554 !90 !91 !92) +!581 = span !0 2570 2624 +!582 = span !0 2697 2701 +!583 = span !0 2702 2703 +!584 = span !0 2668 2704 +!585 = fn_call_path_span !0 2668 2696 +!586 = (!584 !585) +!587 = span !101 5528 5529 +!588 = (!584 !585 !587) +!589 = span !0 2645 2705 +!590 = span !0 2749 2756 +!591 = span !0 2731 2757 +!592 = fn_call_path_span !0 2731 2737 +!593 = (!591 !592) +!594 = (!591 !592 !109) +!595 = (!591 !592 !111 !112) +!596 = (!591 !592 !111 !112) +!597 = span !0 239 243 +!598 = (!591 !592 !111 !112 !597) +!599 = span !0 233 446 +!600 = (!591 !592 !111 !112 !599) +!601 = (!591 !592 !111 !112 !597) +!602 = (!591 !592 !111 !112 !597) +!603 = (!591 !592 !111 !112) +!604 = span !0 246 442 +!605 = fn_call_path_span !0 246 442 +!606 = (!591 !592 !111 !112 !604 !605) +!607 = (!591 !592 !111 !112 !604) +!608 = span !0 335 336 +!609 = span !0 326 337 +!610 = (!553 !554 !90 !91 !393 !394 !609) +!611 = (!591 !592 !111 !112 !597) +!612 = (!591 !592 !111 !112) +!613 = (!591 !592 !111 !112) +!614 = span !0 317 323 +!615 = (!591 !592 !111 !112 !614) +!616 = span !0 301 305 +!617 = span !0 288 325 +!618 = (!591 !592 !111 !112 !617) +!619 = span !0 380 386 +!620 = (!591 !592 !111 !112 !619) +!621 = span !0 350 388 +!622 = (!591 !592 !111 !112 !621) +!623 = span !0 413 419 +!624 = (!591 !592 !111 !112 !623) +!625 = span !0 220 447 +!626 = (!591 !592 !111 !112 !625) +!627 = span !0 468 474 +!628 = (!591 !592 !111 !112 !627) +!629 = (!591 !592 !141) +!630 = (!591 !592 !143) +!631 = span !0 2706 2758 +!632 = span !0 2794 2801 +!633 = span !0 2794 2807 +!634 = fn_call_path_span !0 2802 2805 +!635 = (!633 !634) +!636 = (!633 !634 !69) +!637 = (!633 !634 !71 !72) +!638 = (!633 !634 !71 !72 !74) +!639 = (!633 !634 !76) +!640 = span !0 2809 2816 +!641 = span !0 2779 2829 +!642 = (!591 !592 !111 !112 !599) +!643 = span !0 2836 2848 +!644 = span !0 2852 2869 +!645 = span !0 2836 2869 +!646 = span !0 2900 2907 +!647 = span !0 2900 2935 +!648 = fn_call_path_span !0 2908 2914 +!649 = span !0 265 287 +!650 = fn_call_path_span !0 272 278 +!651 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558 !53) +!652 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558) +!653 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558 !56) +!654 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558 !59) +!655 = span !0 305 306 +!656 = span !0 305 338 +!657 = fn_call_path_span !0 305 338 +!658 = (!647 !648 !90 !91 !393 !394 !656 !657) +!659 = (!647 !648 !90 !91 !393 !394 !656) +!660 = span !101 294 322 +!661 = (!647 !648 !90 !91 !393 !394 !660) +!662 = (!647 !648 !90 !91 !393 !394 !660) +!663 = (!647 !648 !90 !91 !393 !394 !660) +!664 = span !0 316 336 +!665 = fn_call_path_span !0 323 329 +!666 = (!647 !648 !90 !91 !393 !394 !664 !665 !90 !91 !557 !558) +!667 = (!647 !648 !90 !91 !393 !394 !664 !665 !90 !91 !557 !558 !56) +!668 = (!647 !648 !90 !91 !393 !394 !664 !665 !90 !91 !557 !558 !59) +!669 = (!647 !648 !90 !91 !393 !394 !660) +!670 = (!647 !648 !90 !91 !393 !394 !660) +!671 = (!647 !648 !90 !91 !393 !394) +!672 = span !0 340 341 +!673 = span !0 340 373 +!674 = fn_call_path_span !0 340 373 +!675 = (!647 !648 !90 !91 !393 !394 !673 !674) +!676 = (!647 !648 !90 !91 !393 !394 !673) +!677 = (!647 !648 !90 !91 !393 !394 !660) +!678 = (!647 !648 !90 !91 !393 !394 !660) +!679 = (!647 !648 !90 !91 !393 !394 !660) +!680 = span !0 351 371 +!681 = (!647 !648 !90 !91 !393 !394 !680 !107 !90 !91 !557 !558) +!682 = (!647 !648 !90 !91 !393 !394 !680 !107 !90 !91 !557 !558 !56) +!683 = (!647 !648 !90 !91 !393 !394 !680 !107 !90 !91 !557 !558 !59) +!684 = (!647 !648 !90 !91 !393 !394 !660) +!685 = (!647 !648 !90 !91 !393 !394 !660) +!686 = (!647 !648 !90 !91 !393 !394) +!687 = span !0 390 391 +!688 = span !0 381 392 +!689 = (!647 !648 !90 !91 !393 !394 !688) +!690 = (!647 !648 !90 !91 !92) +!691 = (!647 !648 !90 !91 !92) +!692 = span !0 2872 2936 +!693 = span !0 3018 3022 +!694 = span !0 3023 3024 +!695 = span !0 2985 3025 +!696 = fn_call_path_span !0 2985 3017 +!697 = (!695 !696) +!698 = span !101 5643 5644 +!699 = (!695 !696 !698) +!700 = span !0 2957 3026 +!701 = span !0 3075 3082 +!702 = span !0 3052 3083 +!703 = fn_call_path_span !0 3052 3058 +!704 = (!702 !703) +!705 = (!702 !703 !109) +!706 = (!702 !703 !111 !112) +!707 = (!702 !703 !111 !112) +!708 = span !0 259 263 +!709 = (!702 !703 !111 !112 !708) +!710 = span !0 253 664 +!711 = (!702 !703 !111 !112 !710) +!712 = (!702 !703 !111 !112 !708) +!713 = (!702 !703 !111 !112 !708) +!714 = (!702 !703 !111 !112) +!715 = span !0 266 462 +!716 = fn_call_path_span !0 266 462 +!717 = (!702 !703 !111 !112 !715 !716) +!718 = (!702 !703 !111 !112 !715) +!719 = (!702 !703 !111 !112 !708) +!720 = (!702 !703 !111 !112) +!721 = (!702 !703 !111 !112) +!722 = span !0 337 343 +!723 = (!702 !703 !111 !112 !722) +!724 = span !0 321 325 +!725 = span !0 308 345 +!726 = (!702 !703 !111 !112 !725) +!727 = span !0 400 406 +!728 = (!702 !703 !111 !112 !727) +!729 = span !0 370 408 +!730 = (!702 !703 !111 !112 !729) +!731 = span !0 433 439 +!732 = (!702 !703 !111 !112 !731) +!733 = (!702 !703 !111 !112) +!734 = (!702 !703 !111 !112 !708) +!735 = (!702 !703 !111 !112 !708) +!736 = (!702 !703 !111 !112) +!737 = span !0 464 660 +!738 = fn_call_path_span !0 464 660 +!739 = (!702 !703 !111 !112 !737 !738) +!740 = (!702 !703 !111 !112 !737) +!741 = (!702 !703 !111 !112 !708) +!742 = (!702 !703 !111 !112) +!743 = (!702 !703 !111 !112) +!744 = span !0 535 541 +!745 = (!702 !703 !111 !112 !744) +!746 = span !0 519 523 +!747 = span !0 506 543 +!748 = (!702 !703 !111 !112 !747) +!749 = span !0 598 604 +!750 = (!702 !703 !111 !112 !749) +!751 = span !0 568 606 +!752 = (!702 !703 !111 !112 !751) +!753 = span !0 631 637 +!754 = (!702 !703 !111 !112 !753) +!755 = (!702 !703 !111 !112) +!756 = (!702 !703 !111 !112 !710) +!757 = span !0 240 665 +!758 = (!702 !703 !111 !112 !757) +!759 = span !0 686 692 +!760 = (!702 !703 !111 !112 !759) +!761 = (!702 !703 !141) +!762 = (!702 !703 !143) +!763 = span !0 3027 3084 +!764 = span !0 3120 3127 +!765 = span !0 3120 3133 +!766 = fn_call_path_span !0 3128 3131 +!767 = (!765 !766) +!768 = (!765 !766 !69) +!769 = (!765 !766 !71 !72) +!770 = (!765 !766 !71 !72 !74) +!771 = (!765 !766 !76) +!772 = span !0 3135 3142 +!773 = span !0 3105 3155 +!774 = span !0 3162 3174 +!775 = span !0 3178 3199 +!776 = span !0 3162 3199 +!777 = span !0 3235 3242 +!778 = span !0 3235 3275 +!779 = fn_call_path_span !0 3243 3249 +!780 = span !0 285 307 +!781 = fn_call_path_span !0 292 298 +!782 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558 !53) +!783 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558) +!784 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558 !56) +!785 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558 !59) +!786 = span !0 325 326 +!787 = span !0 325 358 +!788 = fn_call_path_span !0 325 358 +!789 = (!778 !779 !90 !91 !393 !394 !787 !788) +!790 = (!778 !779 !90 !91 !393 !394 !787) +!791 = span !101 323 360 +!792 = (!778 !779 !90 !91 !393 !394 !791) +!793 = (!778 !779 !90 !91 !393 !394 !791) +!794 = (!778 !779 !90 !91 !393 !394 !791) +!795 = span !0 336 356 +!796 = fn_call_path_span !0 343 349 +!797 = (!778 !779 !90 !91 !393 !394 !795 !796 !90 !91 !557 !558) +!798 = (!778 !779 !90 !91 !393 !394 !795 !796 !90 !91 !557 !558 !56) +!799 = (!778 !779 !90 !91 !393 !394 !795 !796 !90 !91 !557 !558 !59) +!800 = (!778 !779 !90 !91 !393 !394 !791) +!801 = (!778 !779 !90 !91 !393 !394 !791) +!802 = (!778 !779 !90 !91 !393 !394) +!803 = span !0 360 361 +!804 = span !0 360 393 +!805 = fn_call_path_span !0 360 393 +!806 = (!778 !779 !90 !91 !393 !394 !804 !805) +!807 = (!778 !779 !90 !91 !393 !394 !804) +!808 = (!778 !779 !90 !91 !393 !394 !791) +!809 = (!778 !779 !90 !91 !393 !394 !791) +!810 = (!778 !779 !90 !91 !393 !394 !791) +!811 = span !0 371 391 +!812 = fn_call_path_span !0 378 384 +!813 = (!778 !779 !90 !91 !393 !394 !811 !812 !90 !91 !557 !558) +!814 = (!778 !779 !90 !91 !393 !394 !811 !812 !90 !91 !557 !558 !56) +!815 = (!778 !779 !90 !91 !393 !394 !811 !812 !90 !91 !557 !558 !59) +!816 = (!778 !779 !90 !91 !393 !394 !791) +!817 = (!778 !779 !90 !91 !393 !394 !791) +!818 = (!778 !779 !90 !91 !393 !394) +!819 = span !0 395 396 +!820 = span !0 395 428 +!821 = fn_call_path_span !0 395 428 +!822 = (!778 !779 !90 !91 !393 !394 !820 !821) +!823 = (!778 !779 !90 !91 !393 !394 !820) +!824 = (!778 !779 !90 !91 !393 !394 !791) +!825 = (!778 !779 !90 !91 !393 !394 !791) +!826 = (!778 !779 !90 !91 !393 !394 !791) +!827 = span !0 406 426 +!828 = fn_call_path_span !0 413 419 +!829 = (!778 !779 !90 !91 !393 !394 !827 !828 !90 !91 !557 !558) +!830 = (!778 !779 !90 !91 !393 !394 !827 !828 !90 !91 !557 !558 !56) +!831 = (!778 !779 !90 !91 !393 !394 !827 !828 !90 !91 !557 !558 !59) +!832 = (!778 !779 !90 !91 !393 !394 !791) +!833 = (!778 !779 !90 !91 !393 !394 !791) +!834 = (!778 !779 !90 !91 !393 !394) +!835 = span !0 445 446 +!836 = span !0 436 447 +!837 = (!778 !779 !90 !91 !393 !394 !836) +!838 = (!778 !779 !90 !91 !393 !394) +!839 = (!778 !779 !90 !91 !92) +!840 = (!778 !779 !90 !91 !92) +!841 = span !0 3202 3276 +!842 = span !0 3367 3371 +!843 = span !0 3372 3373 +!844 = span !0 3330 3374 +!845 = fn_call_path_span !0 3330 3366 +!846 = (!844 !845) +!847 = span !101 5780 5781 +!848 = (!844 !845 !847) +!849 = span !0 3297 3375 +!850 = span !0 3429 3436 +!851 = span !0 3401 3437 +!852 = fn_call_path_span !0 3401 3407 +!853 = (!851 !852) +!854 = (!851 !852 !109) +!855 = (!851 !852 !111 !112) +!856 = (!851 !852 !111 !112) +!857 = span !0 279 283 +!858 = (!851 !852 !111 !112 !857) +!859 = span !0 273 882 +!860 = (!851 !852 !111 !112 !859) +!861 = (!851 !852 !111 !112 !857) +!862 = (!851 !852 !111 !112 !857) +!863 = (!851 !852 !111 !112) +!864 = span !0 286 482 +!865 = fn_call_path_span !0 286 482 +!866 = (!851 !852 !111 !112 !864 !865) +!867 = (!851 !852 !111 !112 !864) +!868 = (!851 !852 !111 !112 !857) +!869 = (!851 !852 !111 !112) +!870 = (!851 !852 !111 !112) +!871 = span !0 357 363 +!872 = (!851 !852 !111 !112 !871) +!873 = span !0 341 345 +!874 = span !0 328 365 +!875 = (!851 !852 !111 !112 !874) +!876 = span !0 420 426 +!877 = (!851 !852 !111 !112 !876) +!878 = span !0 390 428 +!879 = (!851 !852 !111 !112 !878) +!880 = span !0 453 459 +!881 = (!851 !852 !111 !112 !880) +!882 = (!851 !852 !111 !112) +!883 = (!851 !852 !111 !112 !857) +!884 = (!851 !852 !111 !112 !857) +!885 = (!851 !852 !111 !112) +!886 = span !0 484 680 +!887 = fn_call_path_span !0 484 680 +!888 = (!851 !852 !111 !112 !886 !887) +!889 = (!851 !852 !111 !112 !886) +!890 = (!851 !852 !111 !112 !857) +!891 = (!851 !852 !111 !112) +!892 = (!851 !852 !111 !112) +!893 = span !0 555 561 +!894 = (!851 !852 !111 !112 !893) +!895 = span !0 539 543 +!896 = span !0 526 563 +!897 = (!851 !852 !111 !112 !896) +!898 = span !0 618 624 +!899 = (!851 !852 !111 !112 !898) +!900 = span !0 588 626 +!901 = (!851 !852 !111 !112 !900) +!902 = span !0 651 657 +!903 = (!851 !852 !111 !112 !902) +!904 = (!851 !852 !111 !112) +!905 = (!851 !852 !111 !112 !857) +!906 = (!851 !852 !111 !112 !857) +!907 = (!851 !852 !111 !112) +!908 = span !0 682 878 +!909 = fn_call_path_span !0 682 878 +!910 = (!851 !852 !111 !112 !908 !909) +!911 = (!851 !852 !111 !112 !908) +!912 = (!851 !852 !111 !112 !857) +!913 = (!851 !852 !111 !112) +!914 = (!851 !852 !111 !112) +!915 = span !0 753 759 +!916 = (!851 !852 !111 !112 !915) +!917 = span !0 737 741 +!918 = span !0 724 761 +!919 = (!851 !852 !111 !112 !918) +!920 = span !0 816 822 +!921 = (!851 !852 !111 !112 !920) +!922 = span !0 786 824 +!923 = (!851 !852 !111 !112 !922) +!924 = span !0 849 855 +!925 = (!851 !852 !111 !112 !924) +!926 = (!851 !852 !111 !112) +!927 = (!851 !852 !111 !112 !859) +!928 = (!851 !852 !111 !112) +!929 = span !0 260 883 +!930 = (!851 !852 !111 !112 !929) +!931 = span !0 904 910 +!932 = (!851 !852 !111 !112 !931) +!933 = (!851 !852 !141) +!934 = (!851 !852 !143) +!935 = span !0 3376 3438 +!936 = span !0 3474 3481 +!937 = span !0 3474 3487 +!938 = fn_call_path_span !0 3482 3485 +!939 = (!937 !938) +!940 = (!937 !938 !69) +!941 = (!937 !938 !71 !72) +!942 = (!937 !938 !71 !72 !74) +!943 = (!937 !938 !76) +!944 = span !0 3489 3496 +!945 = span !0 3459 3509 +!946 = span !0 3516 3528 +!947 = span !0 3532 3542 +!948 = span !0 3516 3542 +!949 = span !0 3567 3574 +!950 = span !0 3567 3596 +!951 = fn_call_path_span !0 3575 3581 +!952 = span !6 73547 73579 +!953 = (!950 !951 !90 !91 !393 !394 !952) +!954 = span !6 73595 73599 +!955 = (!950 !951 !90 !91 !393 !394 !954) +!956 = span !6 73595 73605 +!957 = fn_call_path_span !6 73600 73603 +!958 = (!950 !951 !90 !91 !393 !394 !956 !957) +!959 = (!950 !951 !90 !91 !393 !394 !956 !957 !69) +!960 = (!950 !951 !90 !91 !393 !394 !956 !957 !71 !72) +!961 = (!950 !951 !90 !91 !393 !394 !956 !957 !71 !72 !74) +!962 = (!950 !951 !90 !91 !393 !394 !956 !957 !76) +!963 = (!950 !951 !90 !91 !92) +!964 = (!950 !951 !90 !91 !92) +!965 = span !0 3545 3597 +!966 = span !0 3666 3670 +!967 = span !0 3671 3672 +!968 = span !0 3640 3673 +!969 = fn_call_path_span !0 3640 3665 +!970 = (!968 !969) +!971 = span !101 3624 3625 +!972 = (!968 !969 !971) +!973 = span !0 3618 3674 +!974 = span !0 3717 3724 +!975 = span !0 3700 3725 +!976 = fn_call_path_span !0 3700 3706 +!977 = (!975 !976) +!978 = (!975 !976 !109) +!979 = (!975 !976 !111 !112) +!980 = (!975 !976 !111 !112) +!981 = span !6 5753 5759 +!982 = (!975 !976 !111 !112 !981) +!983 = (!975 !976 !111 !112 !428) +!984 = (!975 !976 !111 !112) +!985 = (!975 !976 !111 !112) +!986 = (!975 !976 !111 !112) +!987 = (!975 !976 !111 !112) +!988 = (!975 !976 !111 !112) +!989 = (!975 !976 !111 !112) +!990 = (!975 !976 !111 !112) +!991 = span !6 5768 5772 +!992 = (!975 !976 !111 !112 !991) +!993 = (!975 !976 !111 !112) +!994 = (!975 !976 !111 !112) +!995 = (!975 !976 !111 !112) +!996 = (!975 !976 !111 !112) +!997 = (!975 !976 !111 !112) +!998 = (!975 !976 !111 !112) +!999 = (!975 !976 !111 !112) +!1000 = (!975 !976 !111 !112) +!1001 = (!975 !976 !111 !112) +!1002 = (!975 !976 !111 !112) +!1003 = (!975 !976 !111 !112) +!1004 = (!975 !976 !111 !112) +!1005 = (!975 !976 !111 !112) +!1006 = span !6 5701 5784 +!1007 = (!975 !976 !111 !112 !1006) +!1008 = (!975 !976 !111 !112) +!1009 = (!975 !976 !141) +!1010 = (!975 !976 !143) +!1011 = span !0 3675 3726 +!1012 = span !0 3762 3769 +!1013 = span !0 3762 3775 +!1014 = fn_call_path_span !0 3770 3773 +!1015 = (!1013 !1014) +!1016 = (!1013 !1014 !69) +!1017 = (!1013 !1014 !71 !72) +!1018 = (!1013 !1014 !71 !72 !74) +!1019 = (!1013 !1014 !76) +!1020 = span !0 3777 3784 +!1021 = span !0 3747 3797 +!1022 = (!975 !976 !111 !112) +!1023 = (!975 !976 !111 !112) +!1024 = (!975 !976 !111 !112) +!1025 = span !0 3804 3816 +!1026 = span !0 3820 3830 +!1027 = span !0 3804 3830 +!1028 = span !0 3855 3862 +!1029 = span !0 3855 3884 +!1030 = fn_call_path_span !0 3863 3869 +!1031 = (!1029 !1030 !90 !91 !393 !394 !952) +!1032 = (!1029 !1030 !90 !91 !393 !394 !954) +!1033 = (!1029 !1030 !90 !91 !393 !394 !956 !957) +!1034 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !69) +!1035 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !71 !72) +!1036 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !71 !72 !74) +!1037 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !76) +!1038 = (!1029 !1030 !90 !91 !92) +!1039 = (!1029 !1030 !90 !91 !92) +!1040 = span !0 3833 3885 +!1041 = span !0 3954 3958 +!1042 = span !0 3959 3960 +!1043 = span !0 3928 3961 +!1044 = fn_call_path_span !0 3928 3953 +!1045 = (!1043 !1044) +!1046 = span !101 3708 3709 +!1047 = (!1043 !1044 !1046) +!1048 = span !0 3906 3962 +!1049 = span !0 4005 4012 +!1050 = span !0 3988 4013 +!1051 = fn_call_path_span !0 3988 3994 +!1052 = (!1050 !1051) +!1053 = (!1050 !1051 !109) +!1054 = (!1050 !1051 !111 !112) +!1055 = (!1050 !1051 !111 !112) +!1056 = (!1050 !1051 !111 !112 !981) +!1057 = (!1050 !1051 !111 !112 !428) +!1058 = (!1050 !1051 !111 !112) +!1059 = (!1050 !1051 !111 !112) +!1060 = (!1050 !1051 !111 !112) +!1061 = (!1050 !1051 !111 !112) +!1062 = (!1050 !1051 !111 !112) +!1063 = (!1050 !1051 !111 !112) +!1064 = (!1050 !1051 !111 !112) +!1065 = (!1050 !1051 !111 !112 !991) +!1066 = (!1050 !1051 !111 !112) +!1067 = (!1050 !1051 !111 !112) +!1068 = (!1050 !1051 !111 !112) +!1069 = (!1050 !1051 !111 !112) +!1070 = (!1050 !1051 !111 !112) +!1071 = (!1050 !1051 !111 !112) +!1072 = (!1050 !1051 !111 !112) +!1073 = (!1050 !1051 !111 !112) +!1074 = (!1050 !1051 !111 !112) +!1075 = (!1050 !1051 !111 !112) +!1076 = (!1050 !1051 !111 !112) +!1077 = (!1050 !1051 !111 !112) +!1078 = (!1050 !1051 !111 !112) +!1079 = (!1050 !1051 !111 !112) +!1080 = (!1050 !1051 !111 !112 !1006) +!1081 = (!1050 !1051 !111 !112) +!1082 = (!1050 !1051 !141) +!1083 = (!1050 !1051 !143) +!1084 = span !0 3963 4014 +!1085 = span !0 4050 4057 +!1086 = span !0 4050 4063 +!1087 = fn_call_path_span !0 4058 4061 +!1088 = (!1086 !1087) +!1089 = (!1086 !1087 !69) +!1090 = (!1086 !1087 !71 !72) +!1091 = (!1086 !1087 !71 !72 !74) +!1092 = (!1086 !1087 !76) +!1093 = span !0 4065 4072 +!1094 = span !0 4035 4085 +!1095 = (!1050 !1051 !111 !112) +!1096 = (!1050 !1051 !111 !112) +!1097 = (!1050 !1051 !111 !112) +!1098 = (!1050 !1051 !111 !112) +!1099 = span !0 4092 4104 +!1100 = span !0 4108 4119 +!1101 = span !0 4092 4119 +!1102 = span !0 4145 4152 +!1103 = span !0 4145 4175 +!1104 = fn_call_path_span !0 4153 4159 +!1105 = (!1103 !1104 !90 !91 !393 !394 !952) +!1106 = (!1103 !1104 !90 !91 !393 !394 !954) +!1107 = (!1103 !1104 !90 !91 !393 !394 !956 !957) +!1108 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !69) +!1109 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !71 !72) +!1110 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !71 !72 !74) +!1111 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !76) +!1112 = (!1103 !1104 !90 !91 !92) +!1113 = (!1103 !1104 !90 !91 !92) +!1114 = span !0 4122 4176 +!1115 = span !0 4247 4251 +!1116 = span !0 4252 4253 +!1117 = span !0 4220 4254 +!1118 = fn_call_path_span !0 4220 4246 +!1119 = (!1117 !1118) +!1120 = span !101 3880 3881 +!1121 = (!1117 !1118 !1120) +!1122 = span !0 4197 4255 +!1123 = span !0 4299 4306 +!1124 = span !0 4281 4307 +!1125 = fn_call_path_span !0 4281 4287 +!1126 = (!1124 !1125) +!1127 = (!1124 !1125 !109) +!1128 = (!1124 !1125 !111 !112) +!1129 = (!1124 !1125 !111 !112) +!1130 = (!1124 !1125 !111 !112 !981) +!1131 = (!1124 !1125 !111 !112 !428) +!1132 = (!1124 !1125 !111 !112) +!1133 = (!1124 !1125 !111 !112) +!1134 = (!1124 !1125 !111 !112) +!1135 = (!1124 !1125 !111 !112) +!1136 = (!1124 !1125 !111 !112) +!1137 = (!1124 !1125 !111 !112) +!1138 = (!1124 !1125 !111 !112) +!1139 = (!1124 !1125 !111 !112 !991) +!1140 = (!1124 !1125 !111 !112) +!1141 = (!1124 !1125 !111 !112) +!1142 = (!1124 !1125 !111 !112) +!1143 = (!1124 !1125 !111 !112) +!1144 = (!1124 !1125 !111 !112) +!1145 = (!1124 !1125 !111 !112) +!1146 = (!1124 !1125 !111 !112) +!1147 = (!1124 !1125 !111 !112) +!1148 = (!1124 !1125 !111 !112) +!1149 = (!1124 !1125 !111 !112) +!1150 = (!1124 !1125 !111 !112) +!1151 = (!1124 !1125 !111 !112) +!1152 = (!1124 !1125 !111 !112) +!1153 = (!1124 !1125 !111 !112) +!1154 = (!1124 !1125 !111 !112 !1006) +!1155 = (!1124 !1125 !111 !112) +!1156 = (!1124 !1125 !141) +!1157 = (!1124 !1125 !143) +!1158 = span !0 4256 4308 +!1159 = span !0 4344 4351 +!1160 = span !0 4344 4357 +!1161 = fn_call_path_span !0 4352 4355 +!1162 = (!1160 !1161) +!1163 = (!1160 !1161 !69) +!1164 = (!1160 !1161 !71 !72) +!1165 = (!1160 !1161 !71 !72 !74) +!1166 = (!1160 !1161 !76) +!1167 = span !0 4359 4366 +!1168 = span !0 4329 4379 +!1169 = (!1124 !1125 !111 !112) +!1170 = (!1124 !1125 !111 !112) +!1171 = (!1124 !1125 !111 !112) +!1172 = (!1124 !1125 !111 !112) +!1173 = span !0 4386 4398 +!1174 = span !0 4402 4413 +!1175 = span !0 4386 4413 +!1176 = span !0 4439 4446 +!1177 = span !0 4439 4469 +!1178 = fn_call_path_span !0 4447 4453 +!1179 = (!1177 !1178 !90 !91 !393 !394 !952) +!1180 = (!1177 !1178 !90 !91 !393 !394 !954) +!1181 = (!1177 !1178 !90 !91 !393 !394 !956 !957) +!1182 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !69) +!1183 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !71 !72) +!1184 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !71 !72 !74) +!1185 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !76) +!1186 = (!1177 !1178 !90 !91 !92) +!1187 = (!1177 !1178 !90 !91 !92) +!1188 = span !0 4416 4470 +!1189 = span !0 4541 4545 +!1190 = span !0 4546 4547 +!1191 = span !0 4514 4548 +!1192 = fn_call_path_span !0 4514 4540 +!1193 = (!1191 !1192) +!1194 = span !101 3969 3970 +!1195 = (!1191 !1192 !1194) +!1196 = span !0 4491 4549 +!1197 = span !0 4593 4600 +!1198 = span !0 4575 4601 +!1199 = fn_call_path_span !0 4575 4581 +!1200 = (!1198 !1199) +!1201 = (!1198 !1199 !109) +!1202 = (!1198 !1199 !111 !112) +!1203 = (!1198 !1199 !111 !112) +!1204 = (!1198 !1199 !111 !112 !981) +!1205 = (!1198 !1199 !111 !112 !428) +!1206 = (!1198 !1199 !111 !112) +!1207 = (!1198 !1199 !111 !112) +!1208 = (!1198 !1199 !111 !112) +!1209 = (!1198 !1199 !111 !112) +!1210 = (!1198 !1199 !111 !112) +!1211 = (!1198 !1199 !111 !112) +!1212 = (!1198 !1199 !111 !112) +!1213 = (!1198 !1199 !111 !112 !991) +!1214 = (!1198 !1199 !111 !112) +!1215 = (!1198 !1199 !111 !112) +!1216 = (!1198 !1199 !111 !112) +!1217 = (!1198 !1199 !111 !112) +!1218 = (!1198 !1199 !111 !112) +!1219 = (!1198 !1199 !111 !112) +!1220 = (!1198 !1199 !111 !112) +!1221 = (!1198 !1199 !111 !112) +!1222 = (!1198 !1199 !111 !112) +!1223 = (!1198 !1199 !111 !112) +!1224 = (!1198 !1199 !111 !112) +!1225 = (!1198 !1199 !111 !112) +!1226 = (!1198 !1199 !111 !112) +!1227 = (!1198 !1199 !111 !112) +!1228 = (!1198 !1199 !111 !112 !1006) +!1229 = (!1198 !1199 !111 !112) +!1230 = (!1198 !1199 !141) +!1231 = (!1198 !1199 !143) +!1232 = span !0 4550 4602 +!1233 = span !0 4638 4645 +!1234 = span !0 4638 4651 +!1235 = fn_call_path_span !0 4646 4649 +!1236 = (!1234 !1235) +!1237 = (!1234 !1235 !69) +!1238 = (!1234 !1235 !71 !72) +!1239 = (!1234 !1235 !71 !72 !74) +!1240 = (!1234 !1235 !76) +!1241 = span !0 4653 4660 +!1242 = span !0 4623 4673 +!1243 = (!1198 !1199 !111 !112) +!1244 = (!1198 !1199 !111 !112) +!1245 = (!1198 !1199 !111 !112) +!1246 = (!1198 !1199 !111 !112) +!1247 = span !0 4680 4692 +!1248 = span !0 4696 4706 +!1249 = span !0 4680 4706 +!1250 = span !0 4731 4738 +!1251 = span !0 4731 4760 +!1252 = fn_call_path_span !0 4739 4745 +!1253 = (!1251 !1252 !90 !91 !393 !394 !952) +!1254 = (!1251 !1252 !90 !91 !393 !394 !954) +!1255 = (!1251 !1252 !90 !91 !393 !394 !956 !957) +!1256 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !69) +!1257 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !71 !72) +!1258 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !71 !72 !74) +!1259 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !76) +!1260 = (!1251 !1252 !90 !91 !92) +!1261 = (!1251 !1252 !90 !91 !92) +!1262 = span !0 4709 4761 +!1263 = span !0 4830 4834 +!1264 = span !0 4835 4836 +!1265 = span !0 4804 4837 +!1266 = fn_call_path_span !0 4804 4829 +!1267 = (!1265 !1266) +!1268 = span !101 3792 3793 +!1269 = (!1265 !1266 !1268) +!1270 = span !0 4782 4838 +!1271 = span !0 4881 4888 +!1272 = span !0 4864 4889 +!1273 = fn_call_path_span !0 4864 4870 +!1274 = (!1272 !1273) +!1275 = (!1272 !1273 !109) +!1276 = (!1272 !1273 !111 !112) +!1277 = (!1272 !1273 !111 !112) +!1278 = (!1272 !1273 !111 !112 !981) +!1279 = (!1272 !1273 !111 !112 !428) +!1280 = (!1272 !1273 !111 !112) +!1281 = (!1272 !1273 !111 !112) +!1282 = (!1272 !1273 !111 !112) +!1283 = (!1272 !1273 !111 !112) +!1284 = (!1272 !1273 !111 !112) +!1285 = (!1272 !1273 !111 !112) +!1286 = (!1272 !1273 !111 !112) +!1287 = (!1272 !1273 !111 !112 !991) +!1288 = (!1272 !1273 !111 !112) +!1289 = (!1272 !1273 !111 !112) +!1290 = (!1272 !1273 !111 !112) +!1291 = (!1272 !1273 !111 !112) +!1292 = (!1272 !1273 !111 !112) +!1293 = (!1272 !1273 !111 !112) +!1294 = (!1272 !1273 !111 !112) +!1295 = (!1272 !1273 !111 !112) +!1296 = (!1272 !1273 !111 !112) +!1297 = (!1272 !1273 !111 !112) +!1298 = (!1272 !1273 !111 !112) +!1299 = (!1272 !1273 !111 !112) +!1300 = (!1272 !1273 !111 !112) +!1301 = (!1272 !1273 !111 !112) +!1302 = (!1272 !1273 !111 !112 !1006) +!1303 = (!1272 !1273 !111 !112) +!1304 = (!1272 !1273 !141) +!1305 = (!1272 !1273 !143) +!1306 = span !0 4839 4890 +!1307 = span !0 4926 4933 +!1308 = span !0 4926 4939 +!1309 = fn_call_path_span !0 4934 4937 +!1310 = (!1308 !1309) +!1311 = (!1308 !1309 !69) +!1312 = (!1308 !1309 !71 !72) +!1313 = (!1308 !1309 !71 !72 !74) +!1314 = (!1308 !1309 !76) +!1315 = span !0 4941 4948 +!1316 = span !0 4911 4961 +!1317 = (!1272 !1273 !111 !112) +!1318 = (!1272 !1273 !111 !112) +!1319 = (!1272 !1273 !111 !112) +!1320 = (!1272 !1273 !111 !112) +!1321 = span !0 4968 4980 +!1322 = span !0 4984 4999 +!1323 = span !0 4968 4999 +!1324 = span !0 5025 5032 +!1325 = span !0 5025 5055 +!1326 = fn_call_path_span !0 5033 5039 +!1327 = span !0 236 256 +!1328 = fn_call_path_span !0 243 249 +!1329 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558 !53) +!1330 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558) +!1331 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558 !56) +!1332 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558 !59) +!1333 = span !0 226 259 +!1334 = (!1325 !1326 !90 !91 !393 !394 !1333) +!1335 = (!1325 !1326 !90 !91 !393 !394) +!1336 = (!1325 !1326 !90 !91 !393 !394 !1333) +!1337 = (!1325 !1326 !90 !91 !92) +!1338 = (!1325 !1326 !90 !91 !92) +!1339 = span !0 5002 5056 +!1340 = span !0 5131 5135 +!1341 = span !0 5136 5137 +!1342 = span !0 5100 5138 +!1343 = fn_call_path_span !0 5100 5130 +!1344 = (!1342 !1343) +!1345 = span !101 4730 4731 +!1346 = (!1342 !1343 !1345) +!1347 = span !0 5077 5139 +!1348 = span !0 5183 5190 +!1349 = span !0 5140 5192 +!1350 = span !0 5228 5235 +!1351 = span !0 5228 5241 +!1352 = fn_call_path_span !0 5236 5239 +!1353 = (!1351 !1352) +!1354 = (!1351 !1352 !69) +!1355 = (!1351 !1352 !71 !72) +!1356 = (!1351 !1352 !71 !72 !74) +!1357 = (!1351 !1352 !76) +!1358 = span !0 5243 5250 +!1359 = span !0 5213 5263 +!1360 = span !0 5270 5282 +!1361 = span !0 5286 5305 +!1362 = span !0 5270 5305 +!1363 = span !0 5336 5343 +!1364 = span !0 5336 5371 +!1365 = fn_call_path_span !0 5344 5350 +!1366 = span !0 256 276 +!1367 = fn_call_path_span !0 263 269 +!1368 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558 !53) +!1369 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558) +!1370 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558 !56) +!1371 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558 !59) +!1372 = span !0 280 300 +!1373 = fn_call_path_span !0 287 293 +!1374 = (!1364 !1365 !90 !91 !393 !394 !1372 !1373 !90 !91 !557 !558) +!1375 = (!1364 !1365 !90 !91 !393 !394 !1372 !1373 !90 !91 !557 !558 !56) +!1376 = (!1364 !1365 !90 !91 !393 !394 !1372 !1373 !90 !91 !557 !558 !59) +!1377 = span !0 246 303 +!1378 = (!1364 !1365 !90 !91 !393 !394 !1377) +!1379 = (!1364 !1365 !90 !91 !393 !394) +!1380 = (!1364 !1365 !90 !91 !393 !394 !1377) +!1381 = (!1364 !1365 !90 !91 !393 !394) +!1382 = (!1364 !1365 !90 !91 !393 !394 !1377) +!1383 = (!1364 !1365 !90 !91 !92) +!1384 = (!1364 !1365 !90 !91 !92) +!1385 = span !0 5308 5372 +!1386 = span !0 5456 5460 +!1387 = span !0 5461 5462 +!1388 = span !0 5421 5463 +!1389 = fn_call_path_span !0 5421 5455 +!1390 = (!1388 !1389) +!1391 = span !101 5278 5279 +!1392 = (!1388 !1389 !1391) +!1393 = span !0 5393 5464 +!1394 = span !0 5513 5520 +!1395 = span !0 5465 5522 +!1396 = span !0 5558 5565 +!1397 = span !0 5558 5571 +!1398 = fn_call_path_span !0 5566 5569 +!1399 = (!1397 !1398) +!1400 = (!1397 !1398 !69) +!1401 = (!1397 !1398 !71 !72) +!1402 = (!1397 !1398 !71 !72 !74) +!1403 = (!1397 !1398 !76) +!1404 = span !0 5573 5580 +!1405 = span !0 5543 5593 +!1406 = span !0 5600 5612 +!1407 = span !0 5616 5639 +!1408 = span !0 5600 5639 +!1409 = span !0 5675 5682 +!1410 = span !0 5675 5715 +!1411 = fn_call_path_span !0 5683 5689 +!1412 = span !0 276 296 +!1413 = fn_call_path_span !0 283 289 +!1414 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558 !53) +!1415 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558) +!1416 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558 !56) +!1417 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558 !59) +!1418 = span !0 300 320 +!1419 = fn_call_path_span !0 307 313 +!1420 = (!1410 !1411 !90 !91 !393 !394 !1418 !1419 !90 !91 !557 !558) +!1421 = (!1410 !1411 !90 !91 !393 !394 !1418 !1419 !90 !91 !557 !558 !56) +!1422 = (!1410 !1411 !90 !91 !393 !394 !1418 !1419 !90 !91 !557 !558 !59) +!1423 = span !0 324 344 +!1424 = fn_call_path_span !0 331 337 +!1425 = (!1410 !1411 !90 !91 !393 !394 !1423 !1424 !90 !91 !557 !558) +!1426 = (!1410 !1411 !90 !91 !393 !394 !1423 !1424 !90 !91 !557 !558 !56) +!1427 = (!1410 !1411 !90 !91 !393 !394 !1423 !1424 !90 !91 !557 !558 !59) +!1428 = span !0 266 347 +!1429 = (!1410 !1411 !90 !91 !393 !394 !1428) +!1430 = (!1410 !1411 !90 !91 !393 !394) +!1431 = (!1410 !1411 !90 !91 !393 !394 !1428) +!1432 = (!1410 !1411 !90 !91 !393 !394) +!1433 = (!1410 !1411 !90 !91 !393 !394 !1428) +!1434 = (!1410 !1411 !90 !91 !393 !394) +!1435 = (!1410 !1411 !90 !91 !393 !394 !1428) +!1436 = (!1410 !1411 !90 !91 !92) +!1437 = (!1410 !1411 !90 !91 !92) +!1438 = span !0 5642 5716 +!1439 = span !0 5809 5813 +!1440 = span !0 5814 5815 +!1441 = span !0 5770 5816 +!1442 = fn_call_path_span !0 5770 5808 +!1443 = (!1441 !1442) +!1444 = span !101 4936 4937 +!1445 = (!1441 !1442 !1444) +!1446 = span !0 5737 5817 +!1447 = span !0 5871 5878 +!1448 = span !0 5818 5880 +!1449 = span !0 5916 5923 +!1450 = span !0 5916 5929 +!1451 = fn_call_path_span !0 5924 5927 +!1452 = (!1450 !1451) +!1453 = (!1450 !1451 !69) +!1454 = (!1450 !1451 !71 !72) +!1455 = (!1450 !1451 !71 !72 !74) +!1456 = (!1450 !1451 !76) +!1457 = span !0 5931 5938 +!1458 = span !0 5901 5951 +!1459 = span !0 5958 5970 +!1460 = span !0 5974 5986 +!1461 = span !0 5958 5986 +!1462 = span !0 6007 6032 +!1463 = fn_call_path_span !0 6015 6021 +!1464 = (!1462 !1463 !90 !91 !92) +!1465 = (!1462 !1463 !90 !91 !92) +!1466 = (!1462 !1463 !90 !91 !92) +!1467 = span !0 5989 6033 +!1468 = span !0 6124 6147 +!1469 = span !0 6149 6150 +!1470 = span !0 6109 6151 +!1471 = span !0 6158 6170 +!1472 = span !0 6174 6186 +!1473 = span !0 6158 6186 +!1474 = span !0 6211 6218 +!1475 = span !0 6211 6240 +!1476 = fn_call_path_span !0 6219 6225 +!1477 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558 !53) +!1478 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558) +!1479 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558 !56) +!1480 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558 !59) +!1481 = (!1475 !1476 !90 !91 !393 !394 !92) +!1482 = (!1475 !1476 !90 !91 !393 !394 !92) +!1483 = (!1475 !1476 !90 !91 !393 !394 !92) +!1484 = (!1475 !1476 !90 !91 !92) +!1485 = (!1475 !1476 !90 !91 !92) +!1486 = span !0 6189 6241 +!1487 = span !0 6312 6316 +!1488 = span !0 6317 6318 +!1489 = span !0 6284 6319 +!1490 = fn_call_path_span !0 6284 6311 +!1491 = (!1489 !1490) +!1492 = (!1489 !1490 !1345) +!1493 = span !0 6262 6320 +!1494 = span !0 6363 6370 +!1495 = span !0 6321 6372 +!1496 = span !0 6408 6415 +!1497 = span !0 6408 6421 +!1498 = fn_call_path_span !0 6416 6419 +!1499 = (!1497 !1498) +!1500 = (!1497 !1498 !69) +!1501 = (!1497 !1498 !71 !72) +!1502 = (!1497 !1498 !71 !72 !74) +!1503 = (!1497 !1498 !76) +!1504 = span !0 6423 6430 +!1505 = span !0 6393 6443 +!1506 = span !0 6450 6462 +!1507 = span !0 6466 6478 +!1508 = span !0 6450 6478 +!1509 = span !0 6507 6514 +!1510 = span !0 6507 6540 +!1511 = fn_call_path_span !0 6515 6521 +!1512 = span !6 115618 115639 +!1513 = fn_call_path_span !6 115618 115631 +!1514 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558 !53) +!1515 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558) +!1516 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558 !56) +!1517 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558 !59) +!1518 = span !6 115641 115662 +!1519 = fn_call_path_span !6 115641 115654 +!1520 = (!1510 !1511 !90 !91 !393 !394 !1518 !1519 !557 !558) +!1521 = (!1510 !1511 !90 !91 !393 !394 !1518 !1519 !557 !558 !56) +!1522 = (!1510 !1511 !90 !91 !393 !394 !1518 !1519 !557 !558 !59) +!1523 = span !6 115617 115663 +!1524 = (!1510 !1511 !90 !91 !393 !394 !1523) +!1525 = (!1510 !1511 !90 !91 !393 !394 !1523) +!1526 = (!1510 !1511 !90 !91 !393 !394 !1523) +!1527 = (!1510 !1511 !90 !91 !393 !394 !1523) +!1528 = (!1510 !1511 !90 !91 !393 !394 !1523) +!1529 = (!1510 !1511 !90 !91 !92) +!1530 = (!1510 !1511 !90 !91 !92) +!1531 = span !0 6481 6541 +!1532 = span !0 6616 6620 +!1533 = span !0 6621 6622 +!1534 = span !0 6588 6623 +!1535 = fn_call_path_span !0 6588 6615 +!1536 = (!1534 !1535) +!1537 = (!1534 !1535 !1391) +!1538 = span !0 6562 6624 +!1539 = span !0 6671 6678 +!1540 = span !0 6625 6680 +!1541 = span !0 6716 6723 +!1542 = span !0 6716 6729 +!1543 = fn_call_path_span !0 6724 6727 +!1544 = (!1542 !1543) +!1545 = (!1542 !1543 !69) +!1546 = (!1542 !1543 !71 !72) +!1547 = (!1542 !1543 !71 !72 !74) +!1548 = (!1542 !1543 !76) +!1549 = span !0 6731 6738 +!1550 = span !0 6701 6751 +!1551 = span !0 6758 6770 +!1552 = span !0 6774 6786 +!1553 = span !0 6758 6786 +!1554 = span !0 6820 6827 +!1555 = span !0 6820 6858 +!1556 = fn_call_path_span !0 6828 6834 +!1557 = span !6 115839 115860 +!1558 = fn_call_path_span !6 115839 115852 +!1559 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558 !53) +!1560 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558) +!1561 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558 !56) +!1562 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558 !59) +!1563 = span !6 115862 115883 +!1564 = fn_call_path_span !6 115862 115875 +!1565 = (!1555 !1556 !90 !91 !393 !394 !1563 !1564 !557 !558) +!1566 = (!1555 !1556 !90 !91 !393 !394 !1563 !1564 !557 !558 !56) +!1567 = (!1555 !1556 !90 !91 !393 !394 !1563 !1564 !557 !558 !59) +!1568 = span !6 115885 115906 +!1569 = fn_call_path_span !6 115885 115898 +!1570 = (!1555 !1556 !90 !91 !393 !394 !1568 !1569 !557 !558) +!1571 = (!1555 !1556 !90 !91 !393 !394 !1568 !1569 !557 !558 !56) +!1572 = (!1555 !1556 !90 !91 !393 !394 !1568 !1569 !557 !558 !59) +!1573 = span !6 115838 115907 +!1574 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1575 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1576 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1577 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1578 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1579 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1580 = (!1555 !1556 !90 !91 !393 !394 !1573) +!1581 = (!1555 !1556 !90 !91 !92) +!1582 = (!1555 !1556 !90 !91 !92) +!1583 = span !0 6789 6859 +!1584 = span !0 6939 6943 +!1585 = span !0 6944 6945 +!1586 = span !0 6911 6946 +!1587 = fn_call_path_span !0 6911 6938 +!1588 = (!1586 !1587) +!1589 = (!1586 !1587 !1444) +!1590 = span !0 6880 6947 +!1591 = span !0 6999 7006 +!1592 = span !0 6948 7008 +!1593 = span !0 7044 7051 +!1594 = span !0 7044 7057 +!1595 = fn_call_path_span !0 7052 7055 +!1596 = (!1594 !1595) +!1597 = (!1594 !1595 !69) +!1598 = (!1594 !1595 !71 !72) +!1599 = (!1594 !1595 !71 !72 !74) +!1600 = (!1594 !1595 !76) +!1601 = span !0 7059 7066 +!1602 = span !0 7029 7079 +!1603 = span !0 7086 7098 +!1604 = span !0 7102 7114 +!1605 = span !0 7086 7114 +!1606 = span !0 7153 7160 +!1607 = span !0 7153 7196 +!1608 = fn_call_path_span !0 7161 7167 +!1609 = span !6 116120 116141 +!1610 = fn_call_path_span !6 116120 116133 +!1611 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558 !53) +!1612 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558) +!1613 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558 !56) +!1614 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558 !59) +!1615 = span !6 116155 116176 +!1616 = fn_call_path_span !6 116155 116168 +!1617 = (!1607 !1608 !90 !91 !393 !394 !1615 !1616 !557 !558) +!1618 = (!1607 !1608 !90 !91 !393 !394 !1615 !1616 !557 !558 !56) +!1619 = (!1607 !1608 !90 !91 !393 !394 !1615 !1616 !557 !558 !59) +!1620 = span !6 116190 116211 +!1621 = fn_call_path_span !6 116190 116203 +!1622 = (!1607 !1608 !90 !91 !393 !394 !1620 !1621 !557 !558) +!1623 = (!1607 !1608 !90 !91 !393 !394 !1620 !1621 !557 !558 !56) +!1624 = (!1607 !1608 !90 !91 !393 !394 !1620 !1621 !557 !558 !59) +!1625 = span !6 116225 116246 +!1626 = fn_call_path_span !6 116225 116238 +!1627 = (!1607 !1608 !90 !91 !393 !394 !1625 !1626 !557 !558) +!1628 = (!1607 !1608 !90 !91 !393 !394 !1625 !1626 !557 !558 !56) +!1629 = (!1607 !1608 !90 !91 !393 !394 !1625 !1626 !557 !558 !59) +!1630 = span !6 116106 116257 +!1631 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1632 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1633 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1634 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1635 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1636 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1637 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1638 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1639 = (!1607 !1608 !90 !91 !393 !394 !1630) +!1640 = (!1607 !1608 !90 !91 !92) +!1641 = (!1607 !1608 !90 !91 !92) +!1642 = span !0 7117 7197 +!1643 = span !0 7282 7286 +!1644 = span !0 7287 7288 +!1645 = span !0 7254 7289 +!1646 = fn_call_path_span !0 7254 7281 +!1647 = (!1645 !1646) +!1648 = span !101 5054 5055 +!1649 = (!1645 !1646 !1648) +!1650 = span !0 7218 7290 +!1651 = span !0 7347 7354 +!1652 = span !0 7316 7355 +!1653 = fn_call_path_span !0 7316 7322 +!1654 = (!1652 !1653) +!1655 = (!1652 !1653 !109) +!1656 = (!1652 !1653 !111 !112) +!1657 = (!1652 !1653 !111 !112) +!1658 = span !6 43600 43604 +!1659 = (!1652 !1653 !111 !112 !1658) +!1660 = span !6 43605 43606 +!1661 = (!1652 !1653 !111 !112 !1660) +!1662 = (!1652 !1653 !111 !112) +!1663 = span !6 43618 43624 +!1664 = (!1652 !1653 !111 !112 !1663) +!1665 = span !6 43587 43626 +!1666 = (!1652 !1653 !111 !112 !1665) +!1667 = span !6 43648 43652 +!1668 = (!1652 !1653 !111 !112 !1667) +!1669 = span !6 43653 43654 +!1670 = (!1652 !1653 !111 !112 !1669) +!1671 = (!1652 !1653 !111 !112) +!1672 = span !6 43666 43672 +!1673 = (!1652 !1653 !111 !112 !1672) +!1674 = span !6 43635 43674 +!1675 = (!1652 !1653 !111 !112 !1674) +!1676 = span !6 43696 43700 +!1677 = (!1652 !1653 !111 !112 !1676) +!1678 = span !6 43701 43702 +!1679 = (!1652 !1653 !111 !112 !1678) +!1680 = (!1652 !1653 !111 !112) +!1681 = span !6 43714 43720 +!1682 = (!1652 !1653 !111 !112 !1681) +!1683 = span !6 43683 43722 +!1684 = (!1652 !1653 !111 !112 !1683) +!1685 = span !6 43744 43748 +!1686 = (!1652 !1653 !111 !112 !1685) +!1687 = span !6 43749 43750 +!1688 = (!1652 !1653 !111 !112 !1687) +!1689 = (!1652 !1653 !111 !112) +!1690 = span !6 43762 43768 +!1691 = (!1652 !1653 !111 !112 !1690) +!1692 = span !6 43731 43770 +!1693 = (!1652 !1653 !111 !112 !1692) +!1694 = span !6 43779 43785 +!1695 = (!1652 !1653 !111 !112 !1694) +!1696 = (!1652 !1653 !141) +!1697 = (!1652 !1653 !143) +!1698 = span !0 7291 7356 +!1699 = span !0 7392 7399 +!1700 = span !0 7392 7405 +!1701 = fn_call_path_span !0 7400 7403 +!1702 = (!1700 !1701) +!1703 = (!1700 !1701 !69) +!1704 = (!1700 !1701 !71 !72) +!1705 = (!1700 !1701 !71 !72 !74) +!1706 = (!1700 !1701 !76) +!1707 = span !0 7407 7414 +!1708 = span !0 7377 7427 +!1709 = span !0 7434 7446 +!1710 = span !0 7450 7458 +!1711 = span !0 7434 7458 +!1712 = span !0 7480 7487 +!1713 = span !0 7480 7506 +!1714 = fn_call_path_span !0 7488 7494 +!1715 = span !6 72535 72554 +!1716 = fn_call_path_span !6 72542 72546 +!1717 = (!1713 !1714 !90 !91 !393 !394 !1715 !1716) +!1718 = span !6 72528 72555 +!1719 = fn_call_path_span !6 72528 72534 +!1720 = span !6 71980 72024 +!1721 = (!1713 !1714 !90 !91 !393 !394 !1718 !1719 !1720) +!1722 = span !6 72580 72599 +!1723 = fn_call_path_span !6 72587 72591 +!1724 = (!1713 !1714 !90 !91 !393 !394 !1722 !1723) +!1725 = span !6 72573 72600 +!1726 = fn_call_path_span !6 72573 72579 +!1727 = (!1713 !1714 !90 !91 !393 !394 !1725 !1726 !1720) +!1728 = span !6 72616 72617 +!1729 = span !6 72611 72617 +!1730 = fn_call_path_span !6 72613 72615 +!1731 = (!1713 !1714 !90 !91 !393 !394 !1729 !1730) +!1732 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/primitives.sw" +!1733 = span !1732 5415 5420 +!1734 = (!1713 !1714 !90 !91 !393 !394 !1729 !1730) +!1735 = span !6 72610 72622 +!1736 = fn_call_path_span !6 72619 72620 +!1737 = (!1713 !1714 !90 !91 !393 !394 !1735 !1736) +!1738 = (!1713 !1714 !90 !91 !92) +!1739 = (!1713 !1714 !90 !91 !92) +!1740 = (!1713 !1714 !90 !91 !92) +!1741 = span !0 7461 7507 +!1742 = span !0 7571 7575 +!1743 = span !0 7576 7577 +!1744 = span !0 7605 7627 +!1745 = fn_call_path_span !0 7605 7611 +!1746 = (!1744 !1745 !111 !112) +!1747 = span !6 5124 5130 +!1748 = (!1744 !1745 !111 !112 !1747) +!1749 = (!1744 !1745 !111 !112 !428) +!1750 = (!1744 !1745 !111 !112) +!1751 = (!1744 !1745 !111 !112) +!1752 = (!1744 !1745 !111 !112) +!1753 = (!1744 !1745 !111 !112) +!1754 = (!1744 !1745 !111 !112) +!1755 = (!1744 !1745 !111 !112) +!1756 = (!1744 !1745 !111 !112) +!1757 = (!1744 !1745 !111 !112) +!1758 = (!1744 !1745 !111 !112) +!1759 = (!1744 !1745 !111 !112) +!1760 = (!1744 !1745 !111 !112) +!1761 = (!1744 !1745 !111 !112) +!1762 = (!1744 !1745 !111 !112) +!1763 = (!1744 !1745 !111 !112) +!1764 = (!1744 !1745 !111 !112) +!1765 = (!1744 !1745 !111 !112) +!1766 = (!1744 !1745 !111 !112) +!1767 = (!1744 !1745 !111 !112) +!1768 = (!1744 !1745 !111 !112) +!1769 = (!1744 !1745 !111 !112) +!1770 = (!1744 !1745 !111 !112) +!1771 = (!1744 !1745 !111 !112) +!1772 = (!1744 !1745 !111 !112) +!1773 = span !6 5072 5155 +!1774 = (!1744 !1745 !111 !112 !1773) +!1775 = (!1744 !1745 !111 !112) +!1776 = (!1744 !1745 !141) +!1777 = (!1744 !1745 !143) +!1778 = span !0 7580 7628 +!1779 = span !0 7664 7671 +!1780 = span !0 7664 7677 +!1781 = fn_call_path_span !0 7672 7675 +!1782 = (!1780 !1781) +!1783 = (!1780 !1781 !69) +!1784 = (!1780 !1781 !71 !72) +!1785 = (!1780 !1781 !71 !72 !74) +!1786 = (!1780 !1781 !76) +!1787 = span !0 7679 7686 +!1788 = span !0 7649 7699 +!1789 = (!1744 !1745 !111 !112) +!1790 = (!1744 !1745 !111 !112) +!1791 = (!1744 !1745 !111 !112) +!1792 = (!1744 !1745 !111 !112) +!1793 = span !0 7706 7718 +!1794 = span !0 7722 7731 +!1795 = span !0 7706 7731 +!1796 = span !0 7754 7761 +!1797 = span !0 7754 7781 +!1798 = fn_call_path_span !0 7762 7768 +!1799 = span !6 71774 71804 +!1800 = fn_call_path_span !6 71781 71794 +!1801 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !53) +!1802 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) +!1803 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !399) +!1804 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) +!1805 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) +!1806 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) +!1807 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !404) +!1808 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !406) +!1809 = (!1797 !1798 !90 !91 !92) +!1810 = (!1797 !1798 !90 !91 !92) +!1811 = span !0 7734 7782 +!1812 = span !0 7848 7852 +!1813 = span !0 7853 7854 +!1814 = span !0 7823 7855 +!1815 = fn_call_path_span !0 7823 7847 +!1816 = (!1814 !1815) +!1817 = span !101 3461 3462 +!1818 = (!1814 !1815 !1817) +!1819 = span !0 7803 7856 +!1820 = span !0 7897 7904 +!1821 = span !0 7882 7905 +!1822 = fn_call_path_span !0 7882 7888 +!1823 = (!1821 !1822) +!1824 = (!1821 !1822 !109) +!1825 = (!1821 !1822 !111 !112) +!1826 = (!1821 !1822 !111 !112) +!1827 = span !6 4590 4596 +!1828 = (!1821 !1822 !111 !112 !1827) +!1829 = (!1821 !1822 !111 !112 !428) +!1830 = (!1821 !1822 !111 !112) +!1831 = (!1821 !1822 !111 !112) +!1832 = (!1821 !1822 !111 !112) +!1833 = (!1821 !1822 !111 !112) +!1834 = (!1821 !1822 !111 !112) +!1835 = (!1821 !1822 !111 !112) +!1836 = (!1821 !1822 !111 !112) +!1837 = span !6 4605 4609 +!1838 = (!1821 !1822 !111 !112 !1837) +!1839 = (!1821 !1822 !111 !112) +!1840 = (!1821 !1822 !111 !112) +!1841 = (!1821 !1822 !111 !112) +!1842 = (!1821 !1822 !111 !112) +!1843 = (!1821 !1822 !111 !112) +!1844 = (!1821 !1822 !111 !112) +!1845 = (!1821 !1822 !111 !112) +!1846 = (!1821 !1822 !111 !112) +!1847 = (!1821 !1822 !111 !112) +!1848 = (!1821 !1822 !111 !112) +!1849 = (!1821 !1822 !111 !112) +!1850 = (!1821 !1822 !111 !112) +!1851 = (!1821 !1822 !111 !112) +!1852 = (!1821 !1822 !111 !112) +!1853 = span !6 4538 4621 +!1854 = (!1821 !1822 !111 !112 !1853) +!1855 = (!1821 !1822 !111 !112) +!1856 = (!1821 !1822 !141) +!1857 = (!1821 !1822 !143) +!1858 = span !0 7857 7906 +!1859 = span !0 7942 7949 +!1860 = span !0 7942 7955 +!1861 = fn_call_path_span !0 7950 7953 +!1862 = (!1860 !1861) +!1863 = (!1860 !1861 !69) +!1864 = (!1860 !1861 !71 !72) +!1865 = (!1860 !1861 !71 !72 !74) +!1866 = (!1860 !1861 !76) +!1867 = span !0 7957 7964 +!1868 = span !0 7927 7977 +!1869 = (!1821 !1822 !111 !112) +!1870 = (!1821 !1822 !111 !112) +!1871 = (!1821 !1822 !111 !112) +!1872 = (!1821 !1822 !111 !112) +!1873 = span !0 7984 7996 +!1874 = span !0 8000 8008 +!1875 = span !0 7984 8008 +!1876 = span !0 8030 8037 +!1877 = span !0 8030 8056 +!1878 = fn_call_path_span !0 8038 8044 +!1879 = span !6 72219 72238 +!1880 = fn_call_path_span !6 72226 72230 +!1881 = (!1877 !1878 !90 !91 !393 !394 !1879 !1880) +!1882 = span !6 72212 72239 +!1883 = fn_call_path_span !6 72212 72218 +!1884 = (!1877 !1878 !90 !91 !393 !394 !1882 !1883 !1720) +!1885 = span !6 72264 72283 +!1886 = fn_call_path_span !6 72271 72275 +!1887 = (!1877 !1878 !90 !91 !393 !394 !1885 !1886) +!1888 = span !6 72257 72284 +!1889 = fn_call_path_span !6 72257 72263 +!1890 = (!1877 !1878 !90 !91 !393 !394 !1888 !1889 !1720) +!1891 = span !6 72309 72328 +!1892 = fn_call_path_span !6 72316 72320 +!1893 = (!1877 !1878 !90 !91 !393 !394 !1891 !1892) +!1894 = span !6 72302 72329 +!1895 = fn_call_path_span !6 72302 72308 +!1896 = (!1877 !1878 !90 !91 !393 !394 !1894 !1895 !1720) +!1897 = span !6 72354 72373 +!1898 = fn_call_path_span !6 72361 72365 +!1899 = (!1877 !1878 !90 !91 !393 !394 !1897 !1898) +!1900 = span !6 72347 72374 +!1901 = fn_call_path_span !6 72347 72353 +!1902 = (!1877 !1878 !90 !91 !393 !394 !1900 !1901 !1720) +!1903 = span !6 72390 72392 +!1904 = span !6 72385 72392 +!1905 = fn_call_path_span !6 72387 72389 +!1906 = (!1877 !1878 !90 !91 !393 !394 !1904 !1905) +!1907 = span !1732 3962 3972 +!1908 = (!1877 !1878 !90 !91 !393 !394 !1904 !1905) +!1909 = span !6 72402 72404 +!1910 = span !6 72397 72404 +!1911 = fn_call_path_span !6 72399 72401 +!1912 = (!1877 !1878 !90 !91 !393 !394 !1910 !1911) +!1913 = (!1877 !1878 !90 !91 !393 !394 !1910 !1911) +!1914 = span !6 72384 72405 +!1915 = fn_call_path_span !6 72394 72395 +!1916 = (!1877 !1878 !90 !91 !393 !394 !1914 !1915) +!1917 = span !6 72414 72415 +!1918 = span !6 72409 72415 +!1919 = fn_call_path_span !6 72411 72413 +!1920 = (!1877 !1878 !90 !91 !393 !394 !1918 !1919) +!1921 = (!1877 !1878 !90 !91 !393 !394 !1918 !1919) +!1922 = span !6 72384 72416 +!1923 = fn_call_path_span !6 72406 72407 +!1924 = (!1877 !1878 !90 !91 !393 !394 !1922 !1923) +!1925 = span !6 72384 72420 +!1926 = fn_call_path_span !6 72417 72418 +!1927 = (!1877 !1878 !90 !91 !393 !394 !1925 !1926) +!1928 = (!1877 !1878 !90 !91 !92) +!1929 = (!1877 !1878 !90 !91 !92) +!1930 = (!1877 !1878 !90 !91 !92) +!1931 = span !0 8011 8057 +!1932 = span !0 8121 8125 +!1933 = span !0 8126 8127 +!1934 = span !0 8155 8177 +!1935 = fn_call_path_span !0 8155 8161 +!1936 = (!1934 !1935 !111 !112) +!1937 = span !6 4946 4952 +!1938 = (!1934 !1935 !111 !112 !1937) +!1939 = (!1934 !1935 !111 !112 !428) +!1940 = (!1934 !1935 !111 !112) +!1941 = (!1934 !1935 !111 !112) +!1942 = (!1934 !1935 !111 !112) +!1943 = (!1934 !1935 !111 !112) +!1944 = (!1934 !1935 !111 !112) +!1945 = (!1934 !1935 !111 !112) +!1946 = (!1934 !1935 !111 !112) +!1947 = (!1934 !1935 !111 !112) +!1948 = (!1934 !1935 !111 !112) +!1949 = (!1934 !1935 !111 !112) +!1950 = (!1934 !1935 !111 !112) +!1951 = (!1934 !1935 !111 !112) +!1952 = (!1934 !1935 !111 !112) +!1953 = (!1934 !1935 !111 !112) +!1954 = (!1934 !1935 !111 !112) +!1955 = (!1934 !1935 !111 !112) +!1956 = (!1934 !1935 !111 !112) +!1957 = (!1934 !1935 !111 !112) +!1958 = (!1934 !1935 !111 !112) +!1959 = (!1934 !1935 !111 !112) +!1960 = (!1934 !1935 !111 !112) +!1961 = (!1934 !1935 !111 !112) +!1962 = (!1934 !1935 !111 !112) +!1963 = span !6 4894 4977 +!1964 = (!1934 !1935 !111 !112 !1963) +!1965 = (!1934 !1935 !111 !112) +!1966 = (!1934 !1935 !141) +!1967 = (!1934 !1935 !143) +!1968 = span !0 8130 8178 +!1969 = span !0 8214 8221 +!1970 = span !0 8214 8227 +!1971 = fn_call_path_span !0 8222 8225 +!1972 = (!1970 !1971) +!1973 = (!1970 !1971 !69) +!1974 = (!1970 !1971 !71 !72) +!1975 = (!1970 !1971 !71 !72 !74) +!1976 = (!1970 !1971 !76) +!1977 = span !0 8229 8236 +!1978 = span !0 8199 8249 +!1979 = (!1934 !1935 !111 !112) +!1980 = (!1934 !1935 !111 !112) +!1981 = (!1934 !1935 !111 !112) +!1982 = (!1934 !1935 !111 !112) +!1983 = span !0 8256 8268 +!1984 = span !0 8272 8280 +!1985 = span !0 8256 8280 +!1986 = span !0 8302 8309 +!1987 = span !0 8302 8328 +!1988 = fn_call_path_span !0 8310 8316 +!1989 = (!1987 !1988 !90 !91 !393 !394 !557 !558 !53) +!1990 = (!1987 !1988 !90 !91 !393 !394 !557 !558) +!1991 = (!1987 !1988 !90 !91 !393 !394 !557 !558 !56) +!1992 = (!1987 !1988 !90 !91 !393 !394 !557 !558 !59) +!1993 = (!1987 !1988 !90 !91 !92) +!1994 = (!1987 !1988 !90 !91 !92) +!1995 = (!1987 !1988 !90 !91 !92) +!1996 = span !0 8283 8329 +!1997 = span !0 8393 8397 +!1998 = span !0 8398 8399 +!1999 = span !0 8427 8449 +!2000 = fn_call_path_span !0 8427 8433 +!2001 = (!1999 !2000 !141) +!2002 = (!1999 !2000 !143) +!2003 = span !0 8402 8450 +!2004 = span !0 8486 8493 +!2005 = span !0 8486 8499 +!2006 = fn_call_path_span !0 8494 8497 +!2007 = (!2005 !2006) +!2008 = (!2005 !2006 !69) +!2009 = (!2005 !2006 !71 !72) +!2010 = (!2005 !2006 !71 !72 !74) +!2011 = (!2005 !2006 !76) +!2012 = span !0 8501 8508 +!2013 = span !0 8471 8521 +!2014 = span !0 8528 8540 +!2015 = span !0 8544 8551 +!2016 = span !0 8528 8551 +!2017 = span !0 8572 8579 +!2018 = span !0 8572 8597 +!2019 = fn_call_path_span !0 8580 8586 +!2020 = span !6 72720 72739 +!2021 = fn_call_path_span !6 72727 72731 +!2022 = (!2018 !2019 !90 !91 !393 !394 !2020 !2021) +!2023 = (!2018 !2019 !90 !91 !92) +!2024 = (!2018 !2019 !90 !91 !92) +!2025 = (!2018 !2019 !90 !91 !92) +!2026 = span !0 8554 8598 +!2027 = span !0 8660 8664 +!2028 = span !0 8665 8666 +!2029 = span !0 8694 8715 +!2030 = fn_call_path_span !0 8694 8700 +!2031 = (!2029 !2030 !111 !112) +!2032 = span !6 5301 5307 +!2033 = (!2029 !2030 !111 !112 !2032) +!2034 = (!2029 !2030 !111 !112 !428) +!2035 = (!2029 !2030 !111 !112) +!2036 = (!2029 !2030 !111 !112) +!2037 = (!2029 !2030 !111 !112) +!2038 = (!2029 !2030 !111 !112) +!2039 = (!2029 !2030 !111 !112) +!2040 = (!2029 !2030 !111 !112) +!2041 = (!2029 !2030 !111 !112) +!2042 = (!2029 !2030 !111 !112) +!2043 = (!2029 !2030 !111 !112) +!2044 = (!2029 !2030 !111 !112) +!2045 = (!2029 !2030 !111 !112) +!2046 = (!2029 !2030 !111 !112) +!2047 = (!2029 !2030 !111 !112) +!2048 = (!2029 !2030 !111 !112) +!2049 = (!2029 !2030 !111 !112) +!2050 = (!2029 !2030 !111 !112) +!2051 = (!2029 !2030 !111 !112) +!2052 = (!2029 !2030 !111 !112) +!2053 = (!2029 !2030 !111 !112) +!2054 = (!2029 !2030 !111 !112) +!2055 = span !6 5249 5332 +!2056 = (!2029 !2030 !111 !112 !2055) +!2057 = (!2029 !2030 !111 !112) +!2058 = (!2029 !2030 !141) +!2059 = (!2029 !2030 !143) +!2060 = span !0 8669 8716 +!2061 = span !0 8752 8759 +!2062 = span !0 8752 8765 +!2063 = fn_call_path_span !0 8760 8763 +!2064 = (!2062 !2063) +!2065 = (!2062 !2063 !69) +!2066 = (!2062 !2063 !71 !72) +!2067 = (!2062 !2063 !71 !72 !74) +!2068 = (!2062 !2063 !76) +!2069 = span !0 8767 8774 +!2070 = span !0 8737 8787 +!2071 = (!2029 !2030 !111 !112) +!2072 = (!2029 !2030 !111 !112) +!2073 = (!2029 !2030 !111 !112) +!2074 = (!2029 !2030 !111 !112) +!2075 = span !0 8813 8816 +!2076 = span !0 8804 8817 +!2077 = span !6 3128 3132 +!2078 = span !6 3134 3139 +!2079 = span !6 3102 3321 +!2080 = fn_name_span !6 3109 3119 +!2081 = (!2079 !2080) +!2082 = span !6 3190 3207 +!2083 = span !6 3169 3248 +!2084 = span !6 3257 3300 +!2085 = span !6 3310 3315 +!2086 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/ops.sw" +!2087 = span !2086 35686 36058 +!2088 = fn_name_span !2086 35689 35691 +!2089 = (!2087 !2088) +!2090 = span !2086 35732 35736 +!2091 = span !2086 35746 35751 +!2092 = span !2086 35732 35757 +!2093 = fn_call_path_span !2086 35743 35745 +!2094 = span !2086 15555 15569 +!2095 = fn_call_path_span !2086 15560 15562 +!2096 = (!2092 !2093 !2094 !2095) +!2097 = span !2086 12573 12578 +!2098 = span !2086 15554 15576 +!2099 = fn_call_path_span !2086 15571 15574 +!2100 = (!2092 !2093 !2098 !2099) +!2101 = span !2086 35772 35777 +!2102 = span !2086 35822 35826 +!2103 = span !2086 35865 35870 +!2104 = span !2086 35901 35905 +!2105 = span !2086 35925 36042 +!2106 = span !2086 35987 36002 +!2107 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/str.sw" +!2108 = span !2107 281 403 +!2109 = fn_name_span !2107 288 291 +!2110 = (!2108 !2109) +!2111 = span !2107 337 341 +!2112 = span !2107 90 219 +!2113 = fn_name_span !2107 97 103 +!2114 = (!2112 !2113) +!2115 = span !2107 153 157 +!2116 = span !6 89760 89766 +!2117 = span !6 89738 90238 +!2118 = fn_name_span !6 89741 89751 +!2119 = inline "never" +!2120 = (!2117 !2118 !2119) +!2121 = span !6 89822 89842 +!2122 = span !6 89858 89864 +!2123 = (!2122 !141) +!2124 = (!2122 !143) +!2125 = span !6 89891 89904 +!2126 = span !6 89875 89905 +!2127 = span !6 89998 90003 +!2128 = span !6 90045 90046 +!2129 = (!2128 !141) +!2130 = (!2128 !143) +!2131 = span !6 90027 90028 +!2132 = span !6 90063 90068 +!2133 = fn_call_path_span !6 90065 90066 +!2134 = (!2132 !2133) +!2135 = span !6 90089 90090 +!2136 = (!2135 !141) +!2137 = (!2135 !143) +!2138 = span !6 90165 90185 +!2139 = fn_call_path_span !6 90172 90178 +!2140 = (!2138 !2139 !90 !91 !557 !558 !53) +!2141 = (!2138 !2139 !90 !91 !557 !558) +!2142 = (!2138 !2139 !90 !91 !557 !558 !56) +!2143 = (!2138 !2139 !90 !91 !557 !558 !59) +!2144 = span !6 90157 90185 +!2145 = span !6 90204 90205 +!2146 = span !6 90199 90205 +!2147 = fn_call_path_span !6 90201 90203 +!2148 = (!2146 !2147) +!2149 = span !6 4674 4678 +!2150 = span !6 4660 4805 +!2151 = fn_name_span !6 4663 4673 +!2152 = (!2150 !2151) +!2153 = span !6 4768 4774 +!2154 = span !6 4716 4799 +!2155 = span !6 160 260 +!2156 = fn_name_span !6 167 170 +!2157 = (!2155 !2156) +!2158 = span !6 191 254 +!2159 = span !6 499 591 +!2160 = fn_name_span !6 502 514 +!2161 = (!2159 !2160) +!2162 = span !6 573 577 +!2163 = span !68 3372 3452 +!2164 = fn_name_span !68 3379 3382 +!2165 = (!2163 !2164) +!2166 = span !68 3409 3425 +!2167 = fn_call_path_span !68 3409 3419 +!2168 = (!2166 !2167) +!2169 = (!2166 !2167 !74) +!2170 = (!2117 !2118 !2119) +!2171 = (!2122 !141) +!2172 = (!2122 !143) +!2173 = (!2128 !141) +!2174 = (!2128 !143) +!2175 = (!2132 !2133) +!2176 = (!2135 !141) +!2177 = (!2135 !143) +!2178 = (!2138 !2139 !90 !91 !557 !558 !53) +!2179 = (!2138 !2139 !90 !91 !557 !558) +!2180 = (!2138 !2139 !90 !91 !557 !558 !56) +!2181 = (!2138 !2139 !90 !91 !557 !558 !59) +!2182 = (!2146 !2147) +!2183 = (!2117 !2118 !2119) +!2184 = (!2122 !141) +!2185 = (!2122 !143) +!2186 = (!2128 !141) +!2187 = (!2128 !143) +!2188 = (!2132 !2133) +!2189 = (!2135 !141) +!2190 = (!2135 !143) +!2191 = (!2138 !2139 !90 !91 !557 !558 !53) +!2192 = (!2138 !2139 !90 !91 !557 !558) +!2193 = (!2138 !2139 !90 !91 !557 !558 !56) +!2194 = (!2138 !2139 !90 !91 !557 !558 !59) +!2195 = (!2146 !2147) +!2196 = (!2117 !2118 !2119) +!2197 = (!2122 !141) +!2198 = (!2122 !143) +!2199 = (!2128 !141) +!2200 = (!2128 !143) +!2201 = (!2132 !2133) +!2202 = (!2135 !141) +!2203 = (!2135 !143) +!2204 = (!2138 !2139 !90 !91 !557 !558 !53) +!2205 = (!2138 !2139 !90 !91 !557 !558) +!2206 = (!2138 !2139 !90 !91 !557 !558 !56) +!2207 = (!2138 !2139 !90 !91 !557 !558 !59) +!2208 = (!2146 !2147) +!2209 = (!2117 !2118 !2119) +!2210 = (!2122 !141) +!2211 = (!2122 !143) +!2212 = (!2128 !141) +!2213 = (!2128 !143) +!2214 = (!2132 !2133) +!2215 = (!2135 !141) +!2216 = (!2135 !143) +!2217 = (!2138 !2139 !90 !91 !557 !558 !53) +!2218 = (!2138 !2139 !90 !91 !557 !558) +!2219 = (!2138 !2139 !90 !91 !557 !558 !56) +!2220 = (!2138 !2139 !90 !91 !557 !558 !59) +!2221 = (!2146 !2147) +!2222 = (!2117 !2118 !2119) +!2223 = (!2122 !141) +!2224 = (!2122 !143) +!2225 = (!2128 !141) +!2226 = (!2128 !143) +!2227 = (!2132 !2133) +!2228 = (!2135 !141) +!2229 = (!2135 !143) +!2230 = (!2138 !2139 !90 !91 !557 !558 !53) +!2231 = (!2138 !2139 !90 !91 !557 !558) +!2232 = (!2138 !2139 !90 !91 !557 !558 !56) +!2233 = (!2138 !2139 !90 !91 !557 !558 !59) +!2234 = (!2146 !2147) +!2235 = span !6 70770 70911 +!2236 = fn_name_span !6 70777 70783 +!2237 = (!2235 !2236) +!2238 = (!111 !112) +!2239 = (!111 !112 !117) +!2240 = (!111 !112 !121 !122) +!2241 = (!111 !112 !125) +!2242 = (!111 !112 !127) +!2243 = (!111 !112 !130) +!2244 = (!111 !112 !132) +!2245 = (!111 !112 !135 !136) +!2246 = (!111 !112 !139) +!2247 = span !6 3350 3354 +!2248 = span !6 3327 3871 +!2249 = fn_name_span !6 3334 3338 +!2250 = (!2248 !2249) +!2251 = span !6 3640 3733 +!2252 = span !6 3682 3695 +!2253 = span !6 3747 3786 +!2254 = (!2235 !2236) +!2255 = (!111 !112) +!2256 = span !101 54 58 +!2257 = (!111 !112 !2256) +!2258 = span !0 220 259 +!2259 = (!111 !112 !2258) +!2260 = (!2235 !2236) +!2261 = (!111 !112) +!2262 = span !101 198 202 +!2263 = (!111 !112 !2262) +!2264 = span !0 260 299 +!2265 = (!111 !112 !2264) +!2266 = span !101 232 236 +!2267 = (!111 !112 !2266) +!2268 = span !0 300 339 +!2269 = (!111 !112 !2268) +!2270 = span !101 266 270 +!2271 = (!111 !112 !2270) +!2272 = span !0 340 379 +!2273 = (!111 !112 !2272) +!2274 = (!2235 !2236) +!2275 = (!111 !112) +!2276 = span !6 42991 42992 +!2277 = (!111 !112 !2276) +!2278 = span !6 42973 43012 +!2279 = (!111 !112 !2278) +!2280 = span !6 43039 43040 +!2281 = (!111 !112 !2280) +!2282 = span !6 43021 43060 +!2283 = (!111 !112 !2282) + +// IR: Final +contract { + global __const_global : string<10> = const string<10> "in_array_0" + global __const_global0 : string<10> = const string<10> "in_array_1" + global __const_global1 : string<11> = const string<11> "in_array_16" + global __const_global10 : string<8> = const string<8> "in_str_0" + global __const_global11 : string<8> = const string<8> "in_str_1" + global __const_global12 : string<9> = const string<9> "in_str_16" + global __const_global13 : string<9> = const string<9> "in_str_32" + global __const_global14 : string<8> = const string<8> "in_str_8" + global __const_global15 : string<13> = const string<13> "in_struct_u64" + global __const_global16 : string<17> = const string<17> "in_struct_u64_u64" + global __const_global17 : string<21> = const string<21> "in_struct_u64_u64_u64" + global __const_global18 : string<10> = const string<10> "in_tuple_0" + global __const_global19 : string<10> = const string<10> "in_tuple_1" + global __const_global2 : string<11> = const string<11> "in_array_32" + global __const_global20 : string<10> = const string<10> "in_tuple_2" + global __const_global21 : string<10> = const string<10> "in_tuple_3" + global __const_global22 : string<10> = const string<10> "in_tuple_4" + global __const_global23 : string<6> = const string<6> "in_u16" + global __const_global24 : string<7> = const string<7> "in_u256" + global __const_global25 : string<6> = const string<6> "in_u32" + global __const_global26 : string<6> = const string<6> "in_u64" + global __const_global27 : string<5> = const string<5> "in_u8" + global __const_global28 : string<7> = const string<7> "in_bool" + global __const_global29 : string<5> = const string<5> "in_u8" + global __const_global3 : string<11> = const string<11> "in_array_64" + global __const_global30 : string<6> = const string<6> "in_u16" + global __const_global31 : string<6> = const string<6> "in_u32" + global __const_global32 : string<6> = const string<6> "in_u64" + global __const_global33 : string<7> = const string<7> "in_u256" + global __const_global34 : string<7> = const string<7> "in_b256" + global __const_global35 : string<8> = const string<8> "in_str_0" + global __const_global36 : string<8> = const string<8> "in_str_1" + global __const_global37 : string<8> = const string<8> "in_str_8" + global __const_global38 : string<9> = const string<9> "in_str_16" + global __const_global39 : string<9> = const string<9> "in_str_32" + global __const_global4 : string<10> = const string<10> "in_array_8" + global __const_global40 : string<10> = const string<10> "in_array_0" + global __const_global41 : string<10> = const string<10> "in_array_1" + global __const_global42 : string<10> = const string<10> "in_array_8" + global __const_global43 : string<11> = const string<11> "in_array_16" + global __const_global44 : string<11> = const string<11> "in_array_32" + global __const_global45 : string<11> = const string<11> "in_array_64" + global __const_global46 : string<10> = const string<10> "in_tuple_0" + global __const_global47 : string<10> = const string<10> "in_tuple_1" + global __const_global48 : string<10> = const string<10> "in_tuple_2" + global __const_global49 : string<10> = const string<10> "in_tuple_3" + global __const_global5 : string<7> = const string<7> "in_b256" + global __const_global50 : string<10> = const string<10> "in_tuple_4" + global __const_global51 : string<13> = const string<13> "in_struct_u64" + global __const_global52 : string<17> = const string<17> "in_struct_u64_u64" + global __const_global53 : string<21> = const string<21> "in_struct_u64_u64_u64" + global __const_global54 : string<11> = const string<11> "in_enum_u64" + global __const_global55 : string<15> = const string<15> "in_enum_u64_u64" + global __const_global56 : string<19> = const string<19> "in_enum_u64_u64_u64" + global __const_global6 : string<7> = const string<7> "in_bool" + global __const_global7 : string<11> = const string<11> "in_enum_u64" + global __const_global8 : string<15> = const string<15> "in_enum_u64_u64" + global __const_global9 : string<19> = const string<19> "in_enum_u64_u64_u64" + global const_of_contract_call::CONTRACT_ID : b256 = const b256 0xe0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422 + + pub entry fn __entry() -> (), !3 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut slice __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_010 + local mut { ptr, u64 } __aggr_memcpy_011 + local mut { ptr, u64 } __aggr_memcpy_012 + local mut string<0> __aggr_memcpy_013 + local mut { ptr, u64 } __aggr_memcpy_014 + local mut { ptr, u64 } __aggr_memcpy_015 + local mut string<1> __aggr_memcpy_016 + local mut { ptr, u64 } __aggr_memcpy_017 + local mut { ptr, u64 } __aggr_memcpy_018 + local mut string<16> __aggr_memcpy_019 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut { ptr, u64 } __aggr_memcpy_020 + local mut { ptr, u64 } __aggr_memcpy_021 + local mut string<32> __aggr_memcpy_022 + local mut { ptr, u64 } __aggr_memcpy_023 + local mut { ptr, u64 } __aggr_memcpy_024 + local mut string<8> __aggr_memcpy_025 + local mut { ptr, u64 } __aggr_memcpy_026 + local mut { ptr, u64 } __aggr_memcpy_027 + local mut { ptr, u64 } __aggr_memcpy_028 + local mut { ptr, u64 } __aggr_memcpy_029 + local mut { ptr, u64 } __aggr_memcpy_03 + local mut { ptr, u64 } __aggr_memcpy_030 + local mut { ptr, u64 } __aggr_memcpy_031 + local mut { ptr, u64 } __aggr_memcpy_032 + local mut { ptr, u64 } __aggr_memcpy_033 + local mut { ptr, u64 } __aggr_memcpy_034 + local mut { ptr, u64 } __aggr_memcpy_035 + local mut { ptr, u64 } __aggr_memcpy_036 + local mut { ptr, u64 } __aggr_memcpy_037 + local mut { ptr, u64 } __aggr_memcpy_038 + local mut { ptr, u64 } __aggr_memcpy_04 + local mut { ptr, u64 } __aggr_memcpy_05 + local mut { ptr, u64 } __aggr_memcpy_06 + local mut { ptr, u64 } __aggr_memcpy_07 + local mut { ptr, u64 } __aggr_memcpy_08 + local mut { ptr, u64 } __aggr_memcpy_09 + local { ptr, u64 } __anon_0 + local { ptr } __anon_00 + local { ptr, u64 } __anon_000 + local { u64 } __anon_001 + local { ptr } __anon_01 + local { { u64, ( u64 ) } } __anon_010 + local { { u64, ( u64 | u64 ) } } __anon_011 + local { { u64, ( u64 | u64 | u64 ) } } __anon_012 + local { string<0> } __anon_013 + local { string<1> } __anon_014 + local { string<16> } __anon_015 + local { string<32> } __anon_016 + local { string<8> } __anon_017 + local { { u64 } } __anon_018 + local { { u64, u64 } } __anon_019 + local { [u64; 0] } __anon_02 + local { { u64, u64, u64 } } __anon_020 + local { () } __anon_021 + local { { u64 } } __anon_022 + local { { u64, u64 } } __anon_023 + local { { u64, u64, u64 } } __anon_024 + local { { u64, u64, u64, u64 } } __anon_025 + local { u64 } __anon_026 + local { u256 } __anon_027 + local { u64 } __anon_028 + local { u64 } __anon_029 + local { [u64; 1] } __anon_03 + local { u8 } __anon_030 + local { ptr, u64 } __anon_031 + local { ptr, u64 } __anon_032 + local { ptr, u64 } __anon_033 + local { ptr, u64 } __anon_034 + local { ptr, u64 } __anon_035 + local { ptr, u64 } __anon_036 + local { ptr, u64 } __anon_037 + local { ptr, u64 } __anon_038 + local { ptr, u64 } __anon_039 + local { [u64; 16] } __anon_04 + local { ptr, u64 } __anon_040 + local { ptr, u64 } __anon_041 + local { ptr, u64 } __anon_042 + local { ptr, u64 } __anon_043 + local { ptr, u64 } __anon_044 + local { ptr, u64 } __anon_045 + local { ptr, u64 } __anon_046 + local { ptr, u64 } __anon_047 + local { ptr, u64 } __anon_048 + local { ptr, u64 } __anon_049 + local { [u64; 32] } __anon_05 + local { ptr, u64 } __anon_050 + local { ptr, u64 } __anon_051 + local { ptr, u64 } __anon_052 + local { ptr, u64 } __anon_053 + local { ptr, u64 } __anon_054 + local { ptr, u64 } __anon_055 + local { ptr, u64 } __anon_056 + local { ptr, u64 } __anon_057 + local { ptr, u64 } __anon_058 + local { ptr, u64 } __anon_059 + local { [u64; 64] } __anon_06 + local { ptr, u64 } __anon_060 + local { ptr, u64 } __anon_061 + local { ptr, u64 } __anon_062 + local { ptr, u64 } __anon_063 + local { ptr, u64 } __anon_064 + local { [u64; 8] } __anon_07 + local { b256 } __anon_08 + local { bool } __anon_09 + local slice __anon_1 + local { ptr, u64 } __anon_10 + local slice __anon_11 + local { ptr, u64 } __anon_12 + local slice __anon_13 + local { ptr, u64 } __anon_14 + local slice __anon_15 + local { ptr, u64 } __anon_16 + local slice __anon_17 + local { ptr, u64 } __anon_18 + local slice __anon_19 + local { ptr, u64 } __anon_2 + local { ptr, u64 } __anon_20 + local slice __anon_21 + local { ptr, u64 } __anon_22 + local slice __anon_23 + local { ptr, u64 } __anon_24 + local slice __anon_25 + local { ptr, u64 } __anon_26 + local slice __anon_27 + local { ptr, u64 } __anon_28 + local slice __anon_29 + local slice __anon_3 + local { ptr, u64 } __anon_30 + local slice __anon_31 + local { ptr, u64 } __anon_32 + local slice __anon_33 + local { ptr, u64 } __anon_34 + local slice __anon_35 + local { ptr, u64 } __anon_36 + local slice __anon_37 + local { ptr, u64 } __anon_38 + local slice __anon_39 + local { ptr, u64 } __anon_4 + local { ptr, u64 } __anon_40 + local slice __anon_41 + local { ptr, u64 } __anon_42 + local slice __anon_43 + local { ptr, u64 } __anon_44 + local slice __anon_45 + local { ptr, u64 } __anon_46 + local slice __anon_47 + local { ptr, u64 } __anon_48 + local slice __anon_49 + local slice __anon_5 + local { ptr, u64 } __anon_50 + local slice __anon_51 + local { ptr, u64 } __anon_52 + local slice __anon_53 + local { ptr, u64 } __anon_54 + local slice __anon_55 + local { ptr, u64 } __anon_56 + local slice __anon_57 + local { ptr, u64 } __anon_6 + local slice __anon_7 + local { ptr, u64 } __anon_8 + local slice __anon_9 + local slice __log_arg + local slice __ret_val + local slice __ret_val0 + local slice __ret_val1 + local { { ptr, u64, u64 } } __ret_val10 + local { u64, u64, u64 } __ret_val100 + local { u64, u64, u64 } __ret_val101 + local { u64, u64, u64, u64 } __ret_val102 + local { { ptr, u64, u64 } } __ret_val103 + local { { ptr, u64, u64 } } __ret_val104 + local u256 __ret_val105 + local { { ptr, u64, u64 } } __ret_val106 + local { { ptr, u64, u64 } } __ret_val107 + local { { ptr, u64, u64 } } __ret_val108 + local { { ptr, u64, u64 } } __ret_val11 + local { { ptr, u64, u64 } } __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local { { ptr, u64, u64 } } __ret_val15 + local { { ptr, u64, u64 } } __ret_val16 + local { { ptr, u64, u64 } } __ret_val17 + local { { ptr, u64, u64 } } __ret_val18 + local { { ptr, u64, u64 } } __ret_val19 + local slice __ret_val2 + local { { ptr, u64, u64 } } __ret_val20 + local { { ptr, u64, u64 } } __ret_val21 + local { { ptr, u64, u64 } } __ret_val22 + local { { ptr, u64, u64 } } __ret_val23 + local { { ptr, u64, u64 } } __ret_val24 + local { { ptr, u64, u64 } } __ret_val25 + local { { ptr, u64, u64 } } __ret_val26 + local { { ptr, u64, u64 } } __ret_val27 + local { { ptr, u64, u64 } } __ret_val28 + local { { ptr, u64, u64 } } __ret_val29 + local slice __ret_val3 + local { { ptr, u64, u64 } } __ret_val30 + local { { ptr, u64, u64 } } __ret_val31 + local { { ptr, u64, u64 } } __ret_val32 + local { { ptr, u64, u64 } } __ret_val33 + local { { ptr, u64, u64 } } __ret_val34 + local { { ptr, u64, u64 } } __ret_val35 + local slice __ret_val36 + local slice __ret_val37 + local slice __ret_val38 + local slice __ret_val39 + local slice __ret_val4 + local slice __ret_val40 + local slice __ret_val41 + local slice __ret_val42 + local slice __ret_val43 + local slice __ret_val44 + local slice __ret_val45 + local slice __ret_val46 + local slice __ret_val47 + local slice __ret_val48 + local slice __ret_val49 + local [u64; 0] __ret_val5 + local slice __ret_val50 + local slice __ret_val51 + local slice __ret_val52 + local slice __ret_val53 + local slice __ret_val54 + local slice __ret_val55 + local slice __ret_val56 + local slice __ret_val57 + local slice __ret_val58 + local slice __ret_val59 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val60 + local slice __ret_val61 + local slice __ret_val62 + local slice __ret_val63 + local slice __ret_val64 + local { { ptr, u64, u64 } } __ret_val65 + local [u64; 1] __ret_val66 + local { { ptr, u64, u64 } } __ret_val67 + local [u64; 16] __ret_val68 + local { { ptr, u64, u64 } } __ret_val69 + local { { ptr, u64, u64 } } __ret_val7 + local [u64; 32] __ret_val70 + local { { ptr, u64, u64 } } __ret_val71 + local [u64; 64] __ret_val72 + local { { ptr, u64, u64 } } __ret_val73 + local [u64; 8] __ret_val74 + local { { ptr, u64, u64 } } __ret_val75 + local { { ptr, u64, u64 } } __ret_val76 + local b256 __ret_val77 + local { { ptr, u64, u64 } } __ret_val78 + local { { ptr, u64, u64 } } __ret_val79 + local { { ptr, u64, u64 } } __ret_val8 + local { u64, ( u64 ) } __ret_val80 + local { { ptr, u64, u64 } } __ret_val81 + local { u64, ( u64 | u64 ) } __ret_val82 + local { { ptr, u64, u64 } } __ret_val83 + local { u64, ( u64 | u64 | u64 ) } __ret_val84 + local { { ptr, u64, u64 } } __ret_val85 + local { { ptr, u64, u64 } } __ret_val86 + local { { ptr, u64, u64 } } __ret_val87 + local { { ptr, u64, u64 } } __ret_val88 + local { { ptr, u64, u64 } } __ret_val89 + local { { ptr, u64, u64 } } __ret_val9 + local { { ptr, u64, u64 } } __ret_val90 + local { u64 } __ret_val91 + local { { ptr, u64, u64 } } __ret_val92 + local { { ptr, u64, u64 } } __ret_val93 + local { u64, u64 } __ret_val94 + local { u64, u64 } __ret_val95 + local { { ptr, u64, u64 } } __ret_val96 + local { { ptr, u64, u64 } } __ret_val97 + local { { ptr, u64, u64 } } __ret_val98 + local { { ptr, u64, u64 } } __ret_val99 + local slice __tmp_arg + local slice __tmp_arg0 + local slice __tmp_arg1 + local slice __tmp_arg10 + local slice __tmp_arg100 + local slice __tmp_arg101 + local slice __tmp_arg102 + local slice __tmp_arg103 + local slice __tmp_arg104 + local slice __tmp_arg105 + local slice __tmp_arg106 + local slice __tmp_arg107 + local slice __tmp_arg108 + local slice __tmp_arg109 + local slice __tmp_arg11 + local slice __tmp_arg110 + local slice __tmp_arg111 + local slice __tmp_arg112 + local slice __tmp_arg113 + local slice __tmp_arg114 + local slice __tmp_arg115 + local slice __tmp_arg116 + local [u64; 1] __tmp_arg117 + local { { ptr, u64, u64 } } __tmp_arg118 + local [u64; 16] __tmp_arg119 + local slice __tmp_arg12 + local { { ptr, u64, u64 } } __tmp_arg120 + local [u64; 32] __tmp_arg121 + local { { ptr, u64, u64 } } __tmp_arg122 + local [u64; 64] __tmp_arg123 + local { { ptr, u64, u64 } } __tmp_arg124 + local [u64; 8] __tmp_arg125 + local { { ptr, u64, u64 } } __tmp_arg126 + local [u64; 8] __tmp_arg127 + local { { ptr, u64, u64 } } __tmp_arg128 + local b256 __tmp_arg129 + local slice __tmp_arg13 + local { { ptr, u64, u64 } } __tmp_arg130 + local { { ptr, u64, u64 } } __tmp_arg131 + local { u64, ( u64 ) } __tmp_arg132 + local { { ptr, u64, u64 } } __tmp_arg133 + local { u64, ( u64 | u64 ) } __tmp_arg134 + local { { ptr, u64, u64 } } __tmp_arg135 + local { u64, ( u64 | u64 | u64 ) } __tmp_arg136 + local { { ptr, u64, u64 } } __tmp_arg137 + local string<0> __tmp_arg138 + local { { ptr, u64, u64 } } __tmp_arg139 + local slice __tmp_arg14 + local string<1> __tmp_arg140 + local { { ptr, u64, u64 } } __tmp_arg141 + local string<16> __tmp_arg142 + local { { ptr, u64, u64 } } __tmp_arg143 + local string<32> __tmp_arg144 + local { { ptr, u64, u64 } } __tmp_arg145 + local string<8> __tmp_arg146 + local { { ptr, u64, u64 } } __tmp_arg147 + local { u64 } __tmp_arg148 + local { { ptr, u64, u64 } } __tmp_arg149 + local slice __tmp_arg15 + local { u64 } __tmp_arg150 + local { { ptr, u64, u64 } } __tmp_arg151 + local { u64, u64, u64 } __tmp_arg152 + local { { ptr, u64, u64 } } __tmp_arg153 + local { u64, u64, u64 } __tmp_arg154 + local { { ptr, u64, u64 } } __tmp_arg155 + local { u64, u64 } __tmp_arg156 + local { { ptr, u64, u64 } } __tmp_arg157 + local { u64, u64 } __tmp_arg158 + local { { ptr, u64, u64 } } __tmp_arg159 + local slice __tmp_arg16 + local { u64, u64, u64, u64 } __tmp_arg160 + local { { ptr, u64, u64 } } __tmp_arg161 + local { { ptr, u64, u64 } } __tmp_arg162 + local u256 __tmp_arg163 + local { { ptr, u64, u64 } } __tmp_arg164 + local { { ptr, u64, u64 } } __tmp_arg165 + local { { ptr, u64, u64 } } __tmp_arg166 + local slice __tmp_arg17 + local slice __tmp_arg18 + local slice __tmp_arg19 + local slice __tmp_arg2 + local slice __tmp_arg20 + local slice __tmp_arg21 + local slice __tmp_arg22 + local slice __tmp_arg23 + local slice __tmp_arg24 + local slice __tmp_arg25 + local slice __tmp_arg26 + local slice __tmp_arg27 + local slice __tmp_arg28 + local slice __tmp_arg29 + local slice __tmp_arg3 + local slice __tmp_arg30 + local slice __tmp_arg31 + local slice __tmp_arg32 + local slice __tmp_arg33 + local slice __tmp_arg34 + local slice __tmp_arg35 + local slice __tmp_arg36 + local slice __tmp_arg37 + local slice __tmp_arg38 + local slice __tmp_arg39 + local slice __tmp_arg4 + local slice __tmp_arg40 + local slice __tmp_arg41 + local slice __tmp_arg42 + local slice __tmp_arg43 + local slice __tmp_arg44 + local slice __tmp_arg45 + local slice __tmp_arg46 + local slice __tmp_arg47 + local slice __tmp_arg48 + local slice __tmp_arg49 + local slice __tmp_arg5 + local slice __tmp_arg50 + local slice __tmp_arg51 + local slice __tmp_arg52 + local slice __tmp_arg53 + local slice __tmp_arg54 + local slice __tmp_arg55 + local slice __tmp_arg56 + local { { ptr, u64, u64 } } __tmp_arg57 + local { { ptr, u64, u64 } } __tmp_arg58 + local { { ptr, u64, u64 } } __tmp_arg59 + local slice __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg60 + local { { ptr, u64, u64 } } __tmp_arg61 + local { { ptr, u64, u64 } } __tmp_arg62 + local { { ptr, u64, u64 } } __tmp_arg63 + local { { ptr, u64, u64 } } __tmp_arg64 + local { { ptr, u64, u64 } } __tmp_arg65 + local { { ptr, u64, u64 } } __tmp_arg66 + local { { ptr, u64, u64 } } __tmp_arg67 + local { { ptr, u64, u64 } } __tmp_arg68 + local { { ptr, u64, u64 } } __tmp_arg69 + local slice __tmp_arg7 + local { { ptr, u64, u64 } } __tmp_arg70 + local { { ptr, u64, u64 } } __tmp_arg71 + local { { ptr, u64, u64 } } __tmp_arg72 + local { { ptr, u64, u64 } } __tmp_arg73 + local { { ptr, u64, u64 } } __tmp_arg74 + local { { ptr, u64, u64 } } __tmp_arg75 + local { { ptr, u64, u64 } } __tmp_arg76 + local { { ptr, u64, u64 } } __tmp_arg77 + local { { ptr, u64, u64 } } __tmp_arg78 + local { { ptr, u64, u64 } } __tmp_arg79 + local slice __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg80 + local { { ptr, u64, u64 } } __tmp_arg81 + local { { ptr, u64, u64 } } __tmp_arg82 + local { { ptr, u64, u64 } } __tmp_arg83 + local { { ptr, u64, u64 } } __tmp_arg84 + local { { ptr, u64, u64 } } __tmp_arg85 + local { { ptr, u64, u64 } } __tmp_arg86 + local [u64; 0] __tmp_arg87 + local { { ptr, u64, u64 } } __tmp_arg88 + local slice __tmp_arg89 + local slice __tmp_arg9 + local slice __tmp_arg90 + local slice __tmp_arg91 + local slice __tmp_arg92 + local slice __tmp_arg93 + local slice __tmp_arg94 + local slice __tmp_arg95 + local slice __tmp_arg96 + local slice __tmp_arg97 + local slice __tmp_arg98 + local slice __tmp_arg99 + local mut { ptr } _buffer + local slice _method_name + local [u64; 0] _result + local slice _result_ + local [u64; 1] _result__ + local slice _result___ + local [u64; 16] _result____ + local slice _result_____ + local [u64; 32] _result______ + local slice _result_______ + local [u64; 64] _result________ + local slice _result_________ + local [u64; 8] _result__________ + local slice _result___________ + local b256 _result____________ + local slice _result_____________ + local slice _result_______________ + local { u64, ( u64 ) } _result________________ + local slice _result_________________ + local { u64, ( u64 | u64 ) } _result__________________ + local slice _result___________________ + local { u64, ( u64 | u64 | u64 ) } _result____________________ + local slice _result_____________________ + local string<0> _result______________________ + local slice _result_______________________ + local string<1> _result________________________ + local slice _result_________________________ + local string<16> _result__________________________ + local slice _result___________________________ + local string<32> _result____________________________ + local slice _result_____________________________ + local string<8> _result______________________________ + local slice _result_______________________________ + local { u64 } _result________________________________ + local slice _result_________________________________ + local { u64, u64 } _result__________________________________ + local slice _result___________________________________ + local { u64, u64, u64 } _result____________________________________ + local slice _result_____________________________________ + local { u64 } _result_______________________________________ + local slice _result________________________________________ + local { u64, u64 } _result_________________________________________ + local slice _result__________________________________________ + local { u64, u64, u64 } _result___________________________________________ + local slice _result____________________________________________ + local { u64, u64, u64, u64 } _result_____________________________________________ + local slice _result______________________________________________ + local slice _result________________________________________________ + local u256 _result_________________________________________________ + local slice _result__________________________________________________ + local slice _result____________________________________________________ + local slice _result______________________________________________________ + local slice _result________________________________________________________ + local { [u64; 0] } args + local { [u64; 1] } args_ + local { [u64; 16] } args__ + local { [u64; 32] } args___ + local { [u64; 64] } args____ + local { [u64; 8] } args_____ + local { b256 } args______ + local { bool } args_______ + local { { u64, ( u64 ) } } args________ + local { { u64, ( u64 | u64 ) } } args_________ + local { { u64, ( u64 | u64 | u64 ) } } args__________ + local { string<0> } args___________ + local { string<1> } args____________ + local { string<16> } args_____________ + local { string<32> } args______________ + local { string<8> } args_______________ + local { { u64 } } args________________ + local { { u64, u64 } } args_________________ + local { { u64, u64, u64 } } args__________________ + local { () } args___________________ + local { { u64 } } args____________________ + local { { u64, u64 } } args_____________________ + local { { u64, u64, u64 } } args______________________ + local { { u64, u64, u64, u64 } } args_______________________ + local { u64 } args________________________ + local { u256 } args_________________________ + local { u64 } args__________________________ + local { u64 } args___________________________ + local { u8 } args____________________________ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer10 + local { { ptr, u64, u64 } } buffer11 + local { { ptr, u64, u64 } } buffer12 + local { { ptr, u64, u64 } } buffer13 + local { { ptr, u64, u64 } } buffer14 + local { { ptr, u64, u64 } } buffer15 + local { { ptr, u64, u64 } } buffer16 + local { { ptr, u64, u64 } } buffer17 + local { { ptr, u64, u64 } } buffer18 + local { { ptr, u64, u64 } } buffer19 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer20 + local { { ptr, u64, u64 } } buffer21 + local { { ptr, u64, u64 } } buffer22 + local { { ptr, u64, u64 } } buffer23 + local { { ptr, u64, u64 } } buffer24 + local { { ptr, u64, u64 } } buffer25 + local { { ptr, u64, u64 } } buffer26 + local { { ptr, u64, u64 } } buffer27 + local { { ptr, u64, u64 } } buffer28 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer5 + local { { ptr, u64, u64 } } buffer6 + local { { ptr, u64, u64 } } buffer7 + local { { ptr, u64, u64 } } buffer8 + local { { ptr, u64, u64 } } buffer9 + local slice data + local slice data0 + local slice data1 + local slice data2 + local slice data3 + local slice data4 + local [u64; 0] item_ + local [u64; 1] item_0 + local [u64; 16] item_1 + local { u64, ( u64 | u64 | u64 ) } item_10 + local string<0> item_11 + local string<1> item_12 + local string<16> item_13 + local string<32> item_14 + local string<8> item_15 + local { u64 } item_16 + local { u64, u64 } item_17 + local { u64, u64, u64 } item_18 + local { u64 } item_19 + local [u64; 32] item_2 + local { u64, u64 } item_20 + local { u64, u64, u64 } item_21 + local { u64, u64, u64, u64 } item_22 + local u256 item_24 + local [u64; 64] item_3 + local [u64; 8] item_4 + local [u64; 8] item_5 + local b256 item_6 + local { u64, ( u64 ) } item_8 + local { u64, ( u64 | u64 ) } item_9 + local slice self_ + local slice self_0 + local slice self_1 + local slice self_10 + local slice self_11 + local slice self_12 + local slice self_13 + local slice self_14 + local slice self_15 + local slice self_16 + local slice self_17 + local slice self_18 + local slice self_19 + local slice self_2 + local slice self_20 + local slice self_21 + local slice self_22 + local slice self_23 + local slice self_24 + local slice self_25 + local slice self_26 + local slice self_27 + local slice self_28 + local slice self_29 + local slice self_3 + local slice self_30 + local slice self_31 + local slice self_32 + local slice self_4 + local slice self_5 + local slice self_6 + local slice self_7 + local slice self_8 + local slice self_9 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_10 + local slice slice_11 + local slice slice_12 + local slice slice_13 + local slice slice_14 + local slice slice_15 + local slice slice_16 + local slice slice_17 + local slice slice_18 + local slice slice_19 + local slice slice_2 + local slice slice_20 + local slice slice_21 + local slice slice_22 + local slice slice_23 + local slice slice_24 + local slice slice_25 + local slice slice_26 + local slice slice_27 + local slice slice_28 + local slice slice_29 + local slice slice_3 + local slice slice_30 + local slice slice_31 + local slice slice_32 + local slice slice_4 + local slice slice_5 + local slice slice_6 + local slice slice_7 + local slice slice_8 + local slice slice_9 + local [u64; 0] v_ + local [u64; 1] v_0 + local [u64; 16] v_1 + local string<0> v_10 + local string<1> v_11 + local string<16> v_12 + local string<32> v_13 + local string<8> v_14 + local { u64 } v_15 + local { u64, u64 } v_16 + local { u64, u64, u64 } v_17 + local { u64 } v_19 + local [u64; 32] v_2 + local { u64, u64 } v_20 + local { u64, u64, u64 } v_21 + local { u64, u64, u64, u64 } v_22 + local u256 v_24 + local [u64; 64] v_3 + local [u64; 8] v_4 + local b256 v_5 + local { u64, ( u64 ) } v_7 + local { u64, ( u64 | u64 ) } v_8 + local { u64, ( u64 | u64 | u64 ) } v_9 + + entry(): + v0 = asm() -> ptr fp, !8 { + } + v1 = const u64 592, !11 + v2 = add v0, v1, !12 + v3 = asm(ptr: v2, val) -> u64 val, !17 { + lw val ptr i0, !18 + } + v4 = asm(ptr: v3) -> ptr ptr, !20 { + } + v5 = get_local __ptr { ptr }, __anon_00, !22 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6, !23 + store v4 to v7, !24 + v8 = get_local __ptr { ptr }, _buffer, !25 + mem_copy_val v8, v5 + v9 = asm() -> ptr fp, !31 { + } + v10 = const u64 584, !34 + v11 = add v9, v10, !35 + v12 = asm(ptr: v11, val) -> u64 val, !38 { + lw val ptr i0, !18 + } + v13 = asm(ptr: v12) -> ptr ptr, !40 { + } + v14 = get_local __ptr { ptr }, __anon_01, !42 + v15 = const u64 0 + v16 = get_elem_ptr v14, __ptr ptr, v15, !43 + store v13 to v16, !44 + v17 = get_local __ptr { ptr }, buffer, !46 + mem_copy_val v17, v14 + v18 = get_local __ptr { ptr }, buffer, !48 + v19 = const u64 0 + v20 = get_elem_ptr v18, __ptr ptr, v19, !54 + v21 = load v20, !55 + v22 = asm(ptr: v21, val) -> u64 val, !57 { + lw val ptr i0, !58 + } + v23 = load v20, !55 + v24 = const u64 8, !55 + v25 = add v23, v24, !55 + store v25 to v20, !60 + v26 = get_local __ptr slice, __ret_val + v27 = call read_bytes_8(v18, v22, v26) + v28 = get_local __ptr slice, data, !62 + mem_copy_val v28, v26 + v29 = get_local __ptr slice, data, !64 + v30 = get_local __ptr slice, self_, !67 + mem_copy_val v30, v29 + v31 = get_local __ptr slice, self_, !70 + v32 = get_local __ptr slice, slice_, !73 + mem_copy_val v32, v31 + v33 = get_local __ptr slice, slice_, !75 + v34 = asm(ptr: v33) -> __ptr { ptr, u64 } ptr { + } + v35 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v35, v34 + v36 = get_local __ptr { ptr, u64 }, __anon_031, !67 + mem_copy_val v36, v35 + v37 = const u64 0 + v38 = get_elem_ptr v36, __ptr ptr, v37, !77 + v39 = get_local __ptr { ptr, u64 }, __anon_000, !79 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr ptr, v40, !80 + mem_copy_val v41, v38 + v42 = const u64 1 + v43 = get_elem_ptr v39, __ptr u64, v42, !81 + store v22 to v43, !82 + v44 = asm(s: v39) -> __ptr slice s { + } + v45 = get_local __ptr slice, __aggr_memcpy_00 + mem_copy_val v45, v44 + v46 = get_local __ptr slice, _method_name, !83 + mem_copy_val v46, v45 + v47 = get_local __ptr slice, _method_name, !84 + v48 = get_global __ptr string<10>, __const_global + v49 = cast_ptr v48 to ptr, !85 + v50 = get_local __ptr { ptr, u64 }, __anon_0, !85 + v51 = const u64 0 + v52 = get_elem_ptr v50, __ptr ptr, v51 + store v49 to v52, !85 + v53 = const u64 1 + v54 = get_elem_ptr v50, __ptr u64, v53 + v55 = const u64 10 + store v55 to v54, !85 + v56 = get_local __ptr slice, __anon_1, !85 + mem_copy_bytes v56, v50, 16 + v57 = get_local __ptr slice, __tmp_arg + mem_copy_val v57, v47 + v58 = get_local __ptr slice, __tmp_arg0 + mem_copy_val v58, v56 + v59 = call eq_11(v57, v58) + cbr v59, block0(), block1(), !86 + + block0(): + v60 = get_local __ptr { ptr }, _buffer, !87 + v61 = get_local __ptr [u64; 0], __ret_val5 + v62 = call abi_decode_18(v60, v61) + v63 = get_local __ptr { [u64; 0] }, __anon_02, !93 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr [u64; 0], v64, !94 + mem_copy_val v65, v61 + v66 = get_local __ptr { [u64; 0] }, args, !95 + mem_copy_val v66, v63 + v67 = get_local __ptr { [u64; 0] }, args, !96 + v68 = const u64 0 + v69 = get_elem_ptr v67, __ptr [u64; 0], v68, !97 + v70 = get_local __ptr [u64; 0], v_, !100 + mem_copy_val v70, v69 + v71 = get_local __ptr [u64; 0], v_, !103 + v72 = get_local __ptr [u64; 0], _result, !104 + mem_copy_val v72, v71 + v73 = get_local __ptr [u64; 0], _result, !105 + v74 = get_local __ptr [u64; 0], item_, !108 + mem_copy_val v74, v73 + v75 = get_local __ptr [u64; 0], item_, !110 + v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v77 = call new_21(v76) + v78 = get_local __ptr [u64; 0], __tmp_arg87 + mem_copy_val v78, v75 + v79 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg88 + mem_copy_val v79, v76 + v80 = get_local __ptr { { ptr, u64, u64 } }, __ret_val65 + v81 = call abi_encode_29(v78, v79, v80) + v82 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !112 + mem_copy_val v82, v80 + v83 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !114 + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg58 + mem_copy_val v84, v83 + v85 = get_local __ptr slice, __ret_val36 + v86 = call as_raw_slice_22(v84, v85) + v87 = get_local __ptr slice, _result_, !115 + mem_copy_val v87, v85 + v88 = get_local __ptr slice, _result_, !116 + v89 = get_local __ptr slice, self_0, !119 + mem_copy_val v89, v88 + v90 = get_local __ptr slice, self_0, !120 + v91 = get_local __ptr slice, slice_0, !121 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, slice_0, !122 + v93 = asm(ptr: v92) -> __ptr { ptr, u64 } ptr { + } + v94 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v94, v93 + v95 = get_local __ptr { ptr, u64 }, __anon_032, !119 + mem_copy_val v95, v94 + v96 = get_elem_ptr v95, __ptr ptr, v37, !123 + v97 = load v96, !119 + v98 = get_local __ptr slice, _result_, !124 + v99 = get_local __ptr slice, __tmp_arg89 + mem_copy_val v99, v98 + v100 = call len_30(v99) + retd v97 v100, !125 + + block1(): + v101 = get_local __ptr slice, _method_name, !126 + v102 = get_global __ptr string<10>, __const_global0 + v103 = cast_ptr v102 to ptr, !127 + v104 = get_local __ptr { ptr, u64 }, __anon_2, !127 + v105 = const u64 0 + v106 = get_elem_ptr v104, __ptr ptr, v105 + store v103 to v106, !127 + v107 = const u64 1 + v108 = get_elem_ptr v104, __ptr u64, v107 + v109 = const u64 10 + store v109 to v108, !127 + v110 = get_local __ptr slice, __anon_3, !127 + mem_copy_bytes v110, v104, 16 + v111 = get_local __ptr slice, __tmp_arg1 + mem_copy_val v111, v101 + v112 = get_local __ptr slice, __tmp_arg2 + mem_copy_val v112, v110 + v113 = call eq_11(v111, v112) + cbr v113, block3(), block4(), !128 + + block3(): + v114 = get_local __ptr { ptr }, _buffer, !129 + v115 = get_local __ptr [u64; 1], __ret_val66 + v116 = call abi_decode_34(v114, v115) + v117 = get_local __ptr { [u64; 1] }, __anon_03, !132 + v118 = const u64 0 + v119 = get_elem_ptr v117, __ptr [u64; 1], v118, !133 + mem_copy_val v119, v115 + v120 = get_local __ptr { [u64; 1] }, args_, !134 + mem_copy_val v120, v117 + v121 = get_local __ptr { [u64; 1] }, args_, !135 + v122 = const u64 0 + v123 = get_elem_ptr v121, __ptr [u64; 1], v122, !136 + v124 = get_local __ptr [u64; 1], v_0, !139 + mem_copy_val v124, v123 + v125 = get_local __ptr [u64; 1], v_0, !141 + v126 = get_local __ptr [u64; 1], _result__, !142 + mem_copy_val v126, v125 + v127 = get_local __ptr [u64; 1], _result__, !143 + v128 = get_local __ptr [u64; 1], item_0, !146 + mem_copy_val v128, v127 + v129 = get_local __ptr [u64; 1], item_0, !147 + v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v131 = call new_21(v130) + v132 = get_local __ptr [u64; 1], __tmp_arg117 + mem_copy_val v132, v129 + v133 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg118 + mem_copy_val v133, v130 + v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val67 + v135 = call abi_encode_37(v132, v133, v134) + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !148 + mem_copy_val v136, v134 + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !149 + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg59 + mem_copy_val v138, v137 + v139 = get_local __ptr slice, __ret_val37 + v140 = call as_raw_slice_22(v138, v139) + v141 = get_local __ptr slice, _result___, !150 + mem_copy_val v141, v139 + v142 = get_local __ptr slice, _result___, !151 + v143 = get_local __ptr slice, self_1, !154 + mem_copy_val v143, v142 + v144 = get_local __ptr slice, self_1, !155 + v145 = get_local __ptr slice, slice_1, !156 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, slice_1, !157 + v147 = asm(ptr: v146) -> __ptr { ptr, u64 } ptr { + } + v148 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v148, v147 + v149 = get_local __ptr { ptr, u64 }, __anon_033, !154 + mem_copy_val v149, v148 + v150 = get_elem_ptr v149, __ptr ptr, v37, !158 + v151 = load v150, !154 + v152 = get_local __ptr slice, _result___, !159 + v153 = get_local __ptr slice, __tmp_arg90 + mem_copy_val v153, v152 + v154 = call len_30(v153) + retd v151 v154, !160 + + block4(): + v155 = get_local __ptr slice, _method_name, !161 + v156 = get_global __ptr string<11>, __const_global1 + v157 = cast_ptr v156 to ptr, !162 + v158 = get_local __ptr { ptr, u64 }, __anon_4, !162 + v159 = const u64 0 + v160 = get_elem_ptr v158, __ptr ptr, v159 + store v157 to v160, !162 + v161 = const u64 1 + v162 = get_elem_ptr v158, __ptr u64, v161 + v163 = const u64 11 + store v163 to v162, !162 + v164 = get_local __ptr slice, __anon_5, !162 + mem_copy_bytes v164, v158, 16 + v165 = get_local __ptr slice, __tmp_arg3 + mem_copy_val v165, v155 + v166 = get_local __ptr slice, __tmp_arg4 + mem_copy_val v166, v164 + v167 = call eq_11(v165, v166) + cbr v167, block6(), block7(), !163 + + block6(): + v168 = get_local __ptr { ptr }, _buffer, !164 + v169 = get_local __ptr [u64; 16], __ret_val68 + v170 = call abi_decode_40(v168, v169) + v171 = get_local __ptr { [u64; 16] }, __anon_04, !167 + v172 = const u64 0 + v173 = get_elem_ptr v171, __ptr [u64; 16], v172, !168 + mem_copy_val v173, v169 + v174 = get_local __ptr { [u64; 16] }, args__, !169 + mem_copy_val v174, v171 + v175 = get_local __ptr { [u64; 16] }, args__, !170 + v176 = const u64 0 + v177 = get_elem_ptr v175, __ptr [u64; 16], v176, !171 + v178 = get_local __ptr [u64; 16], v_1, !174 + mem_copy_val v178, v177 + v179 = get_local __ptr [u64; 16], v_1, !176 + v180 = get_local __ptr [u64; 16], _result____, !177 + mem_copy_val v180, v179 + v181 = get_local __ptr [u64; 16], _result____, !178 + v182 = get_local __ptr [u64; 16], item_1, !181 + mem_copy_val v182, v181 + v183 = get_local __ptr [u64; 16], item_1, !182 + v184 = get_local __ptr { { ptr, u64, u64 } }, __ret_val9 + v185 = call new_21(v184) + v186 = get_local __ptr [u64; 16], __tmp_arg119 + mem_copy_val v186, v183 + v187 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg120 + mem_copy_val v187, v184 + v188 = get_local __ptr { { ptr, u64, u64 } }, __ret_val69 + v189 = call abi_encode_43(v186, v187, v188) + v190 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !183 + mem_copy_val v190, v188 + v191 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !184 + v192 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg60 + mem_copy_val v192, v191 + v193 = get_local __ptr slice, __ret_val38 + v194 = call as_raw_slice_22(v192, v193) + v195 = get_local __ptr slice, _result_____, !185 + mem_copy_val v195, v193 + v196 = get_local __ptr slice, _result_____, !186 + v197 = get_local __ptr slice, self_2, !189 + mem_copy_val v197, v196 + v198 = get_local __ptr slice, self_2, !190 + v199 = get_local __ptr slice, slice_2, !191 + mem_copy_val v199, v198 + v200 = get_local __ptr slice, slice_2, !192 + v201 = asm(ptr: v200) -> __ptr { ptr, u64 } ptr { + } + v202 = get_local __ptr { ptr, u64 }, __aggr_memcpy_03 + mem_copy_val v202, v201 + v203 = get_local __ptr { ptr, u64 }, __anon_034, !189 + mem_copy_val v203, v202 + v204 = get_elem_ptr v203, __ptr ptr, v37, !193 + v205 = load v204, !189 + v206 = get_local __ptr slice, _result_____, !194 + v207 = get_local __ptr slice, __tmp_arg91 + mem_copy_val v207, v206 + v208 = call len_30(v207) + retd v205 v208, !195 + + block7(): + v209 = get_local __ptr slice, _method_name, !196 + v210 = get_global __ptr string<11>, __const_global2 + v211 = cast_ptr v210 to ptr, !197 + v212 = get_local __ptr { ptr, u64 }, __anon_6, !197 + v213 = const u64 0 + v214 = get_elem_ptr v212, __ptr ptr, v213 + store v211 to v214, !197 + v215 = const u64 1 + v216 = get_elem_ptr v212, __ptr u64, v215 + v217 = const u64 11 + store v217 to v216, !197 + v218 = get_local __ptr slice, __anon_7, !197 + mem_copy_bytes v218, v212, 16 + v219 = get_local __ptr slice, __tmp_arg5 + mem_copy_val v219, v209 + v220 = get_local __ptr slice, __tmp_arg6 + mem_copy_val v220, v218 + v221 = call eq_11(v219, v220) + cbr v221, block9(), block10(), !198 + + block9(): + v222 = get_local __ptr { ptr }, _buffer, !199 + v223 = get_local __ptr [u64; 32], __ret_val70 + v224 = call abi_decode_46(v222, v223) + v225 = get_local __ptr { [u64; 32] }, __anon_05, !202 + v226 = const u64 0 + v227 = get_elem_ptr v225, __ptr [u64; 32], v226, !203 + mem_copy_val v227, v223 + v228 = get_local __ptr { [u64; 32] }, args___, !204 + mem_copy_val v228, v225 + v229 = get_local __ptr { [u64; 32] }, args___, !205 + v230 = const u64 0 + v231 = get_elem_ptr v229, __ptr [u64; 32], v230, !206 + v232 = get_local __ptr [u64; 32], v_2, !209 + mem_copy_val v232, v231 + v233 = get_local __ptr [u64; 32], v_2, !211 + v234 = get_local __ptr [u64; 32], _result______, !212 + mem_copy_val v234, v233 + v235 = get_local __ptr [u64; 32], _result______, !213 + v236 = get_local __ptr [u64; 32], item_2, !216 + mem_copy_val v236, v235 + v237 = get_local __ptr [u64; 32], item_2, !217 + v238 = get_local __ptr { { ptr, u64, u64 } }, __ret_val10 + v239 = call new_21(v238) + v240 = get_local __ptr [u64; 32], __tmp_arg121 + mem_copy_val v240, v237 + v241 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg122 + mem_copy_val v241, v238 + v242 = get_local __ptr { { ptr, u64, u64 } }, __ret_val71 + v243 = call abi_encode_49(v240, v241, v242) + v244 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !218 + mem_copy_val v244, v242 + v245 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !219 + v246 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg61 + mem_copy_val v246, v245 + v247 = get_local __ptr slice, __ret_val39 + v248 = call as_raw_slice_22(v246, v247) + v249 = get_local __ptr slice, _result_______, !220 + mem_copy_val v249, v247 + v250 = get_local __ptr slice, _result_______, !221 + v251 = get_local __ptr slice, self_3, !224 + mem_copy_val v251, v250 + v252 = get_local __ptr slice, self_3, !225 + v253 = get_local __ptr slice, slice_3, !226 + mem_copy_val v253, v252 + v254 = get_local __ptr slice, slice_3, !227 + v255 = asm(ptr: v254) -> __ptr { ptr, u64 } ptr { + } + v256 = get_local __ptr { ptr, u64 }, __aggr_memcpy_04 + mem_copy_val v256, v255 + v257 = get_local __ptr { ptr, u64 }, __anon_035, !224 + mem_copy_val v257, v256 + v258 = get_elem_ptr v257, __ptr ptr, v37, !228 + v259 = load v258, !224 + v260 = get_local __ptr slice, _result_______, !229 + v261 = get_local __ptr slice, __tmp_arg92 + mem_copy_val v261, v260 + v262 = call len_30(v261) + retd v259 v262, !230 + + block10(): + v263 = get_local __ptr slice, _method_name, !231 + v264 = get_global __ptr string<11>, __const_global3 + v265 = cast_ptr v264 to ptr, !232 + v266 = get_local __ptr { ptr, u64 }, __anon_8, !232 + v267 = const u64 0 + v268 = get_elem_ptr v266, __ptr ptr, v267 + store v265 to v268, !232 + v269 = const u64 1 + v270 = get_elem_ptr v266, __ptr u64, v269 + v271 = const u64 11 + store v271 to v270, !232 + v272 = get_local __ptr slice, __anon_9, !232 + mem_copy_bytes v272, v266, 16 + v273 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v273, v263 + v274 = get_local __ptr slice, __tmp_arg8 + mem_copy_val v274, v272 + v275 = call eq_11(v273, v274) + cbr v275, block12(), block13(), !233 + + block12(): + v276 = get_local __ptr { ptr }, _buffer, !234 + v277 = get_local __ptr [u64; 64], __ret_val72 + v278 = call abi_decode_52(v276, v277) + v279 = get_local __ptr { [u64; 64] }, __anon_06, !237 + v280 = const u64 0 + v281 = get_elem_ptr v279, __ptr [u64; 64], v280, !238 + mem_copy_val v281, v277 + v282 = get_local __ptr { [u64; 64] }, args____, !239 + mem_copy_val v282, v279 + v283 = get_local __ptr { [u64; 64] }, args____, !240 + v284 = const u64 0 + v285 = get_elem_ptr v283, __ptr [u64; 64], v284, !241 + v286 = get_local __ptr [u64; 64], v_3, !244 + mem_copy_val v286, v285 + v287 = get_local __ptr [u64; 64], v_3, !246 + v288 = get_local __ptr [u64; 64], _result________, !247 + mem_copy_val v288, v287 + v289 = get_local __ptr [u64; 64], _result________, !248 + v290 = get_local __ptr [u64; 64], item_3, !251 + mem_copy_val v290, v289 + v291 = get_local __ptr [u64; 64], item_3, !252 + v292 = get_local __ptr { { ptr, u64, u64 } }, __ret_val11 + v293 = call new_21(v292) + v294 = get_local __ptr [u64; 64], __tmp_arg123 + mem_copy_val v294, v291 + v295 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg124 + mem_copy_val v295, v292 + v296 = get_local __ptr { { ptr, u64, u64 } }, __ret_val73 + v297 = call abi_encode_55(v294, v295, v296) + v298 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !253 + mem_copy_val v298, v296 + v299 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !254 + v300 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg62 + mem_copy_val v300, v299 + v301 = get_local __ptr slice, __ret_val40 + v302 = call as_raw_slice_22(v300, v301) + v303 = get_local __ptr slice, _result_________, !255 + mem_copy_val v303, v301 + v304 = get_local __ptr slice, _result_________, !256 + v305 = get_local __ptr slice, self_4, !259 + mem_copy_val v305, v304 + v306 = get_local __ptr slice, self_4, !260 + v307 = get_local __ptr slice, slice_4, !261 + mem_copy_val v307, v306 + v308 = get_local __ptr slice, slice_4, !262 + v309 = asm(ptr: v308) -> __ptr { ptr, u64 } ptr { + } + v310 = get_local __ptr { ptr, u64 }, __aggr_memcpy_05 + mem_copy_val v310, v309 + v311 = get_local __ptr { ptr, u64 }, __anon_036, !259 + mem_copy_val v311, v310 + v312 = get_elem_ptr v311, __ptr ptr, v37, !263 + v313 = load v312, !259 + v314 = get_local __ptr slice, _result_________, !264 + v315 = get_local __ptr slice, __tmp_arg93 + mem_copy_val v315, v314 + v316 = call len_30(v315) + retd v313 v316, !265 + + block13(): + v317 = get_local __ptr slice, _method_name, !266 + v318 = get_global __ptr string<10>, __const_global4 + v319 = cast_ptr v318 to ptr, !267 + v320 = get_local __ptr { ptr, u64 }, __anon_10, !267 + v321 = const u64 0 + v322 = get_elem_ptr v320, __ptr ptr, v321 + store v319 to v322, !267 + v323 = const u64 1 + v324 = get_elem_ptr v320, __ptr u64, v323 + v325 = const u64 10 + store v325 to v324, !267 + v326 = get_local __ptr slice, __anon_11, !267 + mem_copy_bytes v326, v320, 16 + v327 = get_local __ptr slice, __tmp_arg9 + mem_copy_val v327, v317 + v328 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v328, v326 + v329 = call eq_11(v327, v328) + cbr v329, block15(), block16(), !268 + + block15(): + v330 = get_local __ptr { ptr }, _buffer, !269 + v331 = get_local __ptr [u64; 8], __ret_val74 + v332 = call abi_decode_58(v330, v331) + v333 = get_local __ptr { [u64; 8] }, __anon_07, !272 + v334 = const u64 0 + v335 = get_elem_ptr v333, __ptr [u64; 8], v334, !273 + mem_copy_val v335, v331 + v336 = get_local __ptr { [u64; 8] }, args_____, !274 + mem_copy_val v336, v333 + v337 = get_local __ptr { [u64; 8] }, args_____, !275 + v338 = const u64 0 + v339 = get_elem_ptr v337, __ptr [u64; 8], v338, !276 + v340 = get_local __ptr [u64; 8], v_4, !279 + mem_copy_val v340, v339 + v341 = get_local __ptr [u64; 8], v_4, !281 + v342 = get_local __ptr [u64; 8], item_4, !282 + mem_copy_val v342, v341 + v343 = get_local __ptr [u64; 8], item_4, !283 + v344 = get_local __ptr { { ptr, u64, u64 } }, __ret_val12 + v345 = call new_21(v344) + v346 = get_local __ptr [u64; 8], __tmp_arg125 + mem_copy_val v346, v343 + v347 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg126 + mem_copy_val v347, v344 + v348 = get_local __ptr { { ptr, u64, u64 } }, __ret_val75 + v349 = call abi_encode_61(v346, v347, v348) + v350 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !284 + mem_copy_val v350, v348 + v351 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !285 + v352 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg63 + mem_copy_val v352, v351 + v353 = get_local __ptr slice, __ret_val41 + v354 = call as_raw_slice_22(v352, v353) + v355 = get_local __ptr slice, __log_arg + mem_copy_val v355, v353 + v356 = const u64 3565715504387854074 + log __ptr slice v355, v356 + v357 = get_local __ptr [u64; 8], v_4, !287 + v358 = get_local __ptr [u64; 8], _result__________, !288 + mem_copy_val v358, v357 + v359 = get_local __ptr [u64; 8], _result__________, !289 + v360 = get_local __ptr [u64; 8], item_5, !292 + mem_copy_val v360, v359 + v361 = get_local __ptr [u64; 8], item_5, !293 + v362 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v363 = call new_21(v362) + v364 = get_local __ptr [u64; 8], __tmp_arg127 + mem_copy_val v364, v361 + v365 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg128 + mem_copy_val v365, v362 + v366 = get_local __ptr { { ptr, u64, u64 } }, __ret_val76 + v367 = call abi_encode_61(v364, v365, v366) + v368 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !294 + mem_copy_val v368, v366 + v369 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !295 + v370 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg64 + mem_copy_val v370, v369 + v371 = get_local __ptr slice, __ret_val42 + v372 = call as_raw_slice_22(v370, v371) + v373 = get_local __ptr slice, _result___________, !296 + mem_copy_val v373, v371 + v374 = get_local __ptr slice, _result___________, !297 + v375 = get_local __ptr slice, self_5, !300 + mem_copy_val v375, v374 + v376 = get_local __ptr slice, self_5, !301 + v377 = get_local __ptr slice, slice_5, !302 + mem_copy_val v377, v376 + v378 = get_local __ptr slice, slice_5, !303 + v379 = asm(ptr: v378) -> __ptr { ptr, u64 } ptr { + } + v380 = get_local __ptr { ptr, u64 }, __aggr_memcpy_06 + mem_copy_val v380, v379 + v381 = get_local __ptr { ptr, u64 }, __anon_037, !300 + mem_copy_val v381, v380 + v382 = get_elem_ptr v381, __ptr ptr, v37, !304 + v383 = load v382, !300 + v384 = get_local __ptr slice, _result___________, !305 + v385 = get_local __ptr slice, __tmp_arg94 + mem_copy_val v385, v384 + v386 = call len_30(v385) + retd v383 v386, !306 + + block16(): + v387 = get_local __ptr slice, _method_name, !307 + v388 = get_global __ptr string<7>, __const_global5 + v389 = cast_ptr v388 to ptr, !308 + v390 = get_local __ptr { ptr, u64 }, __anon_12, !308 + v391 = const u64 0 + v392 = get_elem_ptr v390, __ptr ptr, v391 + store v389 to v392, !308 + v393 = const u64 1 + v394 = get_elem_ptr v390, __ptr u64, v393 + v395 = const u64 7 + store v395 to v394, !308 + v396 = get_local __ptr slice, __anon_13, !308 + mem_copy_bytes v396, v390, 16 + v397 = get_local __ptr slice, __tmp_arg11 + mem_copy_val v397, v387 + v398 = get_local __ptr slice, __tmp_arg12 + mem_copy_val v398, v396 + v399 = call eq_11(v397, v398) + cbr v399, block18(), block19(), !309 + + block18(): + v400 = get_local __ptr { ptr }, _buffer, !310 + v401 = get_local __ptr b256, __ret_val77 + v402 = call abi_decode_64(v400, v401) + v403 = get_local __ptr { b256 }, __anon_08, !313 + v404 = const u64 0 + v405 = get_elem_ptr v403, __ptr b256, v404, !314 + mem_copy_val v405, v401 + v406 = get_local __ptr { b256 }, args______, !315 + mem_copy_val v406, v403 + v407 = get_local __ptr { b256 }, args______, !316 + v408 = const u64 0 + v409 = get_elem_ptr v407, __ptr b256, v408, !317 + v410 = get_local __ptr b256, v_5, !320 + mem_copy_val v410, v409 + v411 = get_local __ptr b256, v_5, !322 + v412 = get_local __ptr b256, _result____________, !323 + mem_copy_val v412, v411 + v413 = get_local __ptr b256, _result____________, !324 + v414 = get_local __ptr b256, item_6, !327 + mem_copy_val v414, v413 + v415 = get_local __ptr b256, item_6, !328 + v416 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v417 = call new_21(v416) + v418 = get_local __ptr b256, __tmp_arg129 + mem_copy_val v418, v415 + v419 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg130 + mem_copy_val v419, v416 + v420 = get_local __ptr { { ptr, u64, u64 } }, __ret_val78 + v421 = call abi_encode_68(v418, v419, v420) + v422 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !329 + mem_copy_val v422, v420 + v423 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !330 + v424 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg65 + mem_copy_val v424, v423 + v425 = get_local __ptr slice, __ret_val43 + v426 = call as_raw_slice_22(v424, v425) + v427 = get_local __ptr slice, _result_____________, !331 + mem_copy_val v427, v425 + v428 = get_local __ptr slice, _result_____________, !332 + v429 = get_local __ptr slice, self_6, !335 + mem_copy_val v429, v428 + v430 = get_local __ptr slice, self_6, !336 + v431 = get_local __ptr slice, slice_6, !337 + mem_copy_val v431, v430 + v432 = get_local __ptr slice, slice_6, !338 + v433 = asm(ptr: v432) -> __ptr { ptr, u64 } ptr { + } + v434 = get_local __ptr { ptr, u64 }, __aggr_memcpy_07 + mem_copy_val v434, v433 + v435 = get_local __ptr { ptr, u64 }, __anon_038, !335 + mem_copy_val v435, v434 + v436 = get_elem_ptr v435, __ptr ptr, v37, !339 + v437 = load v436, !335 + v438 = get_local __ptr slice, _result_____________, !340 + v439 = get_local __ptr slice, __tmp_arg95 + mem_copy_val v439, v438 + v440 = call len_30(v439) + retd v437 v440, !341 + + block19(): + v441 = get_local __ptr slice, _method_name, !342 + v442 = get_global __ptr string<7>, __const_global6 + v443 = cast_ptr v442 to ptr, !343 + v444 = get_local __ptr { ptr, u64 }, __anon_14, !343 + v445 = const u64 0 + v446 = get_elem_ptr v444, __ptr ptr, v445 + store v443 to v446, !343 + v447 = const u64 1 + v448 = get_elem_ptr v444, __ptr u64, v447 + v449 = const u64 7 + store v449 to v448, !343 + v450 = get_local __ptr slice, __anon_15, !343 + mem_copy_bytes v450, v444, 16 + v451 = get_local __ptr slice, __tmp_arg13 + mem_copy_val v451, v441 + v452 = get_local __ptr slice, __tmp_arg14 + mem_copy_val v452, v450 + v453 = call eq_11(v451, v452) + cbr v453, block21(), block22(), !344 + + block21(): + v454 = get_local __ptr { ptr }, _buffer, !345 + v455 = call read_72(v454), !352 + v456 = const u8 0, !353 + v457 = cmp eq v455 v456, !356 + v458 = const bool false, !357 + cbr v457, abi_decode_71_block5(v458), abi_decode_71_block1(), !358 + + abi_decode_71_block1(): + v459 = const u8 1, !359 + v460 = cmp eq v455 v459, !362 + v461 = const bool true, !363 + cbr v460, abi_decode_71_block5(v461), abi_decode_71_block3(), !364 + + abi_decode_71_block3(): + v462 = const u64 0, !365 + revert v462, !367 + + abi_decode_71_block5(v463: bool): + v464 = get_local __ptr { bool }, __anon_09, !368 + v465 = const u64 0 + v466 = get_elem_ptr v464, __ptr bool, v465, !369 + store v463 to v466, !370 + v467 = get_local __ptr { bool }, args_______, !371 + mem_copy_val v467, v464 + v468 = get_local __ptr { bool }, args_______, !372 + v469 = const u64 0 + v470 = get_elem_ptr v468, __ptr bool, v469, !373 + v471 = load v470 + v472 = get_local __ptr { { ptr, u64, u64 } }, __ret_val15 + v473 = call new_21(v472) + v474 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg131 + mem_copy_val v474, v472 + v475 = get_local __ptr { { ptr, u64, u64 } }, __ret_val79 + v476 = call abi_encode_77(v471, v474, v475) + v477 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !376 + mem_copy_val v477, v475 + v478 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !377 + v479 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg66 + mem_copy_val v479, v478 + v480 = get_local __ptr slice, __ret_val44 + v481 = call as_raw_slice_22(v479, v480) + v482 = get_local __ptr slice, _result_______________, !378 + mem_copy_val v482, v480 + v483 = get_local __ptr slice, _result_______________, !379 + v484 = get_local __ptr slice, self_7, !382 + mem_copy_val v484, v483 + v485 = get_local __ptr slice, self_7, !383 + v486 = get_local __ptr slice, slice_7, !384 + mem_copy_val v486, v485 + v487 = get_local __ptr slice, slice_7, !385 + v488 = asm(ptr: v487) -> __ptr { ptr, u64 } ptr { + } + v489 = get_local __ptr { ptr, u64 }, __aggr_memcpy_08 + mem_copy_val v489, v488 + v490 = get_local __ptr { ptr, u64 }, __anon_039, !382 + mem_copy_val v490, v489 + v491 = get_elem_ptr v490, __ptr ptr, v37, !386 + v492 = load v491, !382 + v493 = get_local __ptr slice, _result_______________, !387 + v494 = get_local __ptr slice, __tmp_arg96 + mem_copy_val v494, v493 + v495 = call len_30(v494) + retd v492 v495, !388 + + block22(): + v496 = get_local __ptr slice, _method_name, !389 + v497 = get_global __ptr string<11>, __const_global7 + v498 = cast_ptr v497 to ptr, !390 + v499 = get_local __ptr { ptr, u64 }, __anon_16, !390 + v500 = const u64 0 + v501 = get_elem_ptr v499, __ptr ptr, v500 + store v498 to v501, !390 + v502 = const u64 1 + v503 = get_elem_ptr v499, __ptr u64, v502 + v504 = const u64 11 + store v504 to v503, !390 + v505 = get_local __ptr slice, __anon_17, !390 + mem_copy_bytes v505, v499, 16 + v506 = get_local __ptr slice, __tmp_arg15 + mem_copy_val v506, v496 + v507 = get_local __ptr slice, __tmp_arg16 + mem_copy_val v507, v505 + v508 = call eq_11(v506, v507) + cbr v508, block24(), block25(), !391 + + block24(): + v509 = get_local __ptr { ptr }, _buffer, !392 + v510 = get_local __ptr { u64, ( u64 ) }, __ret_val80 + v511 = call abi_decode_80(v509, v510) + v512 = get_local __ptr { { u64, ( u64 ) } }, __anon_010, !395 + v513 = const u64 0 + v514 = get_elem_ptr v512, __ptr { u64, ( u64 ) }, v513, !396 + mem_copy_val v514, v510 + v515 = get_local __ptr { { u64, ( u64 ) } }, args________, !397 + mem_copy_val v515, v512 + v516 = get_local __ptr { { u64, ( u64 ) } }, args________, !398 + v517 = const u64 0 + v518 = get_elem_ptr v516, __ptr { u64, ( u64 ) }, v517, !399 + v519 = get_local __ptr { u64, ( u64 ) }, v_7, !402 + mem_copy_val v519, v518 + v520 = get_local __ptr { u64, ( u64 ) }, v_7, !404 + v521 = get_local __ptr { u64, ( u64 ) }, _result________________, !405 + mem_copy_val v521, v520 + v522 = get_local __ptr { u64, ( u64 ) }, _result________________, !406 + v523 = get_local __ptr { u64, ( u64 ) }, item_8, !409 + mem_copy_val v523, v522 + v524 = get_local __ptr { u64, ( u64 ) }, item_8, !410 + v525 = get_local __ptr { { ptr, u64, u64 } }, __ret_val16 + v526 = call new_21(v525) + v527 = get_local __ptr { u64, ( u64 ) }, __tmp_arg132 + mem_copy_val v527, v524 + v528 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg133 + mem_copy_val v528, v525 + v529 = get_local __ptr { { ptr, u64, u64 } }, __ret_val81 + v530 = call abi_encode_83(v527, v528, v529) + v531 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !411 + mem_copy_val v531, v529 + v532 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !412 + v533 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg67 + mem_copy_val v533, v532 + v534 = get_local __ptr slice, __ret_val45 + v535 = call as_raw_slice_22(v533, v534) + v536 = get_local __ptr slice, _result_________________, !413 + mem_copy_val v536, v534 + v537 = get_local __ptr slice, _result_________________, !414 + v538 = get_local __ptr slice, self_8, !417 + mem_copy_val v538, v537 + v539 = get_local __ptr slice, self_8, !418 + v540 = get_local __ptr slice, slice_8, !419 + mem_copy_val v540, v539 + v541 = get_local __ptr slice, slice_8, !420 + v542 = asm(ptr: v541) -> __ptr { ptr, u64 } ptr { + } + v543 = get_local __ptr { ptr, u64 }, __aggr_memcpy_09 + mem_copy_val v543, v542 + v544 = get_local __ptr { ptr, u64 }, __anon_040, !417 + mem_copy_val v544, v543 + v545 = get_elem_ptr v544, __ptr ptr, v37, !421 + v546 = load v545, !417 + v547 = get_local __ptr slice, _result_________________, !422 + v548 = get_local __ptr slice, __tmp_arg97 + mem_copy_val v548, v547 + v549 = call len_30(v548) + retd v546 v549, !423 + + block25(): + v550 = get_local __ptr slice, _method_name, !424 + v551 = get_global __ptr string<15>, __const_global8 + v552 = cast_ptr v551 to ptr, !425 + v553 = get_local __ptr { ptr, u64 }, __anon_18, !425 + v554 = const u64 0 + v555 = get_elem_ptr v553, __ptr ptr, v554 + store v552 to v555, !425 + v556 = const u64 1 + v557 = get_elem_ptr v553, __ptr u64, v556 + v558 = const u64 15 + store v558 to v557, !425 + v559 = get_local __ptr slice, __anon_19, !425 + mem_copy_bytes v559, v553, 16 + v560 = get_local __ptr slice, __tmp_arg17 + mem_copy_val v560, v550 + v561 = get_local __ptr slice, __tmp_arg18 + mem_copy_val v561, v559 + v562 = call eq_11(v560, v561) + cbr v562, block27(), block28(), !426 + + block27(): + v563 = get_local __ptr { ptr }, _buffer, !427 + v564 = get_local __ptr { u64, ( u64 | u64 ) }, __ret_val82 + v565 = call abi_decode_86(v563, v564) + v566 = get_local __ptr { { u64, ( u64 | u64 ) } }, __anon_011, !430 + v567 = const u64 0 + v568 = get_elem_ptr v566, __ptr { u64, ( u64 | u64 ) }, v567, !431 + mem_copy_val v568, v564 + v569 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !432 + mem_copy_val v569, v566 + v570 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !433 + v571 = const u64 0 + v572 = get_elem_ptr v570, __ptr { u64, ( u64 | u64 ) }, v571, !434 + v573 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !437 + mem_copy_val v573, v572 + v574 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !439 + v575 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !440 + mem_copy_val v575, v574 + v576 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !441 + v577 = get_local __ptr { u64, ( u64 | u64 ) }, item_9, !444 + mem_copy_val v577, v576 + v578 = get_local __ptr { u64, ( u64 | u64 ) }, item_9, !445 + v579 = get_local __ptr { { ptr, u64, u64 } }, __ret_val17 + v580 = call new_21(v579) + v581 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_arg134 + mem_copy_val v581, v578 + v582 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg135 + mem_copy_val v582, v579 + v583 = get_local __ptr { { ptr, u64, u64 } }, __ret_val83 + v584 = call abi_encode_89(v581, v582, v583) + v585 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !446 + mem_copy_val v585, v583 + v586 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !447 + v587 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg68 + mem_copy_val v587, v586 + v588 = get_local __ptr slice, __ret_val46 + v589 = call as_raw_slice_22(v587, v588) + v590 = get_local __ptr slice, _result___________________, !448 + mem_copy_val v590, v588 + v591 = get_local __ptr slice, _result___________________, !449 + v592 = get_local __ptr slice, self_9, !452 + mem_copy_val v592, v591 + v593 = get_local __ptr slice, self_9, !453 + v594 = get_local __ptr slice, slice_9, !454 + mem_copy_val v594, v593 + v595 = get_local __ptr slice, slice_9, !455 + v596 = asm(ptr: v595) -> __ptr { ptr, u64 } ptr { + } + v597 = get_local __ptr { ptr, u64 }, __aggr_memcpy_010 + mem_copy_val v597, v596 + v598 = get_local __ptr { ptr, u64 }, __anon_041, !452 + mem_copy_val v598, v597 + v599 = get_elem_ptr v598, __ptr ptr, v37, !456 + v600 = load v599, !452 + v601 = get_local __ptr slice, _result___________________, !457 + v602 = get_local __ptr slice, __tmp_arg98 + mem_copy_val v602, v601 + v603 = call len_30(v602) + retd v600 v603, !458 + + block28(): + v604 = get_local __ptr slice, _method_name, !459 + v605 = get_global __ptr string<19>, __const_global9 + v606 = cast_ptr v605 to ptr, !460 + v607 = get_local __ptr { ptr, u64 }, __anon_20, !460 + v608 = const u64 0 + v609 = get_elem_ptr v607, __ptr ptr, v608 + store v606 to v609, !460 + v610 = const u64 1 + v611 = get_elem_ptr v607, __ptr u64, v610 + v612 = const u64 19 + store v612 to v611, !460 + v613 = get_local __ptr slice, __anon_21, !460 + mem_copy_bytes v613, v607, 16 + v614 = get_local __ptr slice, __tmp_arg19 + mem_copy_val v614, v604 + v615 = get_local __ptr slice, __tmp_arg20 + mem_copy_val v615, v613 + v616 = call eq_11(v614, v615) + cbr v616, block30(), block31(), !461 + + block30(): + v617 = get_local __ptr { ptr }, _buffer, !462 + v618 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __ret_val84 + v619 = call abi_decode_92(v617, v618) + v620 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, __anon_012, !465 + v621 = const u64 0 + v622 = get_elem_ptr v620, __ptr { u64, ( u64 | u64 | u64 ) }, v621, !466 + mem_copy_val v622, v618 + v623 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !467 + mem_copy_val v623, v620 + v624 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !468 + v625 = const u64 0 + v626 = get_elem_ptr v624, __ptr { u64, ( u64 | u64 | u64 ) }, v625, !469 + v627 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !472 + mem_copy_val v627, v626 + v628 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !474 + v629 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !475 + mem_copy_val v629, v628 + v630 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !476 + v631 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_10, !479 + mem_copy_val v631, v630 + v632 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_10, !480 + v633 = get_local __ptr { { ptr, u64, u64 } }, __ret_val18 + v634 = call new_21(v633) + v635 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_arg136 + mem_copy_val v635, v632 + v636 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg137 + mem_copy_val v636, v633 + v637 = get_local __ptr { { ptr, u64, u64 } }, __ret_val85 + v638 = call abi_encode_95(v635, v636, v637) + v639 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !481 + mem_copy_val v639, v637 + v640 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !482 + v641 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg69 + mem_copy_val v641, v640 + v642 = get_local __ptr slice, __ret_val47 + v643 = call as_raw_slice_22(v641, v642) + v644 = get_local __ptr slice, _result_____________________, !483 + mem_copy_val v644, v642 + v645 = get_local __ptr slice, _result_____________________, !484 + v646 = get_local __ptr slice, self_10, !487 + mem_copy_val v646, v645 + v647 = get_local __ptr slice, self_10, !488 + v648 = get_local __ptr slice, slice_10, !489 + mem_copy_val v648, v647 + v649 = get_local __ptr slice, slice_10, !490 + v650 = asm(ptr: v649) -> __ptr { ptr, u64 } ptr { + } + v651 = get_local __ptr { ptr, u64 }, __aggr_memcpy_011 + mem_copy_val v651, v650 + v652 = get_local __ptr { ptr, u64 }, __anon_042, !487 + mem_copy_val v652, v651 + v653 = get_elem_ptr v652, __ptr ptr, v37, !491 + v654 = load v653, !487 + v655 = get_local __ptr slice, _result_____________________, !492 + v656 = get_local __ptr slice, __tmp_arg99 + mem_copy_val v656, v655 + v657 = call len_30(v656) + retd v654 v657, !493 + + block31(): + v658 = get_local __ptr slice, _method_name, !494 + v659 = get_global __ptr string<8>, __const_global10 + v660 = cast_ptr v659 to ptr, !495 + v661 = get_local __ptr { ptr, u64 }, __anon_22, !495 + v662 = const u64 0 + v663 = get_elem_ptr v661, __ptr ptr, v662 + store v660 to v663, !495 + v664 = const u64 1 + v665 = get_elem_ptr v661, __ptr u64, v664 + v666 = const u64 8 + store v666 to v665, !495 + v667 = get_local __ptr slice, __anon_23, !495 + mem_copy_bytes v667, v661, 16 + v668 = get_local __ptr slice, __tmp_arg21 + mem_copy_val v668, v658 + v669 = get_local __ptr slice, __tmp_arg22 + mem_copy_val v669, v667 + v670 = call eq_11(v668, v669) + cbr v670, block33(), block34(), !496 + + block33(): + v671 = get_local __ptr { ptr }, _buffer, !497 + v672 = get_local __ptr slice, __ret_val0 + v673 = const u64 0 + v674 = call read_bytes_8(v671, v673, v672) + v675 = get_local __ptr slice, data0, !501 + mem_copy_val v675, v672 + v676 = get_local __ptr slice, data0, !503 + v677 = get_local __ptr slice, self_11, !506 + mem_copy_val v677, v676 + v678 = get_local __ptr slice, self_11, !507 + v679 = get_local __ptr slice, slice_11, !508 + mem_copy_val v679, v678 + v680 = get_local __ptr slice, slice_11, !509 + v681 = asm(ptr: v680) -> __ptr { ptr, u64 } ptr { + } + v682 = get_local __ptr { ptr, u64 }, __aggr_memcpy_012 + mem_copy_val v682, v681 + v683 = get_local __ptr { ptr, u64 }, __anon_043, !506 + mem_copy_val v683, v682 + v684 = get_elem_ptr v683, __ptr ptr, v37, !510 + v685 = load v684, !506 + v686 = asm(s: v685) -> __ptr string<0> s { + } + v687 = get_local __ptr string<0>, __aggr_memcpy_013 + mem_copy_val v687, v686 + v688 = get_local __ptr { string<0> }, __anon_013, !511 + v689 = const u64 0 + v690 = get_elem_ptr v688, __ptr string<0>, v689, !512 + mem_copy_val v690, v687 + v691 = get_local __ptr { string<0> }, args___________, !513 + mem_copy_val v691, v688 + v692 = get_local __ptr { string<0> }, args___________, !514 + v693 = const u64 0 + v694 = get_elem_ptr v692, __ptr string<0>, v693, !515 + v695 = get_local __ptr string<0>, v_10, !518 + mem_copy_val v695, v694 + v696 = get_local __ptr string<0>, v_10, !520 + v697 = get_local __ptr string<0>, _result______________________, !521 + mem_copy_val v697, v696 + v698 = get_local __ptr string<0>, _result______________________, !522 + v699 = get_local __ptr string<0>, item_11, !525 + mem_copy_val v699, v698 + v700 = get_local __ptr string<0>, item_11, !526 + v701 = get_local __ptr { { ptr, u64, u64 } }, __ret_val19 + v702 = call new_21(v701) + v703 = get_local __ptr string<0>, __tmp_arg138 + mem_copy_val v703, v700 + v704 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg139 + mem_copy_val v704, v701 + v705 = get_local __ptr { { ptr, u64, u64 } }, __ret_val86 + v706 = call abi_encode_101(v703, v704, v705) + v707 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !527 + mem_copy_val v707, v705 + v708 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !528 + v709 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg70 + mem_copy_val v709, v708 + v710 = get_local __ptr slice, __ret_val48 + v711 = call as_raw_slice_22(v709, v710) + v712 = get_local __ptr slice, _result_______________________, !529 + mem_copy_val v712, v710 + v713 = get_local __ptr slice, _result_______________________, !530 + v714 = get_local __ptr slice, self_12, !533 + mem_copy_val v714, v713 + v715 = get_local __ptr slice, self_12, !534 + v716 = get_local __ptr slice, slice_12, !535 + mem_copy_val v716, v715 + v717 = get_local __ptr slice, slice_12, !536 + v718 = asm(ptr: v717) -> __ptr { ptr, u64 } ptr { + } + v719 = get_local __ptr { ptr, u64 }, __aggr_memcpy_014 + mem_copy_val v719, v718 + v720 = get_local __ptr { ptr, u64 }, __anon_044, !533 + mem_copy_val v720, v719 + v721 = get_elem_ptr v720, __ptr ptr, v37, !537 + v722 = load v721, !533 + v723 = get_local __ptr slice, _result_______________________, !538 + v724 = get_local __ptr slice, __tmp_arg100 + mem_copy_val v724, v723 + v725 = call len_30(v724) + retd v722 v725, !539 + + block34(): + v726 = get_local __ptr slice, _method_name, !540 + v727 = get_global __ptr string<8>, __const_global11 + v728 = cast_ptr v727 to ptr, !541 + v729 = get_local __ptr { ptr, u64 }, __anon_24, !541 + v730 = const u64 0 + v731 = get_elem_ptr v729, __ptr ptr, v730 + store v728 to v731, !541 + v732 = const u64 1 + v733 = get_elem_ptr v729, __ptr u64, v732 + v734 = const u64 8 + store v734 to v733, !541 + v735 = get_local __ptr slice, __anon_25, !541 + mem_copy_bytes v735, v729, 16 + v736 = get_local __ptr slice, __tmp_arg23 + mem_copy_val v736, v726 + v737 = get_local __ptr slice, __tmp_arg24 + mem_copy_val v737, v735 + v738 = call eq_11(v736, v737) + cbr v738, block36(), block37(), !542 + + block36(): + v739 = get_local __ptr { ptr }, _buffer, !543 + v740 = get_local __ptr slice, __ret_val1 + v741 = const u64 1 + v742 = call read_bytes_8(v739, v741, v740) + v743 = get_local __ptr slice, data1, !546 + mem_copy_val v743, v740 + v744 = get_local __ptr slice, data1, !547 + v745 = get_local __ptr slice, self_13, !548 + mem_copy_val v745, v744 + v746 = get_local __ptr slice, self_13, !549 + v747 = get_local __ptr slice, slice_13, !550 + mem_copy_val v747, v746 + v748 = get_local __ptr slice, slice_13, !551 + v749 = asm(ptr: v748) -> __ptr { ptr, u64 } ptr { + } + v750 = get_local __ptr { ptr, u64 }, __aggr_memcpy_015 + mem_copy_val v750, v749 + v751 = get_local __ptr { ptr, u64 }, __anon_045, !548 + mem_copy_val v751, v750 + v752 = get_elem_ptr v751, __ptr ptr, v37, !552 + v753 = load v752, !548 + v754 = asm(s: v753) -> __ptr string<1> s { + } + v755 = get_local __ptr string<1>, __aggr_memcpy_016 + mem_copy_val v755, v754 + v756 = get_local __ptr { string<1> }, __anon_014, !553 + v757 = const u64 0 + v758 = get_elem_ptr v756, __ptr string<1>, v757, !554 + mem_copy_val v758, v755 + v759 = get_local __ptr { string<1> }, args____________, !555 + mem_copy_val v759, v756 + v760 = get_local __ptr { string<1> }, args____________, !556 + v761 = const u64 0 + v762 = get_elem_ptr v760, __ptr string<1>, v761, !557 + v763 = get_local __ptr string<1>, v_11, !560 + mem_copy_val v763, v762 + v764 = get_local __ptr string<1>, v_11, !562 + v765 = get_local __ptr string<1>, _result________________________, !563 + mem_copy_val v765, v764 + v766 = get_local __ptr string<1>, _result________________________, !564 + v767 = get_local __ptr string<1>, item_12, !567 + mem_copy_val v767, v766 + v768 = get_local __ptr string<1>, item_12, !568 + v769 = get_local __ptr { { ptr, u64, u64 } }, __ret_val20 + v770 = call new_21(v769) + v771 = get_local __ptr string<1>, __tmp_arg140 + mem_copy_val v771, v768 + v772 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg141 + mem_copy_val v772, v769 + v773 = get_local __ptr { { ptr, u64, u64 } }, __ret_val87 + v774 = call abi_encode_107(v771, v772, v773) + v775 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !569 + mem_copy_val v775, v773 + v776 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !570 + v777 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg71 + mem_copy_val v777, v776 + v778 = get_local __ptr slice, __ret_val49 + v779 = call as_raw_slice_22(v777, v778) + v780 = get_local __ptr slice, _result_________________________, !571 + mem_copy_val v780, v778 + v781 = get_local __ptr slice, _result_________________________, !572 + v782 = get_local __ptr slice, self_14, !575 + mem_copy_val v782, v781 + v783 = get_local __ptr slice, self_14, !576 + v784 = get_local __ptr slice, slice_14, !577 + mem_copy_val v784, v783 + v785 = get_local __ptr slice, slice_14, !578 + v786 = asm(ptr: v785) -> __ptr { ptr, u64 } ptr { + } + v787 = get_local __ptr { ptr, u64 }, __aggr_memcpy_017 + mem_copy_val v787, v786 + v788 = get_local __ptr { ptr, u64 }, __anon_046, !575 + mem_copy_val v788, v787 + v789 = get_elem_ptr v788, __ptr ptr, v37, !579 + v790 = load v789, !575 + v791 = get_local __ptr slice, _result_________________________, !580 + v792 = get_local __ptr slice, __tmp_arg101 + mem_copy_val v792, v791 + v793 = call len_30(v792) + retd v790 v793, !581 + + block37(): + v794 = get_local __ptr slice, _method_name, !582 + v795 = get_global __ptr string<9>, __const_global12 + v796 = cast_ptr v795 to ptr, !583 + v797 = get_local __ptr { ptr, u64 }, __anon_26, !583 + v798 = const u64 0 + v799 = get_elem_ptr v797, __ptr ptr, v798 + store v796 to v799, !583 + v800 = const u64 1 + v801 = get_elem_ptr v797, __ptr u64, v800 + v802 = const u64 9 + store v802 to v801, !583 + v803 = get_local __ptr slice, __anon_27, !583 + mem_copy_bytes v803, v797, 16 + v804 = get_local __ptr slice, __tmp_arg25 + mem_copy_val v804, v794 + v805 = get_local __ptr slice, __tmp_arg26 + mem_copy_val v805, v803 + v806 = call eq_11(v804, v805) + cbr v806, block39(), block40(), !584 + + block39(): + v807 = get_local __ptr { ptr }, _buffer, !585 + v808 = get_local __ptr slice, __ret_val2 + v809 = const u64 16 + v810 = call read_bytes_8(v807, v809, v808) + v811 = get_local __ptr slice, data2, !588 + mem_copy_val v811, v808 + v812 = get_local __ptr slice, data2, !589 + v813 = get_local __ptr slice, self_15, !590 + mem_copy_val v813, v812 + v814 = get_local __ptr slice, self_15, !591 + v815 = get_local __ptr slice, slice_15, !592 + mem_copy_val v815, v814 + v816 = get_local __ptr slice, slice_15, !593 + v817 = asm(ptr: v816) -> __ptr { ptr, u64 } ptr { + } + v818 = get_local __ptr { ptr, u64 }, __aggr_memcpy_018 + mem_copy_val v818, v817 + v819 = get_local __ptr { ptr, u64 }, __anon_047, !590 + mem_copy_val v819, v818 + v820 = get_elem_ptr v819, __ptr ptr, v37, !594 + v821 = load v820, !590 + v822 = asm(s: v821) -> __ptr string<16> s { + } + v823 = get_local __ptr string<16>, __aggr_memcpy_019 + mem_copy_val v823, v822 + v824 = get_local __ptr { string<16> }, __anon_015, !595 + v825 = const u64 0 + v826 = get_elem_ptr v824, __ptr string<16>, v825, !596 + mem_copy_val v826, v823 + v827 = get_local __ptr { string<16> }, args_____________, !597 + mem_copy_val v827, v824 + v828 = get_local __ptr { string<16> }, args_____________, !598 + v829 = const u64 0 + v830 = get_elem_ptr v828, __ptr string<16>, v829, !599 + v831 = get_local __ptr string<16>, v_12, !602 + mem_copy_val v831, v830 + v832 = get_local __ptr string<16>, v_12, !604 + v833 = get_local __ptr string<16>, _result__________________________, !605 + mem_copy_val v833, v832 + v834 = get_local __ptr string<16>, _result__________________________, !606 + v835 = get_local __ptr string<16>, item_13, !609 + mem_copy_val v835, v834 + v836 = get_local __ptr string<16>, item_13, !610 + v837 = get_local __ptr { { ptr, u64, u64 } }, __ret_val21 + v838 = call new_21(v837) + v839 = get_local __ptr string<16>, __tmp_arg142 + mem_copy_val v839, v836 + v840 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg143 + mem_copy_val v840, v837 + v841 = get_local __ptr { { ptr, u64, u64 } }, __ret_val88 + v842 = call abi_encode_113(v839, v840, v841) + v843 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !611 + mem_copy_val v843, v841 + v844 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !612 + v845 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg72 + mem_copy_val v845, v844 + v846 = get_local __ptr slice, __ret_val50 + v847 = call as_raw_slice_22(v845, v846) + v848 = get_local __ptr slice, _result___________________________, !613 + mem_copy_val v848, v846 + v849 = get_local __ptr slice, _result___________________________, !614 + v850 = get_local __ptr slice, self_16, !617 + mem_copy_val v850, v849 + v851 = get_local __ptr slice, self_16, !618 + v852 = get_local __ptr slice, slice_16, !619 + mem_copy_val v852, v851 + v853 = get_local __ptr slice, slice_16, !620 + v854 = asm(ptr: v853) -> __ptr { ptr, u64 } ptr { + } + v855 = get_local __ptr { ptr, u64 }, __aggr_memcpy_020 + mem_copy_val v855, v854 + v856 = get_local __ptr { ptr, u64 }, __anon_048, !617 + mem_copy_val v856, v855 + v857 = get_elem_ptr v856, __ptr ptr, v37, !621 + v858 = load v857, !617 + v859 = get_local __ptr slice, _result___________________________, !622 + v860 = get_local __ptr slice, __tmp_arg102 + mem_copy_val v860, v859 + v861 = call len_30(v860) + retd v858 v861, !623 + + block40(): + v862 = get_local __ptr slice, _method_name, !624 + v863 = get_global __ptr string<9>, __const_global13 + v864 = cast_ptr v863 to ptr, !625 + v865 = get_local __ptr { ptr, u64 }, __anon_28, !625 + v866 = const u64 0 + v867 = get_elem_ptr v865, __ptr ptr, v866 + store v864 to v867, !625 + v868 = const u64 1 + v869 = get_elem_ptr v865, __ptr u64, v868 + v870 = const u64 9 + store v870 to v869, !625 + v871 = get_local __ptr slice, __anon_29, !625 + mem_copy_bytes v871, v865, 16 + v872 = get_local __ptr slice, __tmp_arg27 + mem_copy_val v872, v862 + v873 = get_local __ptr slice, __tmp_arg28 + mem_copy_val v873, v871 + v874 = call eq_11(v872, v873) + cbr v874, block42(), block43(), !626 + + block42(): + v875 = get_local __ptr { ptr }, _buffer, !627 + v876 = get_local __ptr slice, __ret_val3 + v877 = const u64 32 + v878 = call read_bytes_8(v875, v877, v876) + v879 = get_local __ptr slice, data3, !630 + mem_copy_val v879, v876 + v880 = get_local __ptr slice, data3, !631 + v881 = get_local __ptr slice, self_17, !632 + mem_copy_val v881, v880 + v882 = get_local __ptr slice, self_17, !633 + v883 = get_local __ptr slice, slice_17, !634 + mem_copy_val v883, v882 + v884 = get_local __ptr slice, slice_17, !635 + v885 = asm(ptr: v884) -> __ptr { ptr, u64 } ptr { + } + v886 = get_local __ptr { ptr, u64 }, __aggr_memcpy_021 + mem_copy_val v886, v885 + v887 = get_local __ptr { ptr, u64 }, __anon_049, !632 + mem_copy_val v887, v886 + v888 = get_elem_ptr v887, __ptr ptr, v37, !636 + v889 = load v888, !632 + v890 = asm(s: v889) -> __ptr string<32> s { + } + v891 = get_local __ptr string<32>, __aggr_memcpy_022 + mem_copy_val v891, v890 + v892 = get_local __ptr { string<32> }, __anon_016, !637 + v893 = const u64 0 + v894 = get_elem_ptr v892, __ptr string<32>, v893, !638 + mem_copy_val v894, v891 + v895 = get_local __ptr { string<32> }, args______________, !639 + mem_copy_val v895, v892 + v896 = get_local __ptr { string<32> }, args______________, !640 + v897 = const u64 0 + v898 = get_elem_ptr v896, __ptr string<32>, v897, !641 + v899 = get_local __ptr string<32>, v_13, !644 + mem_copy_val v899, v898 + v900 = get_local __ptr string<32>, v_13, !646 + v901 = get_local __ptr string<32>, _result____________________________, !647 + mem_copy_val v901, v900 + v902 = get_local __ptr string<32>, _result____________________________, !648 + v903 = get_local __ptr string<32>, item_14, !651 + mem_copy_val v903, v902 + v904 = get_local __ptr string<32>, item_14, !652 + v905 = get_local __ptr { { ptr, u64, u64 } }, __ret_val22 + v906 = call new_21(v905) + v907 = get_local __ptr string<32>, __tmp_arg144 + mem_copy_val v907, v904 + v908 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg145 + mem_copy_val v908, v905 + v909 = get_local __ptr { { ptr, u64, u64 } }, __ret_val89 + v910 = call abi_encode_119(v907, v908, v909) + v911 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !653 + mem_copy_val v911, v909 + v912 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !654 + v913 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg73 + mem_copy_val v913, v912 + v914 = get_local __ptr slice, __ret_val51 + v915 = call as_raw_slice_22(v913, v914) + v916 = get_local __ptr slice, _result_____________________________, !655 + mem_copy_val v916, v914 + v917 = get_local __ptr slice, _result_____________________________, !656 + v918 = get_local __ptr slice, self_18, !659 + mem_copy_val v918, v917 + v919 = get_local __ptr slice, self_18, !660 + v920 = get_local __ptr slice, slice_18, !661 + mem_copy_val v920, v919 + v921 = get_local __ptr slice, slice_18, !662 + v922 = asm(ptr: v921) -> __ptr { ptr, u64 } ptr { + } + v923 = get_local __ptr { ptr, u64 }, __aggr_memcpy_023 + mem_copy_val v923, v922 + v924 = get_local __ptr { ptr, u64 }, __anon_050, !659 + mem_copy_val v924, v923 + v925 = get_elem_ptr v924, __ptr ptr, v37, !663 + v926 = load v925, !659 + v927 = get_local __ptr slice, _result_____________________________, !664 + v928 = get_local __ptr slice, __tmp_arg103 + mem_copy_val v928, v927 + v929 = call len_30(v928) + retd v926 v929, !665 + + block43(): + v930 = get_local __ptr slice, _method_name, !666 + v931 = get_global __ptr string<8>, __const_global14 + v932 = cast_ptr v931 to ptr, !667 + v933 = get_local __ptr { ptr, u64 }, __anon_30, !667 + v934 = const u64 0 + v935 = get_elem_ptr v933, __ptr ptr, v934 + store v932 to v935, !667 + v936 = const u64 1 + v937 = get_elem_ptr v933, __ptr u64, v936 + v938 = const u64 8 + store v938 to v937, !667 + v939 = get_local __ptr slice, __anon_31, !667 + mem_copy_bytes v939, v933, 16 + v940 = get_local __ptr slice, __tmp_arg29 + mem_copy_val v940, v930 + v941 = get_local __ptr slice, __tmp_arg30 + mem_copy_val v941, v939 + v942 = call eq_11(v940, v941) + cbr v942, block45(), block46(), !668 + + block45(): + v943 = get_local __ptr { ptr }, _buffer, !669 + v944 = get_local __ptr slice, __ret_val4 + v945 = const u64 8 + v946 = call read_bytes_8(v943, v945, v944) + v947 = get_local __ptr slice, data4, !672 + mem_copy_val v947, v944 + v948 = get_local __ptr slice, data4, !673 + v949 = get_local __ptr slice, self_19, !674 + mem_copy_val v949, v948 + v950 = get_local __ptr slice, self_19, !675 + v951 = get_local __ptr slice, slice_19, !676 + mem_copy_val v951, v950 + v952 = get_local __ptr slice, slice_19, !677 + v953 = asm(ptr: v952) -> __ptr { ptr, u64 } ptr { + } + v954 = get_local __ptr { ptr, u64 }, __aggr_memcpy_024 + mem_copy_val v954, v953 + v955 = get_local __ptr { ptr, u64 }, __anon_051, !674 + mem_copy_val v955, v954 + v956 = get_elem_ptr v955, __ptr ptr, v37, !678 + v957 = load v956, !674 + v958 = asm(s: v957) -> __ptr string<8> s { + } + v959 = get_local __ptr string<8>, __aggr_memcpy_025 + mem_copy_val v959, v958 + v960 = get_local __ptr { string<8> }, __anon_017, !679 + v961 = const u64 0 + v962 = get_elem_ptr v960, __ptr string<8>, v961, !680 + mem_copy_val v962, v959 + v963 = get_local __ptr { string<8> }, args_______________, !681 + mem_copy_val v963, v960 + v964 = get_local __ptr { string<8> }, args_______________, !682 + v965 = const u64 0 + v966 = get_elem_ptr v964, __ptr string<8>, v965, !683 + v967 = get_local __ptr string<8>, v_14, !686 + mem_copy_val v967, v966 + v968 = get_local __ptr string<8>, v_14, !688 + v969 = get_local __ptr string<8>, _result______________________________, !689 + mem_copy_val v969, v968 + v970 = get_local __ptr string<8>, _result______________________________, !690 + v971 = get_local __ptr string<8>, item_15, !693 + mem_copy_val v971, v970 + v972 = get_local __ptr string<8>, item_15, !694 + v973 = get_local __ptr { { ptr, u64, u64 } }, __ret_val23 + v974 = call new_21(v973) + v975 = get_local __ptr string<8>, __tmp_arg146 + mem_copy_val v975, v972 + v976 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg147 + mem_copy_val v976, v973 + v977 = get_local __ptr { { ptr, u64, u64 } }, __ret_val90 + v978 = call abi_encode_125(v975, v976, v977) + v979 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !695 + mem_copy_val v979, v977 + v980 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !696 + v981 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg74 + mem_copy_val v981, v980 + v982 = get_local __ptr slice, __ret_val52 + v983 = call as_raw_slice_22(v981, v982) + v984 = get_local __ptr slice, _result_______________________________, !697 + mem_copy_val v984, v982 + v985 = get_local __ptr slice, _result_______________________________, !698 + v986 = get_local __ptr slice, self_20, !701 + mem_copy_val v986, v985 + v987 = get_local __ptr slice, self_20, !702 + v988 = get_local __ptr slice, slice_20, !703 + mem_copy_val v988, v987 + v989 = get_local __ptr slice, slice_20, !704 + v990 = asm(ptr: v989) -> __ptr { ptr, u64 } ptr { + } + v991 = get_local __ptr { ptr, u64 }, __aggr_memcpy_026 + mem_copy_val v991, v990 + v992 = get_local __ptr { ptr, u64 }, __anon_052, !701 + mem_copy_val v992, v991 + v993 = get_elem_ptr v992, __ptr ptr, v37, !705 + v994 = load v993, !701 + v995 = get_local __ptr slice, _result_______________________________, !706 + v996 = get_local __ptr slice, __tmp_arg104 + mem_copy_val v996, v995 + v997 = call len_30(v996) + retd v994 v997, !707 + + block46(): + v998 = get_local __ptr slice, _method_name, !708 + v999 = get_global __ptr string<13>, __const_global15 + v1000 = cast_ptr v999 to ptr, !709 + v1001 = get_local __ptr { ptr, u64 }, __anon_32, !709 + v1002 = const u64 0 + v1003 = get_elem_ptr v1001, __ptr ptr, v1002 + store v1000 to v1003, !709 + v1004 = const u64 1 + v1005 = get_elem_ptr v1001, __ptr u64, v1004 + v1006 = const u64 13 + store v1006 to v1005, !709 + v1007 = get_local __ptr slice, __anon_33, !709 + mem_copy_bytes v1007, v1001, 16 + v1008 = get_local __ptr slice, __tmp_arg31 + mem_copy_val v1008, v998 + v1009 = get_local __ptr slice, __tmp_arg32 + mem_copy_val v1009, v1007 + v1010 = call eq_11(v1008, v1009) + cbr v1010, block48(), block49(), !710 + + block48(): + v1011 = get_local __ptr { ptr }, _buffer, !711 + v1012 = get_local __ptr { u64 }, __ret_val91 + v1013 = call abi_decode_128(v1011, v1012) + v1014 = get_local __ptr { { u64 } }, __anon_018, !714 + v1015 = const u64 0 + v1016 = get_elem_ptr v1014, __ptr { u64 }, v1015, !715 + mem_copy_val v1016, v1012 + v1017 = get_local __ptr { { u64 } }, args________________, !716 + mem_copy_val v1017, v1014 + v1018 = get_local __ptr { { u64 } }, args________________, !717 + v1019 = const u64 0 + v1020 = get_elem_ptr v1018, __ptr { u64 }, v1019, !718 + v1021 = get_local __ptr { u64 }, v_15, !721 + mem_copy_val v1021, v1020 + v1022 = get_local __ptr { u64 }, v_15, !723 + v1023 = get_local __ptr { u64 }, _result________________________________, !724 + mem_copy_val v1023, v1022 + v1024 = get_local __ptr { u64 }, _result________________________________, !725 + v1025 = get_local __ptr { u64 }, item_16, !728 + mem_copy_val v1025, v1024 + v1026 = get_local __ptr { u64 }, item_16, !729 + v1027 = get_local __ptr { { ptr, u64, u64 } }, __ret_val24 + v1028 = call new_21(v1027) + v1029 = get_local __ptr { u64 }, __tmp_arg148 + mem_copy_val v1029, v1026 + v1030 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg149 + mem_copy_val v1030, v1027 + v1031 = get_local __ptr { { ptr, u64, u64 } }, __ret_val92 + v1032 = call abi_encode_131(v1029, v1030, v1031) + v1033 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !730 + mem_copy_val v1033, v1031 + v1034 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !731 + v1035 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg75 + mem_copy_val v1035, v1034 + v1036 = get_local __ptr slice, __ret_val53 + v1037 = call as_raw_slice_22(v1035, v1036) + v1038 = get_local __ptr slice, _result_________________________________, !732 + mem_copy_val v1038, v1036 + v1039 = get_local __ptr slice, _result_________________________________, !733 + v1040 = get_local __ptr slice, self_21, !736 + mem_copy_val v1040, v1039 + v1041 = get_local __ptr slice, self_21, !737 + v1042 = get_local __ptr slice, slice_21, !738 + mem_copy_val v1042, v1041 + v1043 = get_local __ptr slice, slice_21, !739 + v1044 = asm(ptr: v1043) -> __ptr { ptr, u64 } ptr { + } + v1045 = get_local __ptr { ptr, u64 }, __aggr_memcpy_027 + mem_copy_val v1045, v1044 + v1046 = get_local __ptr { ptr, u64 }, __anon_053, !736 + mem_copy_val v1046, v1045 + v1047 = get_elem_ptr v1046, __ptr ptr, v37, !740 + v1048 = load v1047, !736 + v1049 = get_local __ptr slice, _result_________________________________, !741 + v1050 = get_local __ptr slice, __tmp_arg105 + mem_copy_val v1050, v1049 + v1051 = call len_30(v1050) + retd v1048 v1051, !742 + + block49(): + v1052 = get_local __ptr slice, _method_name, !743 + v1053 = get_global __ptr string<17>, __const_global16 + v1054 = cast_ptr v1053 to ptr, !744 + v1055 = get_local __ptr { ptr, u64 }, __anon_34, !744 + v1056 = const u64 0 + v1057 = get_elem_ptr v1055, __ptr ptr, v1056 + store v1054 to v1057, !744 + v1058 = const u64 1 + v1059 = get_elem_ptr v1055, __ptr u64, v1058 + v1060 = const u64 17 + store v1060 to v1059, !744 + v1061 = get_local __ptr slice, __anon_35, !744 + mem_copy_bytes v1061, v1055, 16 + v1062 = get_local __ptr slice, __tmp_arg33 + mem_copy_val v1062, v1052 + v1063 = get_local __ptr slice, __tmp_arg34 + mem_copy_val v1063, v1061 + v1064 = call eq_11(v1062, v1063) + cbr v1064, block51(), block52(), !745 + + block51(): + v1065 = get_local __ptr { ptr }, _buffer, !746 + v1066 = get_local __ptr { u64, u64 }, __ret_val94 + v1067 = call abi_decode_134(v1065, v1066) + v1068 = get_local __ptr { { u64, u64 } }, __anon_019, !749 + v1069 = const u64 0 + v1070 = get_elem_ptr v1068, __ptr { u64, u64 }, v1069, !750 + mem_copy_val v1070, v1066 + v1071 = get_local __ptr { { u64, u64 } }, args_________________, !751 + mem_copy_val v1071, v1068 + v1072 = get_local __ptr { { u64, u64 } }, args_________________, !752 + v1073 = const u64 0 + v1074 = get_elem_ptr v1072, __ptr { u64, u64 }, v1073, !753 + v1075 = get_local __ptr { u64, u64 }, v_16, !756 + mem_copy_val v1075, v1074 + v1076 = get_local __ptr { u64, u64 }, v_16, !758 + v1077 = get_local __ptr { u64, u64 }, _result__________________________________, !759 + mem_copy_val v1077, v1076 + v1078 = get_local __ptr { u64, u64 }, _result__________________________________, !760 + v1079 = get_local __ptr { u64, u64 }, item_17, !763 + mem_copy_val v1079, v1078 + v1080 = get_local __ptr { u64, u64 }, item_17, !764 + v1081 = get_local __ptr { { ptr, u64, u64 } }, __ret_val25 + v1082 = call new_21(v1081) + v1083 = get_local __ptr { u64, u64 }, __tmp_arg156 + mem_copy_val v1083, v1080 + v1084 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg157 + mem_copy_val v1084, v1081 + v1085 = get_local __ptr { { ptr, u64, u64 } }, __ret_val98 + v1086 = call abi_encode_159(v1083, v1084, v1085) + v1087 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !765 + mem_copy_val v1087, v1085 + v1088 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !766 + v1089 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg76 + mem_copy_val v1089, v1088 + v1090 = get_local __ptr slice, __ret_val54 + v1091 = call as_raw_slice_22(v1089, v1090) + v1092 = get_local __ptr slice, _result___________________________________, !767 + mem_copy_val v1092, v1090 + v1093 = get_local __ptr slice, _result___________________________________, !768 + v1094 = get_local __ptr slice, self_22, !771 + mem_copy_val v1094, v1093 + v1095 = get_local __ptr slice, self_22, !772 + v1096 = get_local __ptr slice, slice_22, !773 + mem_copy_val v1096, v1095 + v1097 = get_local __ptr slice, slice_22, !774 + v1098 = asm(ptr: v1097) -> __ptr { ptr, u64 } ptr { + } + v1099 = get_local __ptr { ptr, u64 }, __aggr_memcpy_028 + mem_copy_val v1099, v1098 + v1100 = get_local __ptr { ptr, u64 }, __anon_054, !771 + mem_copy_val v1100, v1099 + v1101 = get_elem_ptr v1100, __ptr ptr, v37, !775 + v1102 = load v1101, !771 + v1103 = get_local __ptr slice, _result___________________________________, !776 + v1104 = get_local __ptr slice, __tmp_arg106 + mem_copy_val v1104, v1103 + v1105 = call len_30(v1104) + retd v1102 v1105, !777 + + block52(): + v1106 = get_local __ptr slice, _method_name, !778 + v1107 = get_global __ptr string<21>, __const_global17 + v1108 = cast_ptr v1107 to ptr, !779 + v1109 = get_local __ptr { ptr, u64 }, __anon_36, !779 + v1110 = const u64 0 + v1111 = get_elem_ptr v1109, __ptr ptr, v1110 + store v1108 to v1111, !779 + v1112 = const u64 1 + v1113 = get_elem_ptr v1109, __ptr u64, v1112 + v1114 = const u64 21 + store v1114 to v1113, !779 + v1115 = get_local __ptr slice, __anon_37, !779 + mem_copy_bytes v1115, v1109, 16 + v1116 = get_local __ptr slice, __tmp_arg35 + mem_copy_val v1116, v1106 + v1117 = get_local __ptr slice, __tmp_arg36 + mem_copy_val v1117, v1115 + v1118 = call eq_11(v1116, v1117) + cbr v1118, block54(), block55(), !780 + + block54(): + v1119 = get_local __ptr { ptr }, _buffer, !781 + v1120 = get_local __ptr { u64, u64, u64 }, __ret_val100 + v1121 = call abi_decode_162(v1119, v1120) + v1122 = get_local __ptr { { u64, u64, u64 } }, __anon_020, !784 + v1123 = const u64 0 + v1124 = get_elem_ptr v1122, __ptr { u64, u64, u64 }, v1123, !785 + mem_copy_val v1124, v1120 + v1125 = get_local __ptr { { u64, u64, u64 } }, args__________________, !786 + mem_copy_val v1125, v1122 + v1126 = get_local __ptr { { u64, u64, u64 } }, args__________________, !787 + v1127 = const u64 0 + v1128 = get_elem_ptr v1126, __ptr { u64, u64, u64 }, v1127, !788 + v1129 = get_local __ptr { u64, u64, u64 }, v_17, !791 + mem_copy_val v1129, v1128 + v1130 = get_local __ptr { u64, u64, u64 }, v_17, !793 + v1131 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !794 + mem_copy_val v1131, v1130 + v1132 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !795 + v1133 = get_local __ptr { u64, u64, u64 }, item_18, !798 + mem_copy_val v1133, v1132 + v1134 = get_local __ptr { u64, u64, u64 }, item_18, !799 + v1135 = get_local __ptr { { ptr, u64, u64 } }, __ret_val26 + v1136 = call new_21(v1135) + v1137 = get_local __ptr { u64, u64, u64 }, __tmp_arg152 + mem_copy_val v1137, v1134 + v1138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg153 + mem_copy_val v1138, v1135 + v1139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val96 + v1140 = call abi_encode_143(v1137, v1138, v1139) + v1141 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !800 + mem_copy_val v1141, v1139 + v1142 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !801 + v1143 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg77 + mem_copy_val v1143, v1142 + v1144 = get_local __ptr slice, __ret_val55 + v1145 = call as_raw_slice_22(v1143, v1144) + v1146 = get_local __ptr slice, _result_____________________________________, !802 + mem_copy_val v1146, v1144 + v1147 = get_local __ptr slice, _result_____________________________________, !803 + v1148 = get_local __ptr slice, self_23, !806 + mem_copy_val v1148, v1147 + v1149 = get_local __ptr slice, self_23, !807 + v1150 = get_local __ptr slice, slice_23, !808 + mem_copy_val v1150, v1149 + v1151 = get_local __ptr slice, slice_23, !809 + v1152 = asm(ptr: v1151) -> __ptr { ptr, u64 } ptr { + } + v1153 = get_local __ptr { ptr, u64 }, __aggr_memcpy_029 + mem_copy_val v1153, v1152 + v1154 = get_local __ptr { ptr, u64 }, __anon_055, !806 + mem_copy_val v1154, v1153 + v1155 = get_elem_ptr v1154, __ptr ptr, v37, !810 + v1156 = load v1155, !806 + v1157 = get_local __ptr slice, _result_____________________________________, !811 + v1158 = get_local __ptr slice, __tmp_arg107 + mem_copy_val v1158, v1157 + v1159 = call len_30(v1158) + retd v1156 v1159, !812 + + block55(): + v1160 = get_local __ptr slice, _method_name, !813 + v1161 = get_global __ptr string<10>, __const_global18 + v1162 = cast_ptr v1161 to ptr, !814 + v1163 = get_local __ptr { ptr, u64 }, __anon_38, !814 + v1164 = const u64 0 + v1165 = get_elem_ptr v1163, __ptr ptr, v1164 + store v1162 to v1165, !814 + v1166 = const u64 1 + v1167 = get_elem_ptr v1163, __ptr u64, v1166 + v1168 = const u64 10 + store v1168 to v1167, !814 + v1169 = get_local __ptr slice, __anon_39, !814 + mem_copy_bytes v1169, v1163, 16 + v1170 = get_local __ptr slice, __tmp_arg37 + mem_copy_val v1170, v1160 + v1171 = get_local __ptr slice, __tmp_arg38 + mem_copy_val v1171, v1169 + v1172 = call eq_11(v1170, v1171) + cbr v1172, block57(), block58(), !815 + + block57(): + v1173 = get_local __ptr { () }, __anon_021, !818 + v1174 = const u64 0 + v1175 = get_elem_ptr v1173, __ptr (), v1174, !819 + v1176 = const unit () + store v1176 to v1175, !820 + v1177 = get_local __ptr { () }, args___________________, !821 + mem_copy_val v1177, v1173 + v1178 = asm() -> ptr zero, !822 { + } + v1179 = const u64 0, !823 + retd v1178 v1179, !824 + + block58(): + v1180 = get_local __ptr slice, _method_name, !825 + v1181 = get_global __ptr string<10>, __const_global19 + v1182 = cast_ptr v1181 to ptr, !826 + v1183 = get_local __ptr { ptr, u64 }, __anon_40, !826 + v1184 = const u64 0 + v1185 = get_elem_ptr v1183, __ptr ptr, v1184 + store v1182 to v1185, !826 + v1186 = const u64 1 + v1187 = get_elem_ptr v1183, __ptr u64, v1186 + v1188 = const u64 10 + store v1188 to v1187, !826 + v1189 = get_local __ptr slice, __anon_41, !826 + mem_copy_bytes v1189, v1183, 16 + v1190 = get_local __ptr slice, __tmp_arg39 + mem_copy_val v1190, v1180 + v1191 = get_local __ptr slice, __tmp_arg40 + mem_copy_val v1191, v1189 + v1192 = call eq_11(v1190, v1191) + cbr v1192, block60(), block61(), !827 + + block60(): + v1193 = get_local __ptr { ptr }, _buffer, !828 + v1194 = get_elem_ptr v1193, __ptr ptr, v19, !833 + v1195 = load v1194, !834 + v1196 = asm(ptr: v1195, val) -> u64 val, !835 { + lw val ptr i0, !58 + } + v1197 = load v1194, !834 + v1198 = const u64 8, !834 + v1199 = add v1197, v1198, !834 + store v1199 to v1194, !836 + v1200 = get_local __ptr { u64 }, __anon_001, !837 + v1201 = const u64 0 + v1202 = get_elem_ptr v1200, __ptr u64, v1201, !838 + store v1196 to v1202, !839 + v1203 = get_local __ptr { { u64 } }, __anon_022, !840 + v1204 = const u64 0 + v1205 = get_elem_ptr v1203, __ptr { u64 }, v1204, !841 + mem_copy_val v1205, v1200 + v1206 = get_local __ptr { { u64 } }, args____________________, !842 + mem_copy_val v1206, v1203 + v1207 = get_local __ptr { { u64 } }, args____________________, !843 + v1208 = const u64 0 + v1209 = get_elem_ptr v1207, __ptr { u64 }, v1208, !844 + v1210 = get_local __ptr { u64 }, v_19, !847 + mem_copy_val v1210, v1209 + v1211 = get_local __ptr { u64 }, v_19, !848 + v1212 = get_local __ptr { u64 }, _result_______________________________________, !849 + mem_copy_val v1212, v1211 + v1213 = get_local __ptr { u64 }, _result_______________________________________, !850 + v1214 = get_local __ptr { u64 }, item_19, !853 + mem_copy_val v1214, v1213 + v1215 = get_local __ptr { u64 }, item_19, !854 + v1216 = get_local __ptr { { ptr, u64, u64 } }, __ret_val27 + v1217 = call new_21(v1216) + v1218 = get_local __ptr { u64 }, __tmp_arg150 + mem_copy_val v1218, v1215 + v1219 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg151 + mem_copy_val v1219, v1216 + v1220 = get_local __ptr { { ptr, u64, u64 } }, __ret_val93 + v1221 = call abi_encode_131(v1218, v1219, v1220) + v1222 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !855 + mem_copy_val v1222, v1220 + v1223 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !856 + v1224 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg78 + mem_copy_val v1224, v1223 + v1225 = get_local __ptr slice, __ret_val56 + v1226 = call as_raw_slice_22(v1224, v1225) + v1227 = get_local __ptr slice, _result________________________________________, !857 + mem_copy_val v1227, v1225 + v1228 = get_local __ptr slice, _result________________________________________, !858 + v1229 = get_local __ptr slice, self_24, !861 + mem_copy_val v1229, v1228 + v1230 = get_local __ptr slice, self_24, !862 + v1231 = get_local __ptr slice, slice_24, !863 + mem_copy_val v1231, v1230 + v1232 = get_local __ptr slice, slice_24, !864 + v1233 = asm(ptr: v1232) -> __ptr { ptr, u64 } ptr { + } + v1234 = get_local __ptr { ptr, u64 }, __aggr_memcpy_030 + mem_copy_val v1234, v1233 + v1235 = get_local __ptr { ptr, u64 }, __anon_056, !861 + mem_copy_val v1235, v1234 + v1236 = get_elem_ptr v1235, __ptr ptr, v37, !865 + v1237 = load v1236, !861 + v1238 = get_local __ptr slice, _result________________________________________, !866 + v1239 = get_local __ptr slice, __tmp_arg108 + mem_copy_val v1239, v1238 + v1240 = call len_30(v1239) + retd v1237 v1240, !867 + + block61(): + v1241 = get_local __ptr slice, _method_name, !868 + v1242 = get_global __ptr string<10>, __const_global20 + v1243 = cast_ptr v1242 to ptr, !869 + v1244 = get_local __ptr { ptr, u64 }, __anon_42, !869 + v1245 = const u64 0 + v1246 = get_elem_ptr v1244, __ptr ptr, v1245 + store v1243 to v1246, !869 + v1247 = const u64 1 + v1248 = get_elem_ptr v1244, __ptr u64, v1247 + v1249 = const u64 10 + store v1249 to v1248, !869 + v1250 = get_local __ptr slice, __anon_43, !869 + mem_copy_bytes v1250, v1244, 16 + v1251 = get_local __ptr slice, __tmp_arg41 + mem_copy_val v1251, v1241 + v1252 = get_local __ptr slice, __tmp_arg42 + mem_copy_val v1252, v1250 + v1253 = call eq_11(v1251, v1252) + cbr v1253, block63(), block64(), !870 + + block63(): + v1254 = get_local __ptr { ptr }, _buffer, !871 + v1255 = get_local __ptr { u64, u64 }, __ret_val95 + v1256 = call abi_decode_134(v1254, v1255) + v1257 = get_local __ptr { { u64, u64 } }, __anon_023, !874 + v1258 = const u64 0 + v1259 = get_elem_ptr v1257, __ptr { u64, u64 }, v1258, !875 + mem_copy_val v1259, v1255 + v1260 = get_local __ptr { { u64, u64 } }, args_____________________, !876 + mem_copy_val v1260, v1257 + v1261 = get_local __ptr { { u64, u64 } }, args_____________________, !877 + v1262 = const u64 0 + v1263 = get_elem_ptr v1261, __ptr { u64, u64 }, v1262, !878 + v1264 = get_local __ptr { u64, u64 }, v_20, !881 + mem_copy_val v1264, v1263 + v1265 = get_local __ptr { u64, u64 }, v_20, !882 + v1266 = get_local __ptr { u64, u64 }, _result_________________________________________, !883 + mem_copy_val v1266, v1265 + v1267 = get_local __ptr { u64, u64 }, _result_________________________________________, !884 + v1268 = get_local __ptr { u64, u64 }, item_20, !887 + mem_copy_val v1268, v1267 + v1269 = get_local __ptr { u64, u64 }, item_20, !888 + v1270 = get_local __ptr { { ptr, u64, u64 } }, __ret_val28 + v1271 = call new_21(v1270) + v1272 = get_local __ptr { u64, u64 }, __tmp_arg158 + mem_copy_val v1272, v1269 + v1273 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg159 + mem_copy_val v1273, v1270 + v1274 = get_local __ptr { { ptr, u64, u64 } }, __ret_val99 + v1275 = call abi_encode_159(v1272, v1273, v1274) + v1276 = get_local __ptr { { ptr, u64, u64 } }, buffer21, !889 + mem_copy_val v1276, v1274 + v1277 = get_local __ptr { { ptr, u64, u64 } }, buffer21, !890 + v1278 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg79 + mem_copy_val v1278, v1277 + v1279 = get_local __ptr slice, __ret_val57 + v1280 = call as_raw_slice_22(v1278, v1279) + v1281 = get_local __ptr slice, _result__________________________________________, !891 + mem_copy_val v1281, v1279 + v1282 = get_local __ptr slice, _result__________________________________________, !892 + v1283 = get_local __ptr slice, self_25, !895 + mem_copy_val v1283, v1282 + v1284 = get_local __ptr slice, self_25, !896 + v1285 = get_local __ptr slice, slice_25, !897 + mem_copy_val v1285, v1284 + v1286 = get_local __ptr slice, slice_25, !898 + v1287 = asm(ptr: v1286) -> __ptr { ptr, u64 } ptr { + } + v1288 = get_local __ptr { ptr, u64 }, __aggr_memcpy_031 + mem_copy_val v1288, v1287 + v1289 = get_local __ptr { ptr, u64 }, __anon_057, !895 + mem_copy_val v1289, v1288 + v1290 = get_elem_ptr v1289, __ptr ptr, v37, !899 + v1291 = load v1290, !895 + v1292 = get_local __ptr slice, _result__________________________________________, !900 + v1293 = get_local __ptr slice, __tmp_arg109 + mem_copy_val v1293, v1292 + v1294 = call len_30(v1293) + retd v1291 v1294, !901 + + block64(): + v1295 = get_local __ptr slice, _method_name, !902 + v1296 = get_global __ptr string<10>, __const_global21 + v1297 = cast_ptr v1296 to ptr, !903 + v1298 = get_local __ptr { ptr, u64 }, __anon_44, !903 + v1299 = const u64 0 + v1300 = get_elem_ptr v1298, __ptr ptr, v1299 + store v1297 to v1300, !903 + v1301 = const u64 1 + v1302 = get_elem_ptr v1298, __ptr u64, v1301 + v1303 = const u64 10 + store v1303 to v1302, !903 + v1304 = get_local __ptr slice, __anon_45, !903 + mem_copy_bytes v1304, v1298, 16 + v1305 = get_local __ptr slice, __tmp_arg43 + mem_copy_val v1305, v1295 + v1306 = get_local __ptr slice, __tmp_arg44 + mem_copy_val v1306, v1304 + v1307 = call eq_11(v1305, v1306) + cbr v1307, block66(), block67(), !904 + + block66(): + v1308 = get_local __ptr { ptr }, _buffer, !905 + v1309 = get_local __ptr { u64, u64, u64 }, __ret_val101 + v1310 = call abi_decode_162(v1308, v1309) + v1311 = get_local __ptr { { u64, u64, u64 } }, __anon_024, !908 + v1312 = const u64 0 + v1313 = get_elem_ptr v1311, __ptr { u64, u64, u64 }, v1312, !909 + mem_copy_val v1313, v1309 + v1314 = get_local __ptr { { u64, u64, u64 } }, args______________________, !910 + mem_copy_val v1314, v1311 + v1315 = get_local __ptr { { u64, u64, u64 } }, args______________________, !911 + v1316 = const u64 0 + v1317 = get_elem_ptr v1315, __ptr { u64, u64, u64 }, v1316, !912 + v1318 = get_local __ptr { u64, u64, u64 }, v_21, !915 + mem_copy_val v1318, v1317 + v1319 = get_local __ptr { u64, u64, u64 }, v_21, !916 + v1320 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !917 + mem_copy_val v1320, v1319 + v1321 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !918 + v1322 = get_local __ptr { u64, u64, u64 }, item_21, !921 + mem_copy_val v1322, v1321 + v1323 = get_local __ptr { u64, u64, u64 }, item_21, !922 + v1324 = get_local __ptr { { ptr, u64, u64 } }, __ret_val29 + v1325 = call new_21(v1324) + v1326 = get_local __ptr { u64, u64, u64 }, __tmp_arg154 + mem_copy_val v1326, v1323 + v1327 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg155 + mem_copy_val v1327, v1324 + v1328 = get_local __ptr { { ptr, u64, u64 } }, __ret_val97 + v1329 = call abi_encode_143(v1326, v1327, v1328) + v1330 = get_local __ptr { { ptr, u64, u64 } }, buffer22, !923 + mem_copy_val v1330, v1328 + v1331 = get_local __ptr { { ptr, u64, u64 } }, buffer22, !924 + v1332 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg80 + mem_copy_val v1332, v1331 + v1333 = get_local __ptr slice, __ret_val58 + v1334 = call as_raw_slice_22(v1332, v1333) + v1335 = get_local __ptr slice, _result____________________________________________, !925 + mem_copy_val v1335, v1333 + v1336 = get_local __ptr slice, _result____________________________________________, !926 + v1337 = get_local __ptr slice, self_26, !929 + mem_copy_val v1337, v1336 + v1338 = get_local __ptr slice, self_26, !930 + v1339 = get_local __ptr slice, slice_26, !931 + mem_copy_val v1339, v1338 + v1340 = get_local __ptr slice, slice_26, !932 + v1341 = asm(ptr: v1340) -> __ptr { ptr, u64 } ptr { + } + v1342 = get_local __ptr { ptr, u64 }, __aggr_memcpy_032 + mem_copy_val v1342, v1341 + v1343 = get_local __ptr { ptr, u64 }, __anon_058, !929 + mem_copy_val v1343, v1342 + v1344 = get_elem_ptr v1343, __ptr ptr, v37, !933 + v1345 = load v1344, !929 + v1346 = get_local __ptr slice, _result____________________________________________, !934 + v1347 = get_local __ptr slice, __tmp_arg110 + mem_copy_val v1347, v1346 + v1348 = call len_30(v1347) + retd v1345 v1348, !935 + + block67(): + v1349 = get_local __ptr slice, _method_name, !936 + v1350 = get_global __ptr string<10>, __const_global22 + v1351 = cast_ptr v1350 to ptr, !937 + v1352 = get_local __ptr { ptr, u64 }, __anon_46, !937 + v1353 = const u64 0 + v1354 = get_elem_ptr v1352, __ptr ptr, v1353 + store v1351 to v1354, !937 + v1355 = const u64 1 + v1356 = get_elem_ptr v1352, __ptr u64, v1355 + v1357 = const u64 10 + store v1357 to v1356, !937 + v1358 = get_local __ptr slice, __anon_47, !937 + mem_copy_bytes v1358, v1352, 16 + v1359 = get_local __ptr slice, __tmp_arg45 + mem_copy_val v1359, v1349 + v1360 = get_local __ptr slice, __tmp_arg46 + mem_copy_val v1360, v1358 + v1361 = call eq_11(v1359, v1360) + cbr v1361, block69(), block70(), !938 + + block69(): + v1362 = get_local __ptr { ptr }, _buffer, !939 + v1363 = get_local __ptr { u64, u64, u64, u64 }, __ret_val102 + v1364 = call abi_decode_168(v1362, v1363) + v1365 = get_local __ptr { { u64, u64, u64, u64 } }, __anon_025, !942 + v1366 = const u64 0 + v1367 = get_elem_ptr v1365, __ptr { u64, u64, u64, u64 }, v1366, !943 + mem_copy_val v1367, v1363 + v1368 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !944 + mem_copy_val v1368, v1365 + v1369 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !945 + v1370 = const u64 0 + v1371 = get_elem_ptr v1369, __ptr { u64, u64, u64, u64 }, v1370, !946 + v1372 = get_local __ptr { u64, u64, u64, u64 }, v_22, !949 + mem_copy_val v1372, v1371 + v1373 = get_local __ptr { u64, u64, u64, u64 }, v_22, !951 + v1374 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !952 + mem_copy_val v1374, v1373 + v1375 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !953 + v1376 = get_local __ptr { u64, u64, u64, u64 }, item_22, !956 + mem_copy_val v1376, v1375 + v1377 = get_local __ptr { u64, u64, u64, u64 }, item_22, !957 + v1378 = get_local __ptr { { ptr, u64, u64 } }, __ret_val30 + v1379 = call new_21(v1378) + v1380 = get_local __ptr { u64, u64, u64, u64 }, __tmp_arg160 + mem_copy_val v1380, v1377 + v1381 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg161 + mem_copy_val v1381, v1378 + v1382 = get_local __ptr { { ptr, u64, u64 } }, __ret_val103 + v1383 = call abi_encode_171(v1380, v1381, v1382) + v1384 = get_local __ptr { { ptr, u64, u64 } }, buffer23, !958 + mem_copy_val v1384, v1382 + v1385 = get_local __ptr { { ptr, u64, u64 } }, buffer23, !959 + v1386 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg81 + mem_copy_val v1386, v1385 + v1387 = get_local __ptr slice, __ret_val59 + v1388 = call as_raw_slice_22(v1386, v1387) + v1389 = get_local __ptr slice, _result______________________________________________, !960 + mem_copy_val v1389, v1387 + v1390 = get_local __ptr slice, _result______________________________________________, !961 + v1391 = get_local __ptr slice, self_27, !964 + mem_copy_val v1391, v1390 + v1392 = get_local __ptr slice, self_27, !965 + v1393 = get_local __ptr slice, slice_27, !966 + mem_copy_val v1393, v1392 + v1394 = get_local __ptr slice, slice_27, !967 + v1395 = asm(ptr: v1394) -> __ptr { ptr, u64 } ptr { + } + v1396 = get_local __ptr { ptr, u64 }, __aggr_memcpy_033 + mem_copy_val v1396, v1395 + v1397 = get_local __ptr { ptr, u64 }, __anon_059, !964 + mem_copy_val v1397, v1396 + v1398 = get_elem_ptr v1397, __ptr ptr, v37, !968 + v1399 = load v1398, !964 + v1400 = get_local __ptr slice, _result______________________________________________, !969 + v1401 = get_local __ptr slice, __tmp_arg111 + mem_copy_val v1401, v1400 + v1402 = call len_30(v1401) + retd v1399 v1402, !970 + + block70(): + v1403 = get_local __ptr slice, _method_name, !971 + v1404 = get_global __ptr string<6>, __const_global23 + v1405 = cast_ptr v1404 to ptr, !972 + v1406 = get_local __ptr { ptr, u64 }, __anon_48, !972 + v1407 = const u64 0 + v1408 = get_elem_ptr v1406, __ptr ptr, v1407 + store v1405 to v1408, !972 + v1409 = const u64 1 + v1410 = get_elem_ptr v1406, __ptr u64, v1409 + v1411 = const u64 6 + store v1411 to v1410, !972 + v1412 = get_local __ptr slice, __anon_49, !972 + mem_copy_bytes v1412, v1406, 16 + v1413 = get_local __ptr slice, __tmp_arg47 + mem_copy_val v1413, v1403 + v1414 = get_local __ptr slice, __tmp_arg48 + mem_copy_val v1414, v1412 + v1415 = call eq_11(v1413, v1414) + cbr v1415, block72(), block73(), !973 + + block72(): + v1416 = get_local __ptr { ptr }, _buffer, !974 + v1417 = call read_72(v1416), !979 + v1418 = asm(input: v1417) -> u64 input, !983 { + } + v1419 = call read_72(v1416), !986 + v1420 = asm(input: v1419) -> u64 input, !989 { + } + v1421 = const u64 8, !990 + v1422 = lsh v1418, v1421, !993 + v1423 = const u64 65535, !995 + v1424 = and v1422, v1423, !996 + v1425 = or v1424, v1420, !999 + v1426 = get_local __ptr { u64 }, __anon_026, !1000 + v1427 = const u64 0 + v1428 = get_elem_ptr v1426, __ptr u64, v1427, !1001 + store v1425 to v1428, !1002 + v1429 = get_local __ptr { u64 }, args________________________, !1003 + mem_copy_val v1429, v1426 + v1430 = get_local __ptr { u64 }, args________________________, !1004 + v1431 = const u64 0 + v1432 = get_elem_ptr v1430, __ptr u64, v1431, !1005 + v1433 = load v1432 + v1434 = get_local __ptr { { ptr, u64, u64 } }, __ret_val31 + v1435 = call new_21(v1434) + v1436 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg162 + mem_copy_val v1436, v1434 + v1437 = get_local __ptr { { ptr, u64, u64 } }, __ret_val104 + v1438 = call abi_encode_181(v1433, v1436, v1437) + v1439 = get_local __ptr { { ptr, u64, u64 } }, buffer24, !1008 + mem_copy_val v1439, v1437 + v1440 = get_local __ptr { { ptr, u64, u64 } }, buffer24, !1009 + v1441 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg82 + mem_copy_val v1441, v1440 + v1442 = get_local __ptr slice, __ret_val60 + v1443 = call as_raw_slice_22(v1441, v1442) + v1444 = get_local __ptr slice, _result________________________________________________, !1010 + mem_copy_val v1444, v1442 + v1445 = get_local __ptr slice, _result________________________________________________, !1011 + v1446 = get_local __ptr slice, self_28, !1014 + mem_copy_val v1446, v1445 + v1447 = get_local __ptr slice, self_28, !1015 + v1448 = get_local __ptr slice, slice_28, !1016 + mem_copy_val v1448, v1447 + v1449 = get_local __ptr slice, slice_28, !1017 + v1450 = asm(ptr: v1449) -> __ptr { ptr, u64 } ptr { + } + v1451 = get_local __ptr { ptr, u64 }, __aggr_memcpy_034 + mem_copy_val v1451, v1450 + v1452 = get_local __ptr { ptr, u64 }, __anon_060, !1014 + mem_copy_val v1452, v1451 + v1453 = get_elem_ptr v1452, __ptr ptr, v37, !1018 + v1454 = load v1453, !1014 + v1455 = get_local __ptr slice, _result________________________________________________, !1019 + v1456 = get_local __ptr slice, __tmp_arg112 + mem_copy_val v1456, v1455 + v1457 = call len_30(v1456) + retd v1454 v1457, !1020 + + block73(): + v1458 = get_local __ptr slice, _method_name, !1021 + v1459 = get_global __ptr string<7>, __const_global24 + v1460 = cast_ptr v1459 to ptr, !1022 + v1461 = get_local __ptr { ptr, u64 }, __anon_50, !1022 + v1462 = const u64 0 + v1463 = get_elem_ptr v1461, __ptr ptr, v1462 + store v1460 to v1463, !1022 + v1464 = const u64 1 + v1465 = get_elem_ptr v1461, __ptr u64, v1464 + v1466 = const u64 7 + store v1466 to v1465, !1022 + v1467 = get_local __ptr slice, __anon_51, !1022 + mem_copy_bytes v1467, v1461, 16 + v1468 = get_local __ptr slice, __tmp_arg49 + mem_copy_val v1468, v1458 + v1469 = get_local __ptr slice, __tmp_arg50 + mem_copy_val v1469, v1467 + v1470 = call eq_11(v1468, v1469) + cbr v1470, block75(), block76(), !1023 + + block75(): + v1471 = get_local __ptr { ptr }, _buffer, !1024 + v1472 = get_local __ptr u256, __ret_val105 + v1473 = call abi_decode_184(v1471, v1472) + v1474 = get_local __ptr { u256 }, __anon_027, !1027 + v1475 = const u64 0 + v1476 = get_elem_ptr v1474, __ptr u256, v1475, !1028 + mem_copy_val v1476, v1472 + v1477 = get_local __ptr { u256 }, args_________________________, !1029 + mem_copy_val v1477, v1474 + v1478 = get_local __ptr { u256 }, args_________________________, !1030 + v1479 = const u64 0 + v1480 = get_elem_ptr v1478, __ptr u256, v1479, !1031 + v1481 = get_local __ptr u256, v_24, !1034 + mem_copy_val v1481, v1480 + v1482 = get_local __ptr u256, v_24, !1036 + v1483 = get_local __ptr u256, _result_________________________________________________, !1037 + mem_copy_val v1483, v1482 + v1484 = get_local __ptr u256, _result_________________________________________________, !1038 + v1485 = get_local __ptr u256, item_24, !1041 + mem_copy_val v1485, v1484 + v1486 = get_local __ptr u256, item_24, !1042 + v1487 = get_local __ptr { { ptr, u64, u64 } }, __ret_val32 + v1488 = call new_21(v1487) + v1489 = get_local __ptr u256, __tmp_arg163 + mem_copy_val v1489, v1486 + v1490 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg164 + mem_copy_val v1490, v1487 + v1491 = get_local __ptr { { ptr, u64, u64 } }, __ret_val106 + v1492 = call abi_encode_188(v1489, v1490, v1491) + v1493 = get_local __ptr { { ptr, u64, u64 } }, buffer25, !1043 + mem_copy_val v1493, v1491 + v1494 = get_local __ptr { { ptr, u64, u64 } }, buffer25, !1044 + v1495 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg83 + mem_copy_val v1495, v1494 + v1496 = get_local __ptr slice, __ret_val61 + v1497 = call as_raw_slice_22(v1495, v1496) + v1498 = get_local __ptr slice, _result__________________________________________________, !1045 + mem_copy_val v1498, v1496 + v1499 = get_local __ptr slice, _result__________________________________________________, !1046 + v1500 = get_local __ptr slice, self_29, !1049 + mem_copy_val v1500, v1499 + v1501 = get_local __ptr slice, self_29, !1050 + v1502 = get_local __ptr slice, slice_29, !1051 + mem_copy_val v1502, v1501 + v1503 = get_local __ptr slice, slice_29, !1052 + v1504 = asm(ptr: v1503) -> __ptr { ptr, u64 } ptr { + } + v1505 = get_local __ptr { ptr, u64 }, __aggr_memcpy_035 + mem_copy_val v1505, v1504 + v1506 = get_local __ptr { ptr, u64 }, __anon_061, !1049 + mem_copy_val v1506, v1505 + v1507 = get_elem_ptr v1506, __ptr ptr, v37, !1053 + v1508 = load v1507, !1049 + v1509 = get_local __ptr slice, _result__________________________________________________, !1054 + v1510 = get_local __ptr slice, __tmp_arg113 + mem_copy_val v1510, v1509 + v1511 = call len_30(v1510) + retd v1508 v1511, !1055 + + block76(): + v1512 = get_local __ptr slice, _method_name, !1056 + v1513 = get_global __ptr string<6>, __const_global25 + v1514 = cast_ptr v1513 to ptr, !1057 + v1515 = get_local __ptr { ptr, u64 }, __anon_52, !1057 + v1516 = const u64 0 + v1517 = get_elem_ptr v1515, __ptr ptr, v1516 + store v1514 to v1517, !1057 + v1518 = const u64 1 + v1519 = get_elem_ptr v1515, __ptr u64, v1518 + v1520 = const u64 6 + store v1520 to v1519, !1057 + v1521 = get_local __ptr slice, __anon_53, !1057 + mem_copy_bytes v1521, v1515, 16 + v1522 = get_local __ptr slice, __tmp_arg51 + mem_copy_val v1522, v1512 + v1523 = get_local __ptr slice, __tmp_arg52 + mem_copy_val v1523, v1521 + v1524 = call eq_11(v1522, v1523) + cbr v1524, block78(), block79(), !1058 + + block78(): + v1525 = get_local __ptr { ptr }, _buffer, !1059 + v1526 = call abi_decode_191(v1525), !1062 + v1527 = get_local __ptr { u64 }, __anon_028, !1063 + v1528 = const u64 0 + v1529 = get_elem_ptr v1527, __ptr u64, v1528, !1064 + store v1526 to v1529, !1065 + v1530 = get_local __ptr { u64 }, args__________________________, !1066 + mem_copy_val v1530, v1527 + v1531 = get_local __ptr { u64 }, args__________________________, !1067 + v1532 = const u64 0 + v1533 = get_elem_ptr v1531, __ptr u64, v1532, !1068 + v1534 = load v1533 + v1535 = get_local __ptr { { ptr, u64, u64 } }, __ret_val33 + v1536 = call new_21(v1535) + v1537 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg165 + mem_copy_val v1537, v1535 + v1538 = get_local __ptr { { ptr, u64, u64 } }, __ret_val107 + v1539 = call abi_encode_198(v1534, v1537, v1538) + v1540 = get_local __ptr { { ptr, u64, u64 } }, buffer26, !1071 + mem_copy_val v1540, v1538 + v1541 = get_local __ptr { { ptr, u64, u64 } }, buffer26, !1072 + v1542 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg84 + mem_copy_val v1542, v1541 + v1543 = get_local __ptr slice, __ret_val62 + v1544 = call as_raw_slice_22(v1542, v1543) + v1545 = get_local __ptr slice, _result____________________________________________________, !1073 + mem_copy_val v1545, v1543 + v1546 = get_local __ptr slice, _result____________________________________________________, !1074 + v1547 = get_local __ptr slice, self_30, !1077 + mem_copy_val v1547, v1546 + v1548 = get_local __ptr slice, self_30, !1078 + v1549 = get_local __ptr slice, slice_30, !1079 + mem_copy_val v1549, v1548 + v1550 = get_local __ptr slice, slice_30, !1080 + v1551 = asm(ptr: v1550) -> __ptr { ptr, u64 } ptr { + } + v1552 = get_local __ptr { ptr, u64 }, __aggr_memcpy_036 + mem_copy_val v1552, v1551 + v1553 = get_local __ptr { ptr, u64 }, __anon_062, !1077 + mem_copy_val v1553, v1552 + v1554 = get_elem_ptr v1553, __ptr ptr, v37, !1081 + v1555 = load v1554, !1077 + v1556 = get_local __ptr slice, _result____________________________________________________, !1082 + v1557 = get_local __ptr slice, __tmp_arg114 + mem_copy_val v1557, v1556 + v1558 = call len_30(v1557) + retd v1555 v1558, !1083 + + block79(): + v1559 = get_local __ptr slice, _method_name, !1084 + v1560 = get_global __ptr string<6>, __const_global26 + v1561 = cast_ptr v1560 to ptr, !1085 + v1562 = get_local __ptr { ptr, u64 }, __anon_54, !1085 + v1563 = const u64 0 + v1564 = get_elem_ptr v1562, __ptr ptr, v1563 + store v1561 to v1564, !1085 + v1565 = const u64 1 + v1566 = get_elem_ptr v1562, __ptr u64, v1565 + v1567 = const u64 6 + store v1567 to v1566, !1085 + v1568 = get_local __ptr slice, __anon_55, !1085 + mem_copy_bytes v1568, v1562, 16 + v1569 = get_local __ptr slice, __tmp_arg53 + mem_copy_val v1569, v1559 + v1570 = get_local __ptr slice, __tmp_arg54 + mem_copy_val v1570, v1568 + v1571 = call eq_11(v1569, v1570) + cbr v1571, block81(), block82(), !1086 + + block81(): + v1572 = get_local __ptr { ptr }, _buffer, !1087 + v1573 = get_elem_ptr v1572, __ptr ptr, v19, !1090 + v1574 = load v1573, !1091 + v1575 = asm(ptr: v1574, val) -> u64 val, !1092 { + lw val ptr i0, !58 + } + v1576 = load v1573, !1091 + v1577 = const u64 8, !1091 + v1578 = add v1576, v1577, !1091 + store v1578 to v1573, !1093 + v1579 = get_local __ptr { u64 }, __anon_029, !1094 + v1580 = get_elem_ptr v1579, __ptr u64, v1201, !1095 + store v1575 to v1580, !1096 + v1581 = get_local __ptr { u64 }, args___________________________, !1097 + mem_copy_val v1581, v1579 + v1582 = get_local __ptr { u64 }, args___________________________, !1098 + v1583 = const u64 0 + v1584 = get_elem_ptr v1582, __ptr u64, v1583, !1099 + v1585 = load v1584 + v1586 = get_local __ptr { { ptr, u64, u64 } }, __ret_val34 + v1587 = call new_21(v1586) + v1588 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg57 + mem_copy_val v1588, v1586 + v1589 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v1590 = call abi_encode_20(v1585, v1588, v1589) + v1591 = get_local __ptr { { ptr, u64, u64 } }, buffer27, !1102 + mem_copy_val v1591, v1589 + v1592 = get_local __ptr { { ptr, u64, u64 } }, buffer27, !1103 + v1593 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg85 + mem_copy_val v1593, v1592 + v1594 = get_local __ptr slice, __ret_val63 + v1595 = call as_raw_slice_22(v1593, v1594) + v1596 = get_local __ptr slice, _result______________________________________________________, !1104 + mem_copy_val v1596, v1594 + v1597 = get_local __ptr slice, _result______________________________________________________, !1105 + v1598 = get_local __ptr slice, self_31, !1108 + mem_copy_val v1598, v1597 + v1599 = get_local __ptr slice, self_31, !1109 + v1600 = get_local __ptr slice, slice_31, !1110 + mem_copy_val v1600, v1599 + v1601 = get_local __ptr slice, slice_31, !1111 + v1602 = asm(ptr: v1601) -> __ptr { ptr, u64 } ptr { + } + v1603 = get_local __ptr { ptr, u64 }, __aggr_memcpy_037 + mem_copy_val v1603, v1602 + v1604 = get_local __ptr { ptr, u64 }, __anon_063, !1108 + mem_copy_val v1604, v1603 + v1605 = get_elem_ptr v1604, __ptr ptr, v37, !1112 + v1606 = load v1605, !1108 + v1607 = get_local __ptr slice, _result______________________________________________________, !1113 + v1608 = get_local __ptr slice, __tmp_arg115 + mem_copy_val v1608, v1607 + v1609 = call len_30(v1608) + retd v1606 v1609, !1114 + + block82(): + v1610 = get_local __ptr slice, _method_name, !1115 + v1611 = get_global __ptr string<5>, __const_global27 + v1612 = cast_ptr v1611 to ptr, !1116 + v1613 = get_local __ptr { ptr, u64 }, __anon_56, !1116 + v1614 = const u64 0 + v1615 = get_elem_ptr v1613, __ptr ptr, v1614 + store v1612 to v1615, !1116 + v1616 = const u64 1 + v1617 = get_elem_ptr v1613, __ptr u64, v1616 + v1618 = const u64 5 + store v1618 to v1617, !1116 + v1619 = get_local __ptr slice, __anon_57, !1116 + mem_copy_bytes v1619, v1613, 16 + v1620 = get_local __ptr slice, __tmp_arg55 + mem_copy_val v1620, v1610 + v1621 = get_local __ptr slice, __tmp_arg56 + mem_copy_val v1621, v1619 + v1622 = call eq_11(v1620, v1621) + cbr v1622, block84(), block85(), !1117 + + block84(): + v1623 = get_local __ptr { ptr }, _buffer, !1118 + v1624 = call read_72(v1623), !1123 + v1625 = get_local __ptr { u8 }, __anon_030, !1124 + v1626 = const u64 0 + v1627 = get_elem_ptr v1625, __ptr u8, v1626, !1125 + store v1624 to v1627, !1126 + v1628 = get_local __ptr { u8 }, args____________________________, !1127 + mem_copy_val v1628, v1625 + v1629 = get_local __ptr { u8 }, args____________________________, !1128 + v1630 = const u64 0 + v1631 = get_elem_ptr v1629, __ptr u8, v1630, !1129 + v1632 = load v1631 + v1633 = get_local __ptr { { ptr, u64, u64 } }, __ret_val35 + v1634 = call new_21(v1633) + v1635 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg166 + mem_copy_val v1635, v1633 + v1636 = get_local __ptr { { ptr, u64, u64 } }, __ret_val108 + v1637 = call abi_encode_206(v1632, v1635, v1636) + v1638 = get_local __ptr { { ptr, u64, u64 } }, buffer28, !1132 + mem_copy_val v1638, v1636 + v1639 = get_local __ptr { { ptr, u64, u64 } }, buffer28, !1133 + v1640 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg86 + mem_copy_val v1640, v1639 + v1641 = get_local __ptr slice, __ret_val64 + v1642 = call as_raw_slice_22(v1640, v1641) + v1643 = get_local __ptr slice, _result________________________________________________________, !1134 + mem_copy_val v1643, v1641 + v1644 = get_local __ptr slice, _result________________________________________________________, !1135 + v1645 = get_local __ptr slice, self_32, !1138 + mem_copy_val v1645, v1644 + v1646 = get_local __ptr slice, self_32, !1139 + v1647 = get_local __ptr slice, slice_32, !1140 + mem_copy_val v1647, v1646 + v1648 = get_local __ptr slice, slice_32, !1141 + v1649 = asm(ptr: v1648) -> __ptr { ptr, u64 } ptr { + } + v1650 = get_local __ptr { ptr, u64 }, __aggr_memcpy_038 + mem_copy_val v1650, v1649 + v1651 = get_local __ptr { ptr, u64 }, __anon_064, !1138 + mem_copy_val v1651, v1650 + v1652 = get_elem_ptr v1651, __ptr ptr, v37, !1142 + v1653 = load v1652, !1138 + v1654 = get_local __ptr slice, _result________________________________________________________, !1143 + v1655 = get_local __ptr slice, __tmp_arg116 + mem_copy_val v1655, v1654 + v1656 = call len_30(v1655) + retd v1653 v1656, !1144 + + block85(): + v1657 = const u64 123, !1145 + revert v1657, !1146 + } + + pub fn read_bytes_8(self !1147: __ptr { ptr }, count !1148: u64, __ret_value: __ptr slice) -> (), !1151 { + local mut slice __aggr_memcpy_0 + local { ptr, u64 } __anon_0 + local slice slice + + entry(self: __ptr { ptr }, count: u64, __ret_value: __ptr slice): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr ptr, v0, !53 + v2 = get_local __ptr { ptr, u64 }, __anon_0, !1152 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr ptr, v3, !1152 + mem_copy_val v4, v1 + v5 = const u64 1 + v6 = get_elem_ptr v2, __ptr u64, v5, !1152 + store count to v6, !1152 + v7 = asm(ptr: v2) -> __ptr slice ptr { + } + v8 = get_local __ptr slice, __aggr_memcpy_0 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, slice, !1153 + mem_copy_val v9, v8 + v10 = load v1 + v11 = add v10, count + store v11 to v1, !1154 + v12 = get_local __ptr slice, slice, !1155 + mem_copy_val __ret_value, v12 + v13 = const unit () + ret () v13 + } + + pub fn eq_11(self: __ptr slice, other: __ptr slice) -> bool, !1159 { + local slice __tmp_arg + local slice __tmp_arg0 + local slice __tmp_arg1 + local slice __tmp_arg2 + local slice __tmp_arg3 + local slice other_ + local slice self_ + + entry(self: __ptr slice, other: __ptr slice): + v0 = get_local __ptr slice, self_ + mem_copy_val v0, self + v1 = get_local __ptr slice, other_ + mem_copy_val v1, other + v2 = get_local __ptr slice, self_, !1160 + v3 = get_local __ptr slice, __tmp_arg + mem_copy_val v3, v2 + v4 = call len_14(v3) + v5 = get_local __ptr slice, other_, !1161 + v6 = get_local __ptr slice, __tmp_arg0 + mem_copy_val v6, v5 + v7 = call len_14(v6) + v8 = cmp eq v4 v7, !1166 + v9 = const bool false, !1167 + v10 = cmp eq v8 v9, !1170 + v11 = const bool false, !1171 + cbr v10, block2(v11), block1(), !1162 + + block1(): + v12 = get_local __ptr slice, self_, !1172 + v13 = get_local __ptr slice, __tmp_arg2 + mem_copy_val v13, v12 + v14 = call as_ptr_15(v13) + v15 = get_local __ptr slice, other_, !1173 + v16 = get_local __ptr slice, __tmp_arg3 + mem_copy_val v16, v15 + v17 = call as_ptr_15(v16) + v18 = get_local __ptr slice, self_, !1174 + v19 = get_local __ptr slice, __tmp_arg1 + mem_copy_val v19, v18 + v20 = call len_14(v19) + v21 = asm(r1: v14, r2: v17, r3: v20, r4) -> bool r4, !1175 { + meq r4 r1 r2 r3, !1176 + } + br block2(v21) + + block2(v22: bool): + ret bool v22 + } + + pub fn len_14(self: __ptr slice) -> u64, !1180 { + local slice self_ + + entry(self: __ptr slice): + v0 = get_local __ptr slice, self_ + mem_copy_val v0, self + v1 = get_local __ptr slice, self_, !1181 + v2 = asm(s: v1) -> __ptr { ptr, u64 } s { + } + v3 = const u64 1 + v4 = get_elem_ptr v2, __ptr u64, v3 + v5 = load v4 + ret u64 v5 + } + + pub fn as_ptr_15(self: __ptr slice) -> ptr, !1184 { + local slice self_ + + entry(self: __ptr slice): + v0 = get_local __ptr slice, self_ + mem_copy_val v0, self + v1 = get_local __ptr slice, self_, !1185 + v2 = asm(s: v1) -> __ptr { ptr, u64 } s { + } + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr ptr, v3 + v5 = load v4 + ret ptr v5 + } + + pub fn abi_decode_18(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 0]) -> (), !1190 { + local [u8; 0] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 0] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 0]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 0, !1191 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1193 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1194 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 0], __anon_0, !1195 + mem_clear_val v13 + v14 = get_local __ptr [u8; 0], array, !1196 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 0], array, !1197 + v16 = cast_ptr v15 to __ptr [u64; 0] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 0 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1199 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1200 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !1201 + br while(v30) + + while(v31: u64): + v32 = const u64 0 + v33 = cmp lt v31 v32, !1204 + cbr v33, while_body(), end_while() + + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !1205 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1206 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1207 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !1210 + v51 = load v50, !1211 + v52 = asm(ptr: v51, val) -> u64 val, !1212 { + lw val ptr i0, !58 + } + v53 = load v50, !1211 + v54 = const u64 8, !1211 + v55 = add v53, v54, !1211 + store v55 to v50, !1213 + store v52 to v48, !1214 + v56 = const u64 1, !1215 + v57 = add v31, v56, !1218 + br while(v57) + + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } + + pub fn abi_encode_20(self !1219: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1222 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local { ptr, u64, u64 } __anon_1 + local { { ptr, u64, u64 } } __anon_2 + local { { ptr, u64, u64 } } buffer_ + + entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1223 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v5, v4 + v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v6, v5 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr ptr, v7 + v9 = load v8 + v10 = const u64 1 + v11 = get_elem_ptr v6, __ptr u64, v10 + v12 = load v11 + v13 = const u64 2 + v14 = get_elem_ptr v6, __ptr u64, v13 + v15 = load v14 + v16 = const u64 8 + v17 = add v15, v16 + v18 = cmp gt v17 v12 + cbr v18, block1(), block0(v9, v12) + + block0(v19: ptr, v20: u64): + v21 = add v19, v15 + v22 = cast_ptr v21 to __ptr u64 + store self to v22 + v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 + v24 = const u64 0 + v25 = get_elem_ptr v23, __ptr ptr, v24 + store v19 to v25 + v26 = const u64 1 + v27 = get_elem_ptr v23, __ptr u64, v26 + store v20 to v27 + v28 = const u64 2 + v29 = get_elem_ptr v23, __ptr u64, v28 + store v17 to v29 + v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { + } + v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v31, v30 + v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !1225 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 + mem_copy_val v34, v31 + mem_copy_val __ret_value, v32 + v35 = const unit () + ret () v35 + + block1(): + v36 = const u64 2 + v37 = mul v12, v36 + v38 = add v37, v16 + v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v39, v38) + } + + pub fn new_21(__ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1228 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local { ptr, u64, u64 } __anon_0 + local { { ptr, u64, u64 } } __anon_1 + + entry(__ret_value: __ptr { { ptr, u64, u64 } }): + v0 = const u64 1024 + v1 = asm(cap: v0) -> ptr hp { + aloc cap + } + v2 = get_local __ptr { ptr, u64, u64 }, __anon_0 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr ptr, v3 + store v1 to v4 + v5 = const u64 1 + v6 = get_elem_ptr v2, __ptr u64, v5 + store v0 to v6 + v7 = const u64 2 + v8 = get_elem_ptr v2, __ptr u64, v7 + v9 = const u64 0 + store v9 to v8 + v10 = asm(buffer: v2) -> __ptr { ptr, u64, u64 } buffer { + } + v11 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v11, v10 + v12 = get_local __ptr { { ptr, u64, u64 } }, __anon_1, !1229 + v13 = const u64 0 + v14 = get_elem_ptr v12, __ptr { ptr, u64, u64 }, v13 + mem_copy_val v14, v11 + mem_copy_val __ret_value, v12 + v15 = const unit () + ret () v15 + } + + pub fn as_raw_slice_22(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice) -> (), !1232 { + local mut slice __aggr_memcpy_00 + local { ptr, u64 } __anon_1 + local { { ptr, u64, u64 } } self_ + + entry(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, self_, !1233 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + v7 = load v6 + v8 = const u64 2 + v9 = get_elem_ptr v4, __ptr u64, v8 + v10 = load v9 + v11 = get_local __ptr { ptr, u64 }, __anon_1 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr ptr, v12 + v14 = get_elem_ptr v13, __ptr ptr, + store v7 to v14 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15 + v17 = get_elem_ptr v16, __ptr u64, + store v10 to v17 + v18 = asm(s: v11) -> __ptr slice s { + } + v19 = get_local __ptr slice, __aggr_memcpy_00 + mem_copy_val v19, v18 + mem_copy_val __ret_value, v19 + v20 = const unit () + ret () v20 + } + + pub fn abi_encode_29(self: __ptr [u64; 0], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1236 { + local { { ptr, u64, u64 } } __ret_val + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 0] self_ + + entry(self: __ptr [u64; 0], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr [u64; 0], self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 + mem_copy_val v1, buffer + v2 = const u64 0, !1238 + br while(v2) + + while(v3: u64): + v4 = const u64 0 + v5 = cmp lt v3 v4, !1241 + cbr v5, while_body(), end_while() + + while_body(): + v6 = get_local __ptr [u64; 0], self_, !1242 + v7 = get_elem_ptr v6, __ptr u64, v3, !1243 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 + mem_copy_val v12, v10 + v13 = const u64 1, !1246 + v14 = add v3, v13, !1249 + br while(v14) + + end_while(): + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 + mem_copy_val __ret_value, v15 + v16 = const unit () + ret () v16 + } + + pub fn len_30(self: __ptr slice) -> u64, !1253 { + local slice slice_ + + entry(self: __ptr slice): + v0 = get_local __ptr slice, slice_, !1256 + mem_copy_val v0, self + v1 = get_local __ptr slice, slice_, !1257 + v2 = asm(ptr: v1) -> __ptr { ptr, u64 } ptr { + } + v3 = const u64 1 + v4 = get_elem_ptr v2, __ptr u64, v3 + v5 = load v4 + ret u64 v5 + } + + pub fn abi_decode_34(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 1]) -> (), !1258 { + local [u8; 1] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 1] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 1]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 1, !1191 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1259 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1260 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 1], __anon_0, !1195 + mem_clear_val v13 + v14 = get_local __ptr [u8; 1], array, !1196 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 1], array, !1197 + v16 = cast_ptr v15 to __ptr [u64; 1] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 1 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1261 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1262 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !1201 + br while(v30) + + while(v31: u64): + v32 = const u64 1 + v33 = cmp lt v31 v32, !1263 + cbr v33, while_body(), end_while() + + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !1205 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1264 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1265 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !1266 + v51 = load v50, !1267 + v52 = asm(ptr: v51, val) -> u64 val, !1268 { + lw val ptr i0, !58 + } + v53 = load v50, !1267 + v54 = const u64 8, !1267 + v55 = add v53, v54, !1267 + store v55 to v50, !1269 + store v52 to v48, !1214 + v56 = const u64 1, !1215 + v57 = add v31, v56, !1270 + br while(v57) + + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } + + pub fn abi_encode_37(self: __ptr [u64; 1], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1271 { + local { { ptr, u64, u64 } } __ret_val + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 1] self_ + + entry(self: __ptr [u64; 1], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr [u64; 1], self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 + mem_copy_val v1, buffer + v2 = const u64 0, !1238 + br while(v2) + + while(v3: u64): + v4 = const u64 1 + v5 = cmp lt v3 v4, !1272 + cbr v5, while_body(), end_while() + + while_body(): + v6 = get_local __ptr [u64; 1], self_, !1242 + v7 = get_elem_ptr v6, __ptr u64, v3, !1243 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 + mem_copy_val v12, v10 + v13 = const u64 1, !1246 + v14 = add v3, v13, !1273 + br while(v14) + + end_while(): + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 + mem_copy_val __ret_value, v15 + v16 = const unit () + ret () v16 + } + + pub fn abi_decode_40(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 16]) -> (), !1274 { + local [u8; 16] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 16] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 16]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 16, !1191 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1275 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1276 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 16], __anon_0, !1195 + mem_clear_val v13 + v14 = get_local __ptr [u8; 16], array, !1196 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 16], array, !1197 + v16 = cast_ptr v15 to __ptr [u64; 16] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 16 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1277 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1278 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !1201 + br while(v30) + + while(v31: u64): + v32 = const u64 16 + v33 = cmp lt v31 v32, !1279 + cbr v33, while_body(), end_while() + + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !1205 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1280 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1281 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !1282 + v51 = load v50, !1283 + v52 = asm(ptr: v51, val) -> u64 val, !1284 { + lw val ptr i0, !58 + } + v53 = load v50, !1283 + v54 = const u64 8, !1283 + v55 = add v53, v54, !1283 + store v55 to v50, !1285 + store v52 to v48, !1214 + v56 = const u64 1, !1215 + v57 = add v31, v56, !1286 + br while(v57) + + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } + + pub fn abi_encode_43(self: __ptr [u64; 16], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1287 { + local { { ptr, u64, u64 } } __ret_val + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 16] self_ + + entry(self: __ptr [u64; 16], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr [u64; 16], self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 + mem_copy_val v1, buffer + v2 = const u64 0, !1238 + br while(v2) + + while(v3: u64): + v4 = const u64 16 + v5 = cmp lt v3 v4, !1288 + cbr v5, while_body(), end_while() + + while_body(): + v6 = get_local __ptr [u64; 16], self_, !1242 + v7 = get_elem_ptr v6, __ptr u64, v3, !1243 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 + mem_copy_val v12, v10 + v13 = const u64 1, !1246 + v14 = add v3, v13, !1289 + br while(v14) + + end_while(): + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 + mem_copy_val __ret_value, v15 + v16 = const unit () + ret () v16 + } + + pub fn abi_decode_46(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 32]) -> (), !1290 { + local [u8; 32] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 32] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 32]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 32, !1191 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1291 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1292 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 32], __anon_0, !1195 + mem_clear_val v13 + v14 = get_local __ptr [u8; 32], array, !1196 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 32], array, !1197 + v16 = cast_ptr v15 to __ptr [u64; 32] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 32 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1293 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1294 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !1201 + br while(v30) + + while(v31: u64): + v32 = const u64 32 + v33 = cmp lt v31 v32, !1295 + cbr v33, while_body(), end_while() + + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !1205 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1296 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1297 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !1298 + v51 = load v50, !1299 + v52 = asm(ptr: v51, val) -> u64 val, !1300 { + lw val ptr i0, !58 + } + v53 = load v50, !1299 + v54 = const u64 8, !1299 + v55 = add v53, v54, !1299 + store v55 to v50, !1301 + store v52 to v48, !1214 + v56 = const u64 1, !1215 + v57 = add v31, v56, !1302 + br while(v57) + + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } + + pub fn abi_encode_49(self: __ptr [u64; 32], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1303 { + local { { ptr, u64, u64 } } __ret_val + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 32] self_ + + entry(self: __ptr [u64; 32], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr [u64; 32], self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 + mem_copy_val v1, buffer + v2 = const u64 0, !1238 + br while(v2) + + while(v3: u64): + v4 = const u64 32 + v5 = cmp lt v3 v4, !1304 + cbr v5, while_body(), end_while() + + while_body(): + v6 = get_local __ptr [u64; 32], self_, !1242 + v7 = get_elem_ptr v6, __ptr u64, v3, !1243 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 + mem_copy_val v12, v10 + v13 = const u64 1, !1246 + v14 = add v3, v13, !1305 + br while(v14) + + end_while(): + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 + mem_copy_val __ret_value, v15 + v16 = const unit () + ret () v16 + } + + pub fn abi_decode_52(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 64]) -> (), !1306 { + local [u8; 64] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 64] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 64]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 64, !1191 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1307 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1308 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 64], __anon_0, !1195 + mem_clear_val v13 + v14 = get_local __ptr [u8; 64], array, !1196 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 64], array, !1197 + v16 = cast_ptr v15 to __ptr [u64; 64] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 64 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1309 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1310 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !1201 + br while(v30) + + while(v31: u64): + v32 = const u64 64 + v33 = cmp lt v31 v32, !1311 + cbr v33, while_body(), end_while() + + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !1205 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1312 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1313 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !1314 + v51 = load v50, !1315 + v52 = asm(ptr: v51, val) -> u64 val, !1316 { + lw val ptr i0, !58 + } + v53 = load v50, !1315 + v54 = const u64 8, !1315 + v55 = add v53, v54, !1315 + store v55 to v50, !1317 + store v52 to v48, !1214 + v56 = const u64 1, !1215 + v57 = add v31, v56, !1318 + br while(v57) + + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } + + pub fn abi_encode_55(self: __ptr [u64; 64], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1319 { + local { { ptr, u64, u64 } } __ret_val + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 64] self_ + + entry(self: __ptr [u64; 64], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr [u64; 64], self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 + mem_copy_val v1, buffer + v2 = const u64 0, !1238 + br while(v2) + + while(v3: u64): + v4 = const u64 64 + v5 = cmp lt v3 v4, !1320 + cbr v5, while_body(), end_while() + + while_body(): + v6 = get_local __ptr [u64; 64], self_, !1242 + v7 = get_elem_ptr v6, __ptr u64, v3, !1243 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 + mem_copy_val v12, v10 + v13 = const u64 1, !1246 + v14 = add v3, v13, !1321 + br while(v14) + + end_while(): + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 + mem_copy_val __ret_value, v15 + v16 = const unit () + ret () v16 + } + + pub fn abi_decode_58(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 8]) -> (), !1322 { + local [u8; 8] __anon_0 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local slice __ret_val5 + local slice __ret_val6 + local slice __ret_val7 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local mut [u8; 8] array + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 8]): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v2, v0 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = const u64 8, !1191 + v5 = call abi_encode_20(v4, v2, v3) + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1323 + mem_copy_val v6, v3 + v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1324 + v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v8, v7 + v9 = get_local __ptr slice, __ret_val5 + v10 = call as_raw_slice_22(v8, v9) + v11 = get_local __ptr slice, __log_arg + mem_copy_val v11, v9 + v12 = const u64 1515152261580153489 + log __ptr slice v11, v12 + v13 = get_local __ptr [u8; 8], __anon_0, !1195 + mem_clear_val v13 + v14 = get_local __ptr [u8; 8], array, !1196 + mem_copy_val v14, v13 + v15 = get_local __ptr [u8; 8], array, !1197 + v16 = cast_ptr v15 to __ptr [u64; 8] + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v18 = call new_21(v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v19, v17 + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = const u64 8 + v22 = call abi_encode_20(v21, v19, v20) + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1325 + mem_copy_val v23, v20 + v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1326 + v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v25, v24 + v26 = get_local __ptr slice, __ret_val6 + v27 = call as_raw_slice_22(v25, v26) + v28 = get_local __ptr slice, __log_arg0 + mem_copy_val v28, v26 + v29 = const u64 1515152261580153489 + log __ptr slice v28, v29 + v30 = const u64 0, !1201 + br while(v30) + + while(v31: u64): + v32 = const u64 8 + v33 = cmp lt v31 v32, !1327 + cbr v33, while_body(), end_while() + + while_body(): + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v35 = call new_21(v34) + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v38 = const u64 2, !1205 + v39 = call abi_encode_20(v38, v36, v37) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1328 + mem_copy_val v40, v37 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1329 + v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, __ret_val7 + v44 = call as_raw_slice_22(v42, v43) + v45 = get_local __ptr slice, __log_arg1 + mem_copy_val v45, v43 + v46 = const u64 1515152261580153489 + log __ptr slice v45, v46 + v47 = const u64 8 + v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { + mul offset_temp idx elem_ir_type_size + add ptr_out ptr offset_temp + } + v49 = const u64 0 + v50 = get_elem_ptr buffer, __ptr ptr, v49, !1330 + v51 = load v50, !1331 + v52 = asm(ptr: v51, val) -> u64 val, !1332 { + lw val ptr i0, !58 + } + v53 = load v50, !1331 + v54 = const u64 8, !1331 + v55 = add v53, v54, !1331 + store v55 to v50, !1333 + store v52 to v48, !1214 + v56 = const u64 1, !1215 + v57 = add v31, v56, !1334 + br while(v57) + + end_while(): + mem_copy_val __ret_value, v16 + v58 = const unit () + ret () v58 + } + + pub fn abi_encode_61(self: __ptr [u64; 8], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1335 { + local { { ptr, u64, u64 } } __ret_val + local mut { { ptr, u64, u64 } } buffer__ + local [u64; 8] self_ + + entry(self: __ptr [u64; 8], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr [u64; 8], self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 + mem_copy_val v1, buffer + v2 = const u64 0, !1238 + br while(v2) + + while(v3: u64): + v4 = const u64 8 + v5 = cmp lt v3 v4, !1336 + cbr v5, while_body(), end_while() + + while_body(): + v6 = get_local __ptr [u64; 8], self_, !1242 + v7 = get_elem_ptr v6, __ptr u64, v3, !1243 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 + mem_copy_val v12, v10 + v13 = const u64 1, !1246 + v14 = add v3, v13, !1337 + br while(v14) + + end_while(): + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 + mem_copy_val __ret_value, v15 + v16 = const unit () + ret () v16 + } + + pub fn abi_decode_64(buffer !1338: __ptr { ptr }, __ret_value: __ptr b256) -> (), !1341 { + local mut b256 __aggr_memcpy_0 + local b256 v + + entry(buffer: __ptr { ptr }, __ret_value: __ptr b256): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1344 + v2 = load v1, !1345 + v3 = asm(ptr: v2) -> __ptr b256 ptr { + } + v4 = get_local __ptr b256, __aggr_memcpy_0 + mem_copy_val v4, v3 + v5 = get_local __ptr b256, v, !1347 + mem_copy_val v5, v4 + v6 = load v1, !1345 + v7 = const u64 32, !1345 + v8 = add v6, v7, !1345 + store v8 to v1, !1349 + v9 = get_local __ptr b256, v, !1351 + mem_copy_val __ret_value, v9 + v10 = const unit () + ret () v10 + } + + pub fn abi_encode_68(self: __ptr b256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1354 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local b256 __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local b256 self_ + + entry(self: __ptr b256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr b256, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1355 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr b256, self_, !1356 + v18 = const u64 32 + v19 = add v16, v18 + v20 = cmp gt v19 v13 + cbr v20, block1(), block0(v10, v13) + + block0(v21: ptr, v22: u64): + v23 = get_local __ptr b256, __anon_1 + mem_copy_val v23, v17 + v24 = add v21, v16 + v25 = cast_ptr v24 to __ptr u8 + mem_copy_bytes v25, v23, 32 + v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v27 = const u64 0 + v28 = get_elem_ptr v26, __ptr ptr, v27 + store v21 to v28 + v29 = const u64 1 + v30 = get_elem_ptr v26, __ptr u64, v29 + store v22 to v30 + v31 = const u64 2 + v32 = get_elem_ptr v26, __ptr u64, v31 + store v19 to v32 + v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { + } + v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1357 + v36 = const u64 0 + v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 + mem_copy_val v37, v34 + mem_copy_val __ret_value, v35 + v38 = const unit () + ret () v38 + + block1(): + v39 = const u64 2 + v40 = mul v13, v39 + v41 = add v40, v18 + v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v42, v41) + } + + pub fn read_72(self !1358: __ptr { ptr }) -> u8, !1361 { + entry(self: __ptr { ptr }): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr ptr, v0, !53 + v2 = load v1 + v3 = asm(ptr: v2, val) -> u8 val, !1362 { + lb val ptr i0, !1363 + } + v4 = load v1 + v5 = const u64 1 + v6 = add v4, v5 + store v6 to v1, !1364 + ret u8 v3 + } + + pub fn abi_encode_77(self !1365: bool, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1368 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local { ptr, u64, u64 } __anon_1 + local { { ptr, u64, u64 } } __anon_2 + local { { ptr, u64, u64 } } buffer_ + + entry(self: bool, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1369 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v5, v4 + v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v6, v5 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr ptr, v7 + v9 = load v8 + v10 = const u64 1 + v11 = get_elem_ptr v6, __ptr u64, v10 + v12 = load v11 + v13 = const u64 2 + v14 = get_elem_ptr v6, __ptr u64, v13 + v15 = load v14 + v16 = const u64 1 + v17 = add v15, v16 + v18 = cmp gt v17 v12 + cbr v18, block1(), block0(v9, v12) + + block0(v19: ptr, v20: u64): + v21 = add v19, v15 + v22 = cast_ptr v21 to __ptr bool + store self to v22 + v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 + v24 = const u64 0 + v25 = get_elem_ptr v23, __ptr ptr, v24 + store v19 to v25 + v26 = const u64 1 + v27 = get_elem_ptr v23, __ptr u64, v26 + store v20 to v27 + v28 = const u64 2 + v29 = get_elem_ptr v23, __ptr u64, v28 + store v17 to v29 + v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { + } + v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v31, v30 + v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !1370 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 + mem_copy_val v34, v31 + mem_copy_val __ret_value, v32 + v35 = const unit () + ret () v35 + + block1(): + v36 = const u64 2 + v37 = mul v12, v36 + v38 = add v37, v16 + v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v39, v38) + } + + pub fn abi_decode_80(buffer !1371: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 ) }) -> (), !1374 { + local { u64, ( u64 ) } __anon_0 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 ) }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1377 + v2 = load v1, !1378 + v3 = asm(ptr: v2, val) -> u64 val, !1379 { + lw val ptr i0, !58 + } + v4 = load v1, !1378 + v5 = const u64 8, !1378 + v6 = add v4, v5, !1378 + store v6 to v1, !1380 + v7 = const u64 0, !1381 + v8 = cmp eq v3 v7, !1384 + cbr v8, block0(), block1(), !1382 + + block0(): + v9 = get_local __ptr { u64, ( u64 ) }, __anon_0, !1385 + v10 = const u64 0 + v11 = get_elem_ptr v9, __ptr u64, v10, !1385 + v12 = const u64 0, !1385 + store v12 to v11, !1385 + v13 = load v1, !1388 + v14 = asm(ptr: v13, val) -> u64 val, !1389 { + lw val ptr i0, !58 + } + v15 = load v1, !1388 + v16 = const u64 8, !1388 + v17 = add v15, v16, !1388 + store v17 to v1, !1390 + v18 = const u64 1 + v19 = const u64 0 + v20 = get_elem_ptr v9, __ptr u64, v18, v19, !1385 + store v14 to v20, !1385 + mem_copy_val __ret_value, v9 + v21 = const unit () + ret () v21 + + block1(): + v22 = const u64 0, !1391 + revert v22, !1392 + } + + pub fn abi_encode_83(self: __ptr { u64, ( u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1394 { + local { u64, ( u64 ) } __matched_value_1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + + entry(self: __ptr { u64, ( u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { u64, ( u64 ) }, __matched_value_1, !1395 + mem_copy_val v1, self + v2 = const u64 0 + v3 = get_elem_ptr self, __ptr u64, v2 + v4 = load v3 + v5 = const u64 0, !1396 + v6 = cmp eq v4 v5, !1399 + cbr v6, block0(), block1(), !1397 + + block0(): + v7 = get_local __ptr { u64, ( u64 ) }, __matched_value_1, !1396 + v8 = const u64 1 + v9 = const u64 0 + v10 = get_elem_ptr v7, __ptr u64, v8, v9 + v11 = load v10 + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1400 + v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v14 = const u64 0, !1401 + v15 = call abi_encode_20(v14, v12, v13) + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1402 + mem_copy_val v16, v13 + v17 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v18 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v19 = call abi_encode_20(v11, v17, v18) + v20 = const u64 0 + v21 = const u64 0 + v22 = get_elem_ptr v18, __ptr ptr, v20, v21 + v23 = load v22 + v24 = const u64 0 + v25 = const u64 1 + v26 = get_elem_ptr v18, __ptr u64, v24, v25 + v27 = load v26 + v28 = const u64 0 + v29 = const u64 2 + v30 = get_elem_ptr v18, __ptr u64, v28, v29 + v31 = load v30 + v32 = const u64 0 + v33 = const u64 0 + v34 = get_elem_ptr __ret_value, __ptr ptr, v32, v33 + store v23 to v34 + v35 = const u64 0 + v36 = const u64 1 + v37 = get_elem_ptr __ret_value, __ptr u64, v35, v36 + store v27 to v37 + v38 = const u64 0 + v39 = const u64 2 + v40 = get_elem_ptr __ret_value, __ptr u64, v38, v39 + store v31 to v40 + v41 = const unit () + ret () v41 + + block1(): + v42 = const u64 14757395258967588866, !1395 + revert v42, !1395 + } + + pub fn abi_decode_86(buffer !1403: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 ) }) -> (), !1406 { + local { u64, ( u64 | u64 ) } __anon_0 + local { u64, ( u64 | u64 ) } __anon_1 + local { u64, ( u64 | u64 ) } __tmp_block_arg + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 ) }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1409 + v2 = load v1, !1410 + v3 = asm(ptr: v2, val) -> u64 val, !1411 { + lw val ptr i0, !58 + } + v4 = load v1, !1410 + v5 = const u64 8, !1410 + v6 = add v4, v5, !1410 + store v6 to v1, !1412 + v7 = const u64 0, !1413 + v8 = cmp eq v3 v7, !1416 + cbr v8, block0(), block1(), !1414 + + block0(): + v9 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_0, !1417 + v10 = const u64 0 + v11 = get_elem_ptr v9, __ptr u64, v10, !1417 + v12 = const u64 0, !1417 + store v12 to v11, !1417 + v13 = load v1, !1420 + v14 = asm(ptr: v13, val) -> u64 val, !1421 { + lw val ptr i0, !58 + } + v15 = load v1, !1420 + v16 = const u64 8, !1420 + v17 = add v15, v16, !1420 + store v17 to v1, !1422 + v18 = const u64 1 + v19 = const u64 0 + v20 = get_elem_ptr v9, __ptr u64, v18, v19, !1417 + store v14 to v20, !1417 + v21 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg + mem_copy_val v21, v9 + br block5(v21) + + block1(): + v22 = const u64 1, !1423 + v23 = cmp eq v3 v22, !1426 + cbr v23, block2(), block3(), !1424 + + block2(): + v24 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_1, !1417 + v25 = const u64 0 + v26 = get_elem_ptr v24, __ptr u64, v25, !1417 + v27 = const u64 1, !1417 + store v27 to v26, !1417 + v28 = load v1, !1428 + v29 = asm(ptr: v28, val) -> u64 val, !1429 { + lw val ptr i0, !58 + } + v30 = load v1, !1428 + v31 = const u64 8, !1428 + v32 = add v30, v31, !1428 + store v32 to v1, !1430 + v33 = const u64 1 + v34 = const u64 1 + v35 = get_elem_ptr v24, __ptr u64, v33, v34, !1417 + store v29 to v35, !1417 + v36 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg + mem_copy_val v36, v24 + br block5(v36) + + block3(): + v37 = const u64 0, !1431 + revert v37, !1432 + + block5(v38: __ptr { u64, ( u64 | u64 ) }): + mem_copy_val __ret_value, v38 + v39 = const unit () + ret () v39 + } + + pub fn abi_encode_89(self: __ptr { u64, ( u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1434 { + local { u64, ( u64 | u64 ) } __matched_value_1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer____ + + entry(self: __ptr { u64, ( u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1435 + mem_copy_val v1, self + v2 = const u64 0 + v3 = get_elem_ptr self, __ptr u64, v2 + v4 = load v3 + v5 = const u64 0, !1436 + v6 = cmp eq v4 v5, !1439 + cbr v6, block0(), block1(), !1437 + + block0(): + v7 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1436 + v8 = const u64 1 + v9 = const u64 0 + v10 = get_elem_ptr v7, __ptr u64, v8, v9 + v11 = load v10 + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1440 + v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v14 = const u64 0, !1441 + v15 = call abi_encode_20(v14, v12, v13) + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1442 + mem_copy_val v16, v13 + v17 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v18 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v19 = call abi_encode_20(v11, v17, v18) + v20 = const u64 0 + v21 = const u64 0 + v22 = get_elem_ptr v18, __ptr ptr, v20, v21 + v23 = load v22 + v24 = const u64 0 + v25 = const u64 1 + v26 = get_elem_ptr v18, __ptr u64, v24, v25 + v27 = load v26 + v28 = const u64 0 + v29 = const u64 2 + v30 = get_elem_ptr v18, __ptr u64, v28, v29 + v31 = load v30 + br block5(v31, v27, v23) + + block1(): + v32 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1436 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr u64, v33, !1436 + v35 = load v34 + v36 = const u64 1, !1436 + v37 = cmp eq v35 v36, !1445 + cbr v37, block2(), block3(), !1443 + + block2(): + v38 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1436 + v39 = const u64 1 + v40 = const u64 1 + v41 = get_elem_ptr v38, __ptr u64, v39, v40 + v42 = load v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1446 + v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v45 = const u64 1, !1447 + v46 = call abi_encode_20(v45, v43, v44) + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1448 + mem_copy_val v47, v44 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer____ + v49 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v50 = call abi_encode_20(v42, v48, v49) + v51 = const u64 0 + v52 = const u64 0 + v53 = get_elem_ptr v49, __ptr ptr, v51, v52 + v54 = load v53 + v55 = const u64 0 + v56 = const u64 1 + v57 = get_elem_ptr v49, __ptr u64, v55, v56 + v58 = load v57 + v59 = const u64 0 + v60 = const u64 2 + v61 = get_elem_ptr v49, __ptr u64, v59, v60 + v62 = load v61 + br block5(v62, v58, v54) + + block3(): + v63 = const u64 14757395258967588866, !1435 + revert v63, !1435 + + block5(v64: u64, v65: u64, v66: ptr): + v67 = const u64 0 + v68 = const u64 0 + v69 = get_elem_ptr __ret_value, __ptr ptr, v67, v68 + store v66 to v69 + v70 = const u64 0 + v71 = const u64 1 + v72 = get_elem_ptr __ret_value, __ptr u64, v70, v71 + store v65 to v72 + v73 = const u64 0 + v74 = const u64 2 + v75 = get_elem_ptr __ret_value, __ptr u64, v73, v74 + store v64 to v75 + v76 = const unit () + ret () v76 + } + + pub fn abi_decode_92(buffer !1449: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 | u64 ) }) -> (), !1452 { + local { u64, ( u64 | u64 | u64 ) } __anon_0 + local { u64, ( u64 | u64 | u64 ) } __anon_1 + local { u64, ( u64 | u64 | u64 ) } __anon_2 + local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg + local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg0 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 | u64 ) }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1455 + v2 = load v1, !1456 + v3 = asm(ptr: v2, val) -> u64 val, !1457 { + lw val ptr i0, !58 + } + v4 = load v1, !1456 + v5 = const u64 8, !1456 + v6 = add v4, v5, !1456 + store v6 to v1, !1458 + v7 = const u64 0, !1459 + v8 = cmp eq v3 v7, !1462 + cbr v8, block0(), block1(), !1460 + + block0(): + v9 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_0, !1463 + v10 = const u64 0 + v11 = get_elem_ptr v9, __ptr u64, v10, !1463 + v12 = const u64 0, !1463 + store v12 to v11, !1463 + v13 = load v1, !1466 + v14 = asm(ptr: v13, val) -> u64 val, !1467 { + lw val ptr i0, !58 + } + v15 = load v1, !1466 + v16 = const u64 8, !1466 + v17 = add v15, v16, !1466 + store v17 to v1, !1468 + v18 = const u64 1 + v19 = const u64 0 + v20 = get_elem_ptr v9, __ptr u64, v18, v19, !1463 + store v14 to v20, !1463 + v21 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg0 + mem_copy_val v21, v9 + br block8(v21) + + block1(): + v22 = const u64 1, !1469 + v23 = cmp eq v3 v22, !1472 + cbr v23, block2(), block3(), !1470 + + block2(): + v24 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_1, !1463 + v25 = const u64 0 + v26 = get_elem_ptr v24, __ptr u64, v25, !1463 + v27 = const u64 1, !1463 + store v27 to v26, !1463 + v28 = load v1, !1475 + v29 = asm(ptr: v28, val) -> u64 val, !1476 { + lw val ptr i0, !58 + } + v30 = load v1, !1475 + v31 = const u64 8, !1475 + v32 = add v30, v31, !1475 + store v32 to v1, !1477 + v33 = const u64 1 + v34 = const u64 1 + v35 = get_elem_ptr v24, __ptr u64, v33, v34, !1463 + store v29 to v35, !1463 + v36 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg + mem_copy_val v36, v24 + br block7(v36) + + block3(): + v37 = const u64 2, !1478 + v38 = cmp eq v3 v37, !1481 + cbr v38, block4(), block5(), !1479 + + block4(): + v39 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_2, !1463 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr u64, v40, !1463 + v42 = const u64 2, !1463 + store v42 to v41, !1463 + v43 = load v1, !1484 + v44 = asm(ptr: v43, val) -> u64 val, !1485 { + lw val ptr i0, !58 + } + v45 = load v1, !1484 + v46 = const u64 8, !1484 + v47 = add v45, v46, !1484 + store v47 to v1, !1486 + v48 = const u64 1 + v49 = const u64 2 + v50 = get_elem_ptr v39, __ptr u64, v48, v49, !1463 + store v44 to v50, !1463 + v51 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg + mem_copy_val v51, v39 + br block7(v51) + + block5(): + v52 = const u64 0, !1487 + revert v52, !1488 + + block7(v53: __ptr { u64, ( u64 | u64 | u64 ) }): + v54 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg0 + mem_copy_val v54, v53 + br block8(v54) + + block8(v55: __ptr { u64, ( u64 | u64 | u64 ) }): + mem_copy_val __ret_value, v55 + v56 = const unit () + ret () v56 + } + + pub fn abi_encode_95(self: __ptr { u64, ( u64 | u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1490 { + local { u64, ( u64 | u64 | u64 ) } __matched_value_1 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer____ + local { { ptr, u64, u64 } } buffer______ + + entry(self: __ptr { u64, ( u64 | u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1491 + mem_copy_val v1, self + v2 = const u64 0 + v3 = get_elem_ptr self, __ptr u64, v2 + v4 = load v3 + v5 = const u64 0, !1492 + v6 = cmp eq v4 v5, !1495 + cbr v6, block0(), block1(), !1493 + + block0(): + v7 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 + v8 = const u64 1 + v9 = const u64 0 + v10 = get_elem_ptr v7, __ptr u64, v8, v9 + v11 = load v10 + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1496 + v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v14 = const u64 0, !1497 + v15 = call abi_encode_20(v14, v12, v13) + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1498 + mem_copy_val v16, v13 + v17 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v18 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v19 = call abi_encode_20(v11, v17, v18) + v20 = const u64 0 + v21 = const u64 0 + v22 = get_elem_ptr v18, __ptr ptr, v20, v21 + v23 = load v22 + v24 = const u64 0 + v25 = const u64 1 + v26 = get_elem_ptr v18, __ptr u64, v24, v25 + v27 = load v26 + v28 = const u64 0 + v29 = const u64 2 + v30 = get_elem_ptr v18, __ptr u64, v28, v29 + v31 = load v30 + br block8(v31, v27, v23) + + block1(): + v32 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr u64, v33, !1492 + v35 = load v34 + v36 = const u64 1, !1492 + v37 = cmp eq v35 v36, !1501 + cbr v37, block2(), block3(), !1499 + + block2(): + v38 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 + v39 = const u64 1 + v40 = const u64 1 + v41 = get_elem_ptr v38, __ptr u64, v39, v40 + v42 = load v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1502 + v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v45 = const u64 1, !1503 + v46 = call abi_encode_20(v45, v43, v44) + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1504 + mem_copy_val v47, v44 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer____ + v49 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v50 = call abi_encode_20(v42, v48, v49) + v51 = const u64 0 + v52 = const u64 0 + v53 = get_elem_ptr v49, __ptr ptr, v51, v52 + v54 = load v53 + v55 = const u64 0 + v56 = const u64 1 + v57 = get_elem_ptr v49, __ptr u64, v55, v56 + v58 = load v57 + v59 = const u64 0 + v60 = const u64 2 + v61 = get_elem_ptr v49, __ptr u64, v59, v60 + v62 = load v61 + br block7(v62, v58, v54) + + block3(): + v63 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr u64, v64, !1492 + v66 = load v65 + v67 = const u64 2, !1492 + v68 = cmp eq v66 v67, !1507 + cbr v68, block4(), block5(), !1505 + + block4(): + v69 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 + v70 = const u64 1 + v71 = const u64 2 + v72 = get_elem_ptr v69, __ptr u64, v70, v71 + v73 = load v72 + v74 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1508 + v75 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v76 = const u64 2, !1509 + v77 = call abi_encode_20(v76, v74, v75) + v78 = get_local __ptr { { ptr, u64, u64 } }, buffer______, !1510 + mem_copy_val v78, v75 + v79 = get_local __ptr { { ptr, u64, u64 } }, buffer______ + v80 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v81 = call abi_encode_20(v73, v79, v80) + v82 = const u64 0 + v83 = const u64 0 + v84 = get_elem_ptr v80, __ptr ptr, v82, v83 + v85 = load v84 + v86 = const u64 0 + v87 = const u64 1 + v88 = get_elem_ptr v80, __ptr u64, v86, v87 + v89 = load v88 + v90 = const u64 0 + v91 = const u64 2 + v92 = get_elem_ptr v80, __ptr u64, v90, v91 + v93 = load v92 + br block7(v93, v89, v85) + + block5(): + v94 = const u64 14757395258967588866, !1491 + revert v94, !1491 + + block7(v95: u64, v96: u64, v97: ptr): + br block8(v95, v96, v97) + + block8(v98: u64, v99: u64, v100: ptr): + v101 = const u64 0 + v102 = const u64 0 + v103 = get_elem_ptr __ret_value, __ptr ptr, v101, v102 + store v100 to v103 + v104 = const u64 0 + v105 = const u64 1 + v106 = get_elem_ptr __ret_value, __ptr u64, v104, v105 + store v99 to v106 + v107 = const u64 0 + v108 = const u64 2 + v109 = get_elem_ptr __ret_value, __ptr u64, v107, v108 + store v98 to v109 + v110 = const unit () + ret () v110 + } + + pub fn abi_encode_101(self: __ptr string<0>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1513 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local string<0> __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local string<0> self_ + + entry(self: __ptr string<0>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr string<0>, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr string<0>, self_, !1515 + v18 = cmp gt v16 v13 + cbr v18, block1(), block0(v10, v13) + + block0(v19: ptr, v20: u64): + v21 = get_local __ptr string<0>, __anon_1 + mem_copy_val v21, v17 + v22 = add v19, v16 + v23 = cast_ptr v22 to __ptr u8 + mem_copy_bytes v23, v21, 0 + v24 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v25 = const u64 0 + v26 = get_elem_ptr v24, __ptr ptr, v25 + store v19 to v26 + v27 = const u64 1 + v28 = get_elem_ptr v24, __ptr u64, v27 + store v20 to v28 + v29 = const u64 2 + v30 = get_elem_ptr v24, __ptr u64, v29 + store v16 to v30 + v31 = asm(buffer: v24) -> __ptr { ptr, u64, u64 } buffer { + } + v32 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v32, v31 + v33 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 + v34 = const u64 0 + v35 = get_elem_ptr v33, __ptr { ptr, u64, u64 }, v34 + mem_copy_val v35, v32 + mem_copy_val __ret_value, v33 + v36 = const unit () + ret () v36 + + block1(): + v37 = const u64 2 + v38 = mul v13, v37 + v39 = asm(new_cap: v38, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v39, v38) + } + + pub fn abi_encode_107(self: __ptr string<1>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1517 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local string<1> __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local string<1> self_ + + entry(self: __ptr string<1>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr string<1>, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr string<1>, self_, !1515 + v18 = const u64 1 + v19 = add v16, v18 + v20 = cmp gt v19 v13 + cbr v20, block1(), block0(v10, v13) + + block0(v21: ptr, v22: u64): + v23 = get_local __ptr string<1>, __anon_1 + mem_copy_val v23, v17 + v24 = add v21, v16 + v25 = cast_ptr v24 to __ptr u8 + mem_copy_bytes v25, v23, 1 + v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v27 = const u64 0 + v28 = get_elem_ptr v26, __ptr ptr, v27 + store v21 to v28 + v29 = const u64 1 + v30 = get_elem_ptr v26, __ptr u64, v29 + store v22 to v30 + v31 = const u64 2 + v32 = get_elem_ptr v26, __ptr u64, v31 + store v19 to v32 + v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { + } + v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 + v36 = const u64 0 + v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 + mem_copy_val v37, v34 + mem_copy_val __ret_value, v35 + v38 = const unit () + ret () v38 + + block1(): + v39 = const u64 2 + v40 = mul v13, v39 + v41 = add v40, v18 + v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v42, v41) + } + + pub fn abi_encode_113(self: __ptr string<16>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1518 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local string<16> __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local string<16> self_ + + entry(self: __ptr string<16>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr string<16>, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr string<16>, self_, !1515 + v18 = const u64 16 + v19 = add v16, v18 + v20 = cmp gt v19 v13 + cbr v20, block1(), block0(v10, v13) + + block0(v21: ptr, v22: u64): + v23 = get_local __ptr string<16>, __anon_1 + mem_copy_val v23, v17 + v24 = add v21, v16 + v25 = cast_ptr v24 to __ptr u8 + mem_copy_bytes v25, v23, 16 + v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v27 = const u64 0 + v28 = get_elem_ptr v26, __ptr ptr, v27 + store v21 to v28 + v29 = const u64 1 + v30 = get_elem_ptr v26, __ptr u64, v29 + store v22 to v30 + v31 = const u64 2 + v32 = get_elem_ptr v26, __ptr u64, v31 + store v19 to v32 + v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { + } + v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 + v36 = const u64 0 + v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 + mem_copy_val v37, v34 + mem_copy_val __ret_value, v35 + v38 = const unit () + ret () v38 + + block1(): + v39 = const u64 2 + v40 = mul v13, v39 + v41 = add v40, v18 + v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v42, v41) + } + + pub fn abi_encode_119(self: __ptr string<32>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1519 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local string<32> __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local string<32> self_ + + entry(self: __ptr string<32>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr string<32>, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr string<32>, self_, !1515 + v18 = const u64 32 + v19 = add v16, v18 + v20 = cmp gt v19 v13 + cbr v20, block1(), block0(v10, v13) + + block0(v21: ptr, v22: u64): + v23 = get_local __ptr string<32>, __anon_1 + mem_copy_val v23, v17 + v24 = add v21, v16 + v25 = cast_ptr v24 to __ptr u8 + mem_copy_bytes v25, v23, 32 + v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v27 = const u64 0 + v28 = get_elem_ptr v26, __ptr ptr, v27 + store v21 to v28 + v29 = const u64 1 + v30 = get_elem_ptr v26, __ptr u64, v29 + store v22 to v30 + v31 = const u64 2 + v32 = get_elem_ptr v26, __ptr u64, v31 + store v19 to v32 + v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { + } + v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 + v36 = const u64 0 + v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 + mem_copy_val v37, v34 + mem_copy_val __ret_value, v35 + v38 = const unit () + ret () v38 + + block1(): + v39 = const u64 2 + v40 = mul v13, v39 + v41 = add v40, v18 + v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v42, v41) + } + + pub fn abi_encode_125(self: __ptr string<8>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1520 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local string<8> __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local string<8> self_ + + entry(self: __ptr string<8>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr string<8>, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr string<8>, self_, !1515 + v18 = const u64 8 + v19 = add v16, v18 + v20 = cmp gt v19 v13 + cbr v20, block1(), block0(v10, v13) + + block0(v21: ptr, v22: u64): + v23 = get_local __ptr string<8>, __anon_1 + mem_copy_val v23, v17 + v24 = add v21, v16 + v25 = cast_ptr v24 to __ptr u8 + mem_copy_bytes v25, v23, 8 + v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v27 = const u64 0 + v28 = get_elem_ptr v26, __ptr ptr, v27 + store v21 to v28 + v29 = const u64 1 + v30 = get_elem_ptr v26, __ptr u64, v29 + store v22 to v30 + v31 = const u64 2 + v32 = get_elem_ptr v26, __ptr u64, v31 + store v19 to v32 + v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { + } + v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 + v36 = const u64 0 + v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 + mem_copy_val v37, v34 + mem_copy_val __ret_value, v35 + v38 = const unit () + ret () v38 + + block1(): + v39 = const u64 2 + v40 = mul v13, v39 + v41 = add v40, v18 + v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v42, v41) + } + + pub fn abi_decode_128(buffer !1371: __ptr { ptr }, __ret_value: __ptr { u64 }) -> (), !1522 { + local { u64 } __anon_0 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64 }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1525 + v2 = load v1, !1526 + v3 = asm(ptr: v2, val) -> u64 val, !1527 { + lw val ptr i0, !58 + } + v4 = load v1, !1526 + v5 = const u64 8, !1526 + v6 = add v4, v5, !1526 + store v6 to v1, !1528 + v7 = get_local __ptr { u64 }, __anon_0, !1529 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr u64, v8 + store v3 to v9, !1529 + mem_copy_val __ret_value, v7 + v10 = const unit () + ret () v10 + } + + pub fn abi_encode_131(self: __ptr { u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1531 { + local { { ptr, u64, u64 } } __ret_val + + entry(self: __ptr { u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr u64, v0, !1532 + v2 = load v1 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = call abi_encode_20(v2, buffer, v3) + v5 = const u64 0 + v6 = const u64 0 + v7 = get_elem_ptr v3, __ptr ptr, v5, v6 + v8 = load v7 + v9 = const u64 0 + v10 = const u64 1 + v11 = get_elem_ptr v3, __ptr u64, v9, v10 + v12 = load v11 + v13 = const u64 0 + v14 = const u64 2 + v15 = get_elem_ptr v3, __ptr u64, v13, v14 + v16 = load v15 + v17 = const u64 0 + v18 = const u64 0 + v19 = get_elem_ptr __ret_value, __ptr ptr, v17, v18 + store v8 to v19 + v20 = const u64 0 + v21 = const u64 1 + v22 = get_elem_ptr __ret_value, __ptr u64, v20, v21 + store v12 to v22 + v23 = const u64 0 + v24 = const u64 2 + v25 = get_elem_ptr __ret_value, __ptr u64, v23, v24 + store v16 to v25 + v26 = const unit () + ret () v26 + } + + pub fn abi_decode_134(buffer !1403: __ptr { ptr }, __ret_value: __ptr { u64, u64 }) -> (), !1534 { + local { u64, u64 } __anon_0 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, u64 }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1537 + v2 = load v1, !1538 + v3 = asm(ptr: v2, val) -> u64 val, !1539 { + lw val ptr i0, !58 + } + v4 = load v1, !1538 + v5 = const u64 8, !1538 + v6 = add v4, v5, !1538 + store v6 to v1, !1540 + v7 = load v1, !1543 + v8 = asm(ptr: v7, val) -> u64 val, !1544 { + lw val ptr i0, !58 + } + v9 = load v1, !1543 + v10 = const u64 8, !1543 + v11 = add v9, v10, !1543 + store v11 to v1, !1545 + v12 = get_local __ptr { u64, u64 }, __anon_0, !1546 + v13 = const u64 0 + v14 = get_elem_ptr v12, __ptr u64, v13 + store v3 to v14, !1546 + v15 = const u64 1 + v16 = get_elem_ptr v12, __ptr u64, v15 + store v8 to v16, !1546 + mem_copy_val __ret_value, v12 + v17 = const unit () + ret () v17 + } + + pub fn abi_encode_143(self: __ptr { u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1548 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer___ + + entry(self: __ptr { u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr u64, v0, !1549 + v2 = load v1 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = call abi_encode_20(v2, buffer, v3) + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1550 + mem_copy_val v5, v3 + v6 = const u64 1 + v7 = get_elem_ptr self, __ptr u64, v6, !1551 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !1552 + mem_copy_val v12, v10 + v13 = const u64 2 + v14 = get_elem_ptr self, __ptr u64, v13, !1553 + v15 = load v14 + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___ + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v18 = call abi_encode_20(v15, v16, v17) + v19 = const u64 0 + v20 = const u64 0 + v21 = get_elem_ptr v17, __ptr ptr, v19, v20 + v22 = load v21 + v23 = const u64 0 + v24 = const u64 1 + v25 = get_elem_ptr v17, __ptr u64, v23, v24 + v26 = load v25 + v27 = const u64 0 + v28 = const u64 2 + v29 = get_elem_ptr v17, __ptr u64, v27, v28 + v30 = load v29 + v31 = const u64 0 + v32 = const u64 0 + v33 = get_elem_ptr __ret_value, __ptr ptr, v31, v32 + store v22 to v33 + v34 = const u64 0 + v35 = const u64 1 + v36 = get_elem_ptr __ret_value, __ptr u64, v34, v35 + store v26 to v36 + v37 = const u64 0 + v38 = const u64 2 + v39 = get_elem_ptr __ret_value, __ptr u64, v37, v38 + store v30 to v39 + v40 = const unit () + ret () v40 + } + + pub fn abi_encode_159(self: __ptr { u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1556 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } buffer__ + + entry(self: __ptr { u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr u64, v0, !1557 + v2 = load v1 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = call abi_encode_20(v2, buffer, v3) + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1558 + mem_copy_val v5, v3 + v6 = const u64 1 + v7 = get_elem_ptr self, __ptr u64, v6, !1559 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v11 = call abi_encode_20(v8, v9, v10) + v12 = const u64 0 + v13 = const u64 0 + v14 = get_elem_ptr v10, __ptr ptr, v12, v13 + v15 = load v14 + v16 = const u64 0 + v17 = const u64 1 + v18 = get_elem_ptr v10, __ptr u64, v16, v17 + v19 = load v18 + v20 = const u64 0 + v21 = const u64 2 + v22 = get_elem_ptr v10, __ptr u64, v20, v21 + v23 = load v22 + v24 = const u64 0 + v25 = const u64 0 + v26 = get_elem_ptr __ret_value, __ptr ptr, v24, v25 + store v15 to v26 + v27 = const u64 0 + v28 = const u64 1 + v29 = get_elem_ptr __ret_value, __ptr u64, v27, v28 + store v19 to v29 + v30 = const u64 0 + v31 = const u64 2 + v32 = get_elem_ptr __ret_value, __ptr u64, v30, v31 + store v23 to v32 + v33 = const unit () + ret () v33 + } + + pub fn abi_decode_162(buffer !1560: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64 }) -> (), !1563 { + local { u64, u64, u64 } __anon_0 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64 }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1566 + v2 = load v1, !1567 + v3 = asm(ptr: v2, val) -> u64 val, !1568 { + lw val ptr i0, !58 + } + v4 = load v1, !1567 + v5 = const u64 8, !1567 + v6 = add v4, v5, !1567 + store v6 to v1, !1569 + v7 = load v1, !1572 + v8 = asm(ptr: v7, val) -> u64 val, !1573 { + lw val ptr i0, !58 + } + v9 = load v1, !1572 + v10 = const u64 8, !1572 + v11 = add v9, v10, !1572 + store v11 to v1, !1574 + v12 = load v1, !1577 + v13 = asm(ptr: v12, val) -> u64 val, !1578 { + lw val ptr i0, !58 + } + v14 = load v1, !1577 + v15 = const u64 8, !1577 + v16 = add v14, v15, !1577 + store v16 to v1, !1579 + v17 = get_local __ptr { u64, u64, u64 }, __anon_0, !1580 + v18 = const u64 0 + v19 = get_elem_ptr v17, __ptr u64, v18, !1580 + store v3 to v19, !1580 + v20 = const u64 1 + v21 = get_elem_ptr v17, __ptr u64, v20, !1580 + store v8 to v21, !1580 + v22 = const u64 2 + v23 = get_elem_ptr v17, __ptr u64, v22, !1580 + store v13 to v23, !1580 + mem_copy_val __ret_value, v17 + v24 = const unit () + ret () v24 + } + + pub fn abi_decode_168(buffer !1581: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64, u64 }) -> (), !1584 { + local { u64, u64, u64, u64 } __anon_0 + + entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64, u64 }): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1587 + v2 = load v1, !1588 + v3 = asm(ptr: v2, val) -> u64 val, !1589 { + lw val ptr i0, !58 + } + v4 = load v1, !1588 + v5 = const u64 8, !1588 + v6 = add v4, v5, !1588 + store v6 to v1, !1590 + v7 = load v1, !1593 + v8 = asm(ptr: v7, val) -> u64 val, !1594 { + lw val ptr i0, !58 + } + v9 = load v1, !1593 + v10 = const u64 8, !1593 + v11 = add v9, v10, !1593 + store v11 to v1, !1595 + v12 = load v1, !1598 + v13 = asm(ptr: v12, val) -> u64 val, !1599 { + lw val ptr i0, !58 + } + v14 = load v1, !1598 + v15 = const u64 8, !1598 + v16 = add v14, v15, !1598 + store v16 to v1, !1600 + v17 = load v1, !1603 + v18 = asm(ptr: v17, val) -> u64 val, !1604 { + lw val ptr i0, !58 + } + v19 = load v1, !1603 + v20 = const u64 8, !1603 + v21 = add v19, v20, !1603 + store v21 to v1, !1605 + v22 = get_local __ptr { u64, u64, u64, u64 }, __anon_0, !1606 + v23 = const u64 0 + v24 = get_elem_ptr v22, __ptr u64, v23, !1606 + store v3 to v24, !1606 + v25 = const u64 1 + v26 = get_elem_ptr v22, __ptr u64, v25, !1606 + store v8 to v26, !1606 + v27 = const u64 2 + v28 = get_elem_ptr v22, __ptr u64, v27, !1606 + store v13 to v28, !1606 + v29 = const u64 3 + v30 = get_elem_ptr v22, __ptr u64, v29, !1606 + store v18 to v30, !1606 + mem_copy_val __ret_value, v22 + v31 = const unit () + ret () v31 + } + + pub fn abi_encode_171(self: __ptr { u64, u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1609 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer___ + local { { ptr, u64, u64 } } buffer____ + + entry(self: __ptr { u64, u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = const u64 0 + v1 = get_elem_ptr self, __ptr u64, v0, !1610 + v2 = load v1 + v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v4 = call abi_encode_20(v2, buffer, v3) + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1611 + mem_copy_val v5, v3 + v6 = const u64 1 + v7 = get_elem_ptr self, __ptr u64, v6, !1612 + v8 = load v7 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v11 = call abi_encode_20(v8, v9, v10) + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !1613 + mem_copy_val v12, v10 + v13 = const u64 2 + v14 = get_elem_ptr self, __ptr u64, v13, !1614 + v15 = load v14 + v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___ + v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v18 = call abi_encode_20(v15, v16, v17) + v19 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1615 + mem_copy_val v19, v17 + v20 = const u64 3 + v21 = get_elem_ptr self, __ptr u64, v20, !1616 + v22 = load v21 + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer____ + v24 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v25 = call abi_encode_20(v22, v23, v24) + v26 = const u64 0 + v27 = const u64 0 + v28 = get_elem_ptr v24, __ptr ptr, v26, v27 + v29 = load v28 + v30 = const u64 0 + v31 = const u64 1 + v32 = get_elem_ptr v24, __ptr u64, v30, v31 + v33 = load v32 + v34 = const u64 0 + v35 = const u64 2 + v36 = get_elem_ptr v24, __ptr u64, v34, v35 + v37 = load v36 + v38 = const u64 0 + v39 = const u64 0 + v40 = get_elem_ptr __ret_value, __ptr ptr, v38, v39 + store v29 to v40 + v41 = const u64 0 + v42 = const u64 1 + v43 = get_elem_ptr __ret_value, __ptr u64, v41, v42 + store v33 to v43 + v44 = const u64 0 + v45 = const u64 2 + v46 = get_elem_ptr __ret_value, __ptr u64, v44, v45 + store v37 to v46 + v47 = const unit () + ret () v47 + } + + pub fn abi_encode_181(self !1617: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1620 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local u64 __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + + entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1621 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v5, v4 + v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v6, v5 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr ptr, v7 + v9 = load v8 + v10 = const u64 1 + v11 = get_elem_ptr v6, __ptr u64, v10 + v12 = load v11 + v13 = const u64 2 + v14 = get_elem_ptr v6, __ptr u64, v13 + v15 = load v14 + v16 = const u64 2 + v17 = add v15, v16 + v18 = cmp gt v17 v12 + cbr v18, block1(), block0(v9, v12) + + block0(v19: ptr, v20: u64): + v21 = get_local __ptr u64, __anon_1 + store self to v21 + v22 = const u64 6 + v23 = add v21, v22 + v24 = cast_ptr v23 to __ptr u8 + v25 = add v19, v15 + v26 = cast_ptr v25 to __ptr u8 + mem_copy_bytes v26, v24, 2 + v27 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v28 = const u64 0 + v29 = get_elem_ptr v27, __ptr ptr, v28 + store v19 to v29 + v30 = const u64 1 + v31 = get_elem_ptr v27, __ptr u64, v30 + store v20 to v31 + v32 = const u64 2 + v33 = get_elem_ptr v27, __ptr u64, v32 + store v17 to v33 + v34 = asm(buffer: v27) -> __ptr { ptr, u64, u64 } buffer { + } + v35 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v35, v34 + v36 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1622 + v37 = const u64 0 + v38 = get_elem_ptr v36, __ptr { ptr, u64, u64 }, v37 + mem_copy_val v38, v35 + mem_copy_val __ret_value, v36 + v39 = const unit () + ret () v39 + + block1(): + v40 = const u64 2 + v41 = mul v12, v40 + v42 = add v41, v16 + v43 = asm(new_cap: v42, old_ptr: v9, len: v15) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v43, v42) + } + + pub fn abi_decode_184(buffer !1623: __ptr { ptr }, __ret_value: __ptr u256) -> (), !1626 { + local mut u256 __aggr_memcpy_0 + local u256 v + + entry(buffer: __ptr { ptr }, __ret_value: __ptr u256): + v0 = const u64 0 + v1 = get_elem_ptr buffer, __ptr ptr, v0, !1629 + v2 = load v1, !1630 + v3 = asm(ptr: v2) -> __ptr u256 ptr { + } + v4 = get_local __ptr u256, __aggr_memcpy_0 + mem_copy_val v4, v3 + v5 = get_local __ptr u256, v, !1631 + mem_copy_val v5, v4 + v6 = load v1, !1630 + v7 = const u64 32, !1630 + v8 = add v6, v7, !1630 + store v8 to v1, !1632 + v9 = get_local __ptr u256, v, !1633 + mem_copy_val __ret_value, v9 + v10 = const unit () + ret () v10 + } + + pub fn abi_encode_188(self: __ptr u256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1636 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local u256 __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + local u256 self_ + + entry(self: __ptr u256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr u256, self_ + mem_copy_val v0, self + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v1, buffer + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1637 + v3 = const u64 0 + v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 + v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { + } + v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v6, v5 + v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v7, v6 + v8 = const u64 0 + v9 = get_elem_ptr v7, __ptr ptr, v8 + v10 = load v9 + v11 = const u64 1 + v12 = get_elem_ptr v7, __ptr u64, v11 + v13 = load v12 + v14 = const u64 2 + v15 = get_elem_ptr v7, __ptr u64, v14 + v16 = load v15 + v17 = get_local __ptr u256, self_, !1638 + v18 = const u64 32 + v19 = add v16, v18 + v20 = cmp gt v19 v13 + cbr v20, block1(), block0(v10, v13) + + block0(v21: ptr, v22: u64): + v23 = get_local __ptr u256, __anon_1 + mem_copy_val v23, v17 + v24 = add v21, v16 + v25 = cast_ptr v24 to __ptr u8 + mem_copy_bytes v25, v23, 32 + v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v27 = const u64 0 + v28 = get_elem_ptr v26, __ptr ptr, v27 + store v21 to v28 + v29 = const u64 1 + v30 = get_elem_ptr v26, __ptr u64, v29 + store v22 to v30 + v31 = const u64 2 + v32 = get_elem_ptr v26, __ptr u64, v31 + store v19 to v32 + v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { + } + v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1639 + v36 = const u64 0 + v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 + mem_copy_val v37, v34 + mem_copy_val __ret_value, v35 + v38 = const unit () + ret () v38 + + block1(): + v39 = const u64 2 + v40 = mul v13, v39 + v41 = add v40, v18 + v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v42, v41) + } + + pub fn abi_decode_191(buffer !1640: __ptr { ptr }) -> u64, !1643 { + entry(buffer: __ptr { ptr }): + v0 = call read_72(buffer), !1646 + v1 = asm(input: v0) -> u64 input, !1649 { + } + v2 = call read_72(buffer), !1652 + v3 = asm(input: v2) -> u64 input, !1655 { + } + v4 = call read_72(buffer), !1658 + v5 = asm(input: v4) -> u64 input, !1661 { + } + v6 = call read_72(buffer), !1664 + v7 = asm(input: v6) -> u64 input, !1667 { + } + v8 = const u64 24, !1668 + v9 = lsh v1, v8, !1671 + v10 = const u64 4294967295, !1672 + v11 = and v9, v10, !1671 + v12 = const u64 16, !1673 + v13 = lsh v3, v12, !1676 + v14 = and v13, v10, !1676 + v15 = or v11, v14, !1679 + v16 = const u64 8, !1680 + v17 = lsh v5, v16, !1683 + v18 = and v17, v10, !1683 + v19 = or v15, v18, !1686 + v20 = or v19, v7, !1689 + ret u64 v20 + } + + pub fn abi_encode_198(self !1690: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1693 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local u64 __anon_1 + local { ptr, u64, u64 } __anon_2 + local { { ptr, u64, u64 } } __anon_3 + local { { ptr, u64, u64 } } buffer_ + + entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1694 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v5, v4 + v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v6, v5 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr ptr, v7 + v9 = load v8 + v10 = const u64 1 + v11 = get_elem_ptr v6, __ptr u64, v10 + v12 = load v11 + v13 = const u64 2 + v14 = get_elem_ptr v6, __ptr u64, v13 + v15 = load v14 + v16 = const u64 4 + v17 = add v15, v16 + v18 = cmp gt v17 v12 + cbr v18, block1(), block0(v9, v12) + + block0(v19: ptr, v20: u64): + v21 = get_local __ptr u64, __anon_1 + store self to v21 + v22 = const u64 4 + v23 = add v21, v22 + v24 = cast_ptr v23 to __ptr u8 + v25 = add v19, v15 + v26 = cast_ptr v25 to __ptr u8 + mem_copy_bytes v26, v24, 4 + v27 = get_local __ptr { ptr, u64, u64 }, __anon_2 + v28 = const u64 0 + v29 = get_elem_ptr v27, __ptr ptr, v28 + store v19 to v29 + v30 = const u64 1 + v31 = get_elem_ptr v27, __ptr u64, v30 + store v20 to v31 + v32 = const u64 2 + v33 = get_elem_ptr v27, __ptr u64, v32 + store v17 to v33 + v34 = asm(buffer: v27) -> __ptr { ptr, u64, u64 } buffer { + } + v35 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v35, v34 + v36 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1695 + v37 = const u64 0 + v38 = get_elem_ptr v36, __ptr { ptr, u64, u64 }, v37 + mem_copy_val v38, v35 + mem_copy_val __ret_value, v36 + v39 = const unit () + ret () v39 + + block1(): + v40 = const u64 2 + v41 = mul v12, v40 + v42 = add v41, v16 + v43 = asm(new_cap: v42, old_ptr: v9, len: v15) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v43, v42) + } + + pub fn abi_encode_206(self !1696: u8, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1699 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { ptr, u64, u64 } __aggr_memcpy_00 + local { ptr, u64, u64 } __anon_0 + local { ptr, u64, u64 } __anon_1 + local { { ptr, u64, u64 } } __anon_2 + local { { ptr, u64, u64 } } buffer_ + + entry(self: u8, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): + v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + mem_copy_val v0, buffer + v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1700 + v2 = const u64 0 + v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 + v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { + } + v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v5, v4 + v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 + mem_copy_val v6, v5 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr ptr, v7 + v9 = load v8 + v10 = const u64 1 + v11 = get_elem_ptr v6, __ptr u64, v10 + v12 = load v11 + v13 = const u64 2 + v14 = get_elem_ptr v6, __ptr u64, v13 + v15 = load v14 + v16 = const u64 1 + v17 = add v15, v16 + v18 = cmp gt v17 v12 + cbr v18, block1(), block0(v9, v12) + + block0(v19: ptr, v20: u64): + v21 = add v19, v15 + v22 = cast_ptr v21 to __ptr u8 + store self to v22 + v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 + v24 = const u64 0 + v25 = get_elem_ptr v23, __ptr ptr, v24 + store v19 to v25 + v26 = const u64 1 + v27 = get_elem_ptr v23, __ptr u64, v26 + store v20 to v27 + v28 = const u64 2 + v29 = get_elem_ptr v23, __ptr u64, v28 + store v17 to v29 + v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { + } + v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 + mem_copy_val v31, v30 + v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !1701 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 + mem_copy_val v34, v31 + mem_copy_val __ret_value, v32 + v35 = const unit () + ret () v35 + + block1(): + v36 = const u64 2 + v37 = mul v12, v36 + v38 = add v37, v16 + v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { + aloc new_cap + mcp hp old_ptr len + } + br block0(v39, v38) + } + + entry fn cost_of_in_bool() -> (), !1705 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { bool } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local slice __ret_val14 + local slice __ret_val15 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { b256, u64, u64 } __tmp_arg10 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { { ptr, u64, u64 } } __tmp_arg8 + local slice __tmp_arg9 + local { bool } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { bool } item_ + local slice method_name_ + local slice params + local slice second_parameter + local { bool } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1706 + v2 = get_global __ptr string<7>, __const_global28 + v3 = cast_ptr v2 to ptr, !1707 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !1707 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !1707 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 7 + store v9 to v8, !1707 + v10 = get_local __ptr slice, __anon_1, !1707 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { bool }, __anon_2 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr bool, v12 + v14 = const bool false, !1708 + store v14 to v13 + v15 = get_local __ptr b256, contract_id_, !1709 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !1709 + mem_copy_val v16, v10 + v17 = get_local __ptr { bool }, args_, !1709 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, asset_id_, !1709 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !1711 + v20 = get_local __ptr slice, __tmp_arg9 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val14 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !1713 + mem_copy_val v23, v21 + v24 = get_local __ptr { bool }, args_, !1715 + v25 = get_local __ptr { bool }, item_, !1718 + mem_copy_val v25, v24 + v26 = get_local __ptr { bool }, item_, !1719 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { bool }, self_, !1722 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1723 + mem_copy_val v30, v27 + v31 = get_local __ptr { bool }, self_, !1725 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr bool, v32, !1727 + v34 = load v33, !1728 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1730 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 + mem_copy_val v36, v35 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v38 = call abi_encode_77(v34, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1732 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1734 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1735 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1736 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val8 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !1738 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !1740 + v48 = get_local __ptr slice, first_parameter, !1742 + v49 = get_local __ptr slice, self_0, !1745 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !1746 + v51 = get_local __ptr slice, slice_, !1747 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !1748 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !1745 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !1749 + v58 = load v57, !1745 + v59 = asm(a: v58) -> u64 a, !1751 { + } + v60 = get_local __ptr slice, second_parameter, !1753 + v61 = get_local __ptr slice, self_1, !1756 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !1757 + v63 = get_local __ptr slice, slice_0, !1758 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !1759 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !1756 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !1760 + v69 = load v68, !1756 + v70 = asm(a: v69) -> u64 a, !1762 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !1764 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !1765 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !1766 + store v59 to v75, !1767 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !1768 + store v70 to v77, !1769 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val15 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !1771 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1773 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1774 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val9 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !1776 + v96 = get_local __ptr slice, self_2, !1779 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !1780 + v98 = get_local __ptr slice, slice_1, !1781 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !1782 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !1779 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !1783 + v104 = load v103, !1779 + v105 = get_local __ptr b256, asset_id_, !1785 + v106 = get_local __ptr b256, __anon_10, !1709 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !1709 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !1787 + v111 = asm() -> ptr ret, !1789 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1791 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1792 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val10 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !1796 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !1797 + store v111 to v127, !1798 + v128 = get_local __ptr { ptr }, buffer, !1800 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1802 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1803 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val11 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !1805 + v143 = call read_72(v142), !1808 + v144 = const u8 0, !353 + v145 = cmp eq v143 v144, !1809 + cbr v145, abi_decode_71_block5(), abi_decode_71_block1(), !1810 + + abi_decode_71_block1(): + v146 = const u8 1, !359 + v147 = cmp eq v143 v146, !1811 + cbr v147, abi_decode_71_block5(), abi_decode_71_block3(), !1812 + + abi_decode_71_block3(): + v148 = const u64 0, !365 + revert v148, !1813 + + abi_decode_71_block5(): + v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v150 = call new_21(v149) + v151 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v151, v149 + v152 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v153 = const u64 103, !1814 + v154 = call abi_encode_20(v153, v151, v152) + v155 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1815 + mem_copy_val v155, v152 + v156 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1816 + v157 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v157, v156 + v158 = get_local __ptr slice, __ret_val12 + v159 = call as_raw_slice_22(v157, v158) + v160 = get_local __ptr slice, __log_arg2 + mem_copy_val v160, v158 + v161 = const u64 1515152261580153489 + log __ptr slice v160, v161 + v162 = const unit () + ret () v162 + } + + pub fn encode_208(item: __ptr slice, __ret_value: __ptr slice) -> (), !1819 { + local mut { ptr, u64, u64 } __aggr_memcpy_0 + local mut { u64, u64 } __aggr_memcpy_00 + local mut slice __aggr_memcpy_01 + local mut { ptr, u64, u64 } __aggr_memcpy_02 + local { ptr, u64, u64 } __anon_0 + local { u64, u64 } __anon_1 + local slice __anon_2 + local { ptr, u64, u64 } __anon_3 + local { { ptr, u64, u64 } } __anon_4 + local { { ptr, u64, u64 } } __ret_val + local slice __ret_val0 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } buffer + local { { ptr, u64, u64 } } buffer_ + local slice item_ + local slice self_ + + entry(item: __ptr slice, __ret_value: __ptr slice): + v0 = get_local __ptr slice, item_ + mem_copy_val v0, item + v1 = get_local __ptr slice, item_, !109 + v2 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v3 = call new_21(v2) + v4 = get_local __ptr slice, self_, !1820 + mem_copy_val v4, v1 + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1820 + mem_copy_val v5, v2 + v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1822 + v7 = const u64 0 + v8 = get_elem_ptr v6, __ptr { ptr, u64, u64 }, v7, !1823 + v9 = asm(buffer: v8) -> __ptr { ptr, u64, u64 } buffer { + } + v10 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 + mem_copy_val v10, v9 + v11 = get_local __ptr { ptr, u64, u64 }, __anon_0, !1820 + mem_copy_val v11, v10 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr ptr, v12, !1820 + v14 = load v13, !1820 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15, !1820 + v17 = load v16, !1820 + v18 = const u64 2 + v19 = get_elem_ptr v11, __ptr u64, v18, !1820 + v20 = load v19, !1820 + v21 = get_local __ptr slice, self_, !1825 + v22 = get_local __ptr slice, __aggr_memcpy_01 + mem_copy_val v22, v21 + v23 = asm(item: v21) -> __ptr { u64, u64 } item { + } + v24 = get_local __ptr { u64, u64 }, __aggr_memcpy_00 + mem_copy_val v24, v23 + v25 = get_local __ptr { u64, u64 }, __anon_1, !1820 + mem_copy_val v25, v24 + v26 = const u64 1 + v27 = get_elem_ptr v25, __ptr u64, v26, !1820 + v28 = load v27, !1820 + v29 = const u64 8 + v30 = add v28, v29, !1820 + v31 = add v20, v30, !1820 + v32 = cmp gt v31 v17, !1820 + cbr v32, abi_encode_209_block1(), abi_encode_209_block0(v14, v17), !1820 + + abi_encode_209_block0(v33: ptr, v34: u64): + v35 = get_local __ptr slice, __anon_2, !1820 + mem_copy_val v35, v22 + v36 = add v33, v20, !1820 + v37 = cast_ptr v36 to __ptr u8, !1820 + v38 = asm(item_ptr: v35, len: v20, addr: v37, data_ptr, item_len, new_len) -> u64 new_len, !1820 { + lw item_len item_ptr i1 + sw addr item_len i0 + addi addr addr i8 + lw data_ptr item_ptr i0 + mcp addr data_ptr item_len + addi new_len len i8 + add new_len new_len item_len + } + v39 = get_local __ptr { ptr, u64, u64 }, __anon_3, !1820 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr ptr, v40, !1820 + store v33 to v41, !1820 + v42 = const u64 1 + v43 = get_elem_ptr v39, __ptr u64, v42, !1820 + store v34 to v43, !1820 + v44 = const u64 2 + v45 = get_elem_ptr v39, __ptr u64, v44, !1820 + store v38 to v45, !1820 + v46 = asm(buffer: v39) -> __ptr { ptr, u64, u64 } buffer { + } + v47 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_02 + mem_copy_val v47, v46 + v48 = get_local __ptr { { ptr, u64, u64 } }, __anon_4, !1827 + v49 = const u64 0 + v50 = get_elem_ptr v48, __ptr { ptr, u64, u64 }, v49, !1820 + mem_copy_val v50, v47 + v51 = get_local __ptr { { ptr, u64, u64 } }, buffer, !111 + mem_copy_val v51, v48 + v52 = get_local __ptr { { ptr, u64, u64 } }, buffer, !113 + v53 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v53, v52 + v54 = get_local __ptr slice, __ret_val0 + v55 = call as_raw_slice_22(v53, v54) + mem_copy_val __ret_value, v54 + v56 = const unit () + ret () v56 + + abi_encode_209_block1(): + v57 = const u64 2 + v58 = mul v17, v57, !1820 + v59 = add v58, v30, !1820 + v60 = asm(new_cap: v59, old_ptr: v14, len: v20) -> __ptr u8 hp, !1820 { + aloc new_cap + mcp hp old_ptr len + } + br abi_encode_209_block0(v60, v59), !1820 + } + + pub fn encode_212(item: __ptr { b256, u64, u64 }, __ret_value: __ptr slice) -> (), !1828 { + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local { { ptr, u64, u64 } } buffer___ + local { { ptr, u64, u64 } } buffer____ + + entry(item: __ptr { b256, u64, u64 }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1829 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr b256, v3, !1831 + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v7 = call abi_encode_68(v4, v5, v6) + v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1833 + mem_copy_val v8, v6 + v9 = const u64 1 + v10 = get_elem_ptr item, __ptr u64, v9, !1835 + v11 = load v10, !1829 + v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v14 = call abi_encode_20(v11, v12, v13) + v15 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !1837 + mem_copy_val v15, v13 + v16 = const u64 2 + v17 = get_elem_ptr item, __ptr u64, v16, !1839 + v18 = load v17, !1829 + v19 = get_local __ptr { { ptr, u64, u64 } }, buffer___ + v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v21 = call abi_encode_20(v18, v19, v20) + v22 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1841 + mem_copy_val v22, v20 + v23 = get_local __ptr { { ptr, u64, u64 } }, buffer____ + v24 = get_local __ptr slice, __ret_val2 + v25 = call as_raw_slice_22(v23, v24) + mem_copy_val __ret_value, v24 + v26 = const unit () + ret () v26 + } + + entry fn cost_of_in_u8() -> (), !1845 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u8 } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local slice __ret_val14 + local slice __ret_val15 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { b256, u64, u64 } __tmp_arg10 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { { ptr, u64, u64 } } __tmp_arg8 + local slice __tmp_arg9 + local { u8 } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { u8 } item_ + local slice method_name_ + local slice params + local slice second_parameter + local { u8 } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1846 + v2 = get_global __ptr string<5>, __const_global29 + v3 = cast_ptr v2 to ptr, !1847 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !1847 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !1847 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 5 + store v9 to v8, !1847 + v10 = get_local __ptr slice, __anon_1, !1847 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u8 }, __anon_2 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u8, v12 + v14 = const u8 0, !1848 + store v14 to v13 + v15 = get_local __ptr b256, contract_id_, !1849 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !1849 + mem_copy_val v16, v10 + v17 = get_local __ptr { u8 }, args_, !1849 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, asset_id_, !1849 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !1850 + v20 = get_local __ptr slice, __tmp_arg9 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val14 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !1851 + mem_copy_val v23, v21 + v24 = get_local __ptr { u8 }, args_, !1852 + v25 = get_local __ptr { u8 }, item_, !1853 + mem_copy_val v25, v24 + v26 = get_local __ptr { u8 }, item_, !1854 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { u8 }, self_, !1855 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1856 + mem_copy_val v30, v27 + v31 = get_local __ptr { u8 }, self_, !1857 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr u8, v32, !1858 + v34 = load v33, !1859 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1860 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 + mem_copy_val v36, v35 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v38 = call abi_encode_206(v34, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1861 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1862 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1863 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1864 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val8 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !1865 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !1866 + v48 = get_local __ptr slice, first_parameter, !1867 + v49 = get_local __ptr slice, self_0, !1868 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !1869 + v51 = get_local __ptr slice, slice_, !1870 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !1871 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !1868 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !1872 + v58 = load v57, !1868 + v59 = asm(a: v58) -> u64 a, !1873 { + } + v60 = get_local __ptr slice, second_parameter, !1874 + v61 = get_local __ptr slice, self_1, !1875 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !1876 + v63 = get_local __ptr slice, slice_0, !1877 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !1878 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !1875 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !1879 + v69 = load v68, !1875 + v70 = asm(a: v69) -> u64 a, !1880 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !1881 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !1882 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !1883 + store v59 to v75, !1884 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !1885 + store v70 to v77, !1886 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val15 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !1887 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1888 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1889 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val9 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !1890 + v96 = get_local __ptr slice, self_2, !1891 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !1892 + v98 = get_local __ptr slice, slice_1, !1893 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !1894 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !1891 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !1895 + v104 = load v103, !1891 + v105 = get_local __ptr b256, asset_id_, !1896 + v106 = get_local __ptr b256, __anon_10, !1849 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !1849 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !1897 + v111 = asm() -> ptr ret, !1898 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1899 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1900 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val10 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !1901 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !1902 + store v111 to v127, !1903 + v128 = get_local __ptr { ptr }, buffer, !1904 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1905 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1906 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val11 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !1907 + v143 = call read_72(v142), !1908 + v144 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v145 = call new_21(v144) + v146 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v146, v144 + v147 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v148 = const u64 103, !1814 + v149 = call abi_encode_20(v148, v146, v147) + v150 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1909 + mem_copy_val v150, v147 + v151 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1910 + v152 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v152, v151 + v153 = get_local __ptr slice, __ret_val12 + v154 = call as_raw_slice_22(v152, v153) + v155 = get_local __ptr slice, __log_arg2 + mem_copy_val v155, v153 + v156 = const u64 1515152261580153489 + log __ptr slice v155, v156 + v157 = const unit () + ret () v157 + } + + entry fn cost_of_in_u16() -> (), !1914 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64 } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local slice __ret_val14 + local slice __ret_val15 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { b256, u64, u64 } __tmp_arg10 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { { ptr, u64, u64 } } __tmp_arg8 + local slice __tmp_arg9 + local { u64 } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { u64 } item_ + local slice method_name_ + local slice params + local slice second_parameter + local { u64 } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1915 + v2 = get_global __ptr string<6>, __const_global30 + v3 = cast_ptr v2 to ptr, !1916 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !1916 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !1916 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 6 + store v9 to v8, !1916 + v10 = get_local __ptr slice, __anon_1, !1916 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64 }, __anon_2 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !1917 + store v14 to v13 + v15 = get_local __ptr b256, contract_id_, !1918 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !1918 + mem_copy_val v16, v10 + v17 = get_local __ptr { u64 }, args_, !1918 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, asset_id_, !1918 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !1919 + v20 = get_local __ptr slice, __tmp_arg9 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val14 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !1920 + mem_copy_val v23, v21 + v24 = get_local __ptr { u64 }, args_, !1921 + v25 = get_local __ptr { u64 }, item_, !1922 + mem_copy_val v25, v24 + v26 = get_local __ptr { u64 }, item_, !1923 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { u64 }, self_, !1924 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1925 + mem_copy_val v30, v27 + v31 = get_local __ptr { u64 }, self_, !1926 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr u64, v32, !1927 + v34 = load v33, !1928 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1929 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 + mem_copy_val v36, v35 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v38 = call abi_encode_181(v34, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1930 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1931 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1932 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1933 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val8 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !1934 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !1935 + v48 = get_local __ptr slice, first_parameter, !1936 + v49 = get_local __ptr slice, self_0, !1937 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !1938 + v51 = get_local __ptr slice, slice_, !1939 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !1940 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !1937 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !1941 + v58 = load v57, !1937 + v59 = asm(a: v58) -> u64 a, !1942 { + } + v60 = get_local __ptr slice, second_parameter, !1943 + v61 = get_local __ptr slice, self_1, !1944 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !1945 + v63 = get_local __ptr slice, slice_0, !1946 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !1947 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !1944 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !1948 + v69 = load v68, !1944 + v70 = asm(a: v69) -> u64 a, !1949 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !1950 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !1951 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !1952 + store v59 to v75, !1953 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !1954 + store v70 to v77, !1955 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val15 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !1956 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1957 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1958 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val9 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !1959 + v96 = get_local __ptr slice, self_2, !1960 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !1961 + v98 = get_local __ptr slice, slice_1, !1962 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !1963 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !1960 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !1964 + v104 = load v103, !1960 + v105 = get_local __ptr b256, asset_id_, !1965 + v106 = get_local __ptr b256, __anon_10, !1918 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !1918 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !1966 + v111 = asm() -> ptr ret, !1967 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1968 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1969 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val10 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !1970 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !1971 + store v111 to v127, !1972 + v128 = get_local __ptr { ptr }, buffer, !1973 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1974 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1975 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val11 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !1976 + v143 = call read_72(v142), !1977 + v144 = call read_72(v142), !1978 + v145 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v146 = call new_21(v145) + v147 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v147, v145 + v148 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v149 = const u64 103, !1814 + v150 = call abi_encode_20(v149, v147, v148) + v151 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1979 + mem_copy_val v151, v148 + v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1980 + v153 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v153, v152 + v154 = get_local __ptr slice, __ret_val12 + v155 = call as_raw_slice_22(v153, v154) + v156 = get_local __ptr slice, __log_arg2 + mem_copy_val v156, v154 + v157 = const u64 1515152261580153489 + log __ptr slice v156, v157 + v158 = const unit () + ret () v158 + } + + entry fn cost_of_in_u32() -> (), !1984 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64 } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local slice __ret_val14 + local slice __ret_val15 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { b256, u64, u64 } __tmp_arg10 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { { ptr, u64, u64 } } __tmp_arg8 + local slice __tmp_arg9 + local { u64 } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { u64 } item_ + local slice method_name_ + local slice params + local slice second_parameter + local { u64 } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1985 + v2 = get_global __ptr string<6>, __const_global31 + v3 = cast_ptr v2 to ptr, !1986 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !1986 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !1986 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 6 + store v9 to v8, !1986 + v10 = get_local __ptr slice, __anon_1, !1986 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64 }, __anon_2 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !1987 + store v14 to v13 + v15 = get_local __ptr b256, contract_id_, !1988 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !1988 + mem_copy_val v16, v10 + v17 = get_local __ptr { u64 }, args_, !1988 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, asset_id_, !1988 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !1989 + v20 = get_local __ptr slice, __tmp_arg9 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val14 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !1990 + mem_copy_val v23, v21 + v24 = get_local __ptr { u64 }, args_, !1991 + v25 = get_local __ptr { u64 }, item_, !1992 + mem_copy_val v25, v24 + v26 = get_local __ptr { u64 }, item_, !1993 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { u64 }, self_, !1994 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1995 + mem_copy_val v30, v27 + v31 = get_local __ptr { u64 }, self_, !1996 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr u64, v32, !1997 + v34 = load v33, !1998 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1999 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 + mem_copy_val v36, v35 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v38 = call abi_encode_198(v34, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2000 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2001 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2002 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2003 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val8 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !2004 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !2005 + v48 = get_local __ptr slice, first_parameter, !2006 + v49 = get_local __ptr slice, self_0, !2007 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !2008 + v51 = get_local __ptr slice, slice_, !2009 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !2010 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !2007 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !2011 + v58 = load v57, !2007 + v59 = asm(a: v58) -> u64 a, !2012 { + } + v60 = get_local __ptr slice, second_parameter, !2013 + v61 = get_local __ptr slice, self_1, !2014 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !2015 + v63 = get_local __ptr slice, slice_0, !2016 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !2017 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !2014 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !2018 + v69 = load v68, !2014 + v70 = asm(a: v69) -> u64 a, !2019 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2020 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !2021 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !2022 + store v59 to v75, !2023 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !2024 + store v70 to v77, !2025 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val15 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !2026 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2027 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2028 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val9 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !2029 + v96 = get_local __ptr slice, self_2, !2030 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !2031 + v98 = get_local __ptr slice, slice_1, !2032 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !2033 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !2030 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !2034 + v104 = load v103, !2030 + v105 = get_local __ptr b256, asset_id_, !2035 + v106 = get_local __ptr b256, __anon_10, !1988 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !1988 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !2036 + v111 = asm() -> ptr ret, !2037 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2038 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2039 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val10 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !2040 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !2041 + store v111 to v127, !2042 + v128 = get_local __ptr { ptr }, buffer, !2043 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2044 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2045 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val11 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !2046 + v143 = call abi_decode_191(v142), !2047 + v144 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v145 = call new_21(v144) + v146 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v146, v144 + v147 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v148 = const u64 103, !1814 + v149 = call abi_encode_20(v148, v146, v147) + v150 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2048 + mem_copy_val v150, v147 + v151 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2049 + v152 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v152, v151 + v153 = get_local __ptr slice, __ret_val12 + v154 = call as_raw_slice_22(v152, v153) + v155 = get_local __ptr slice, __log_arg2 + mem_copy_val v155, v153 + v156 = const u64 1515152261580153489 + log __ptr slice v155, v156 + v157 = const unit () + ret () v157 + } + + entry fn cost_of_in_u64() -> (), !2053 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64 } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { { ptr, u64, u64 } } __ret_val13 + local slice __ret_val14 + local slice __ret_val15 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { u64 } __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { u64 } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local b256 contract_id_ + local slice first_parameter + local { u64 } item_ + local slice method_name_ + local slice params + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2054 + v2 = get_global __ptr string<6>, __const_global32 + v3 = cast_ptr v2 to ptr, !2055 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !2055 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !2055 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 6 + store v9 to v8, !2055 + v10 = get_local __ptr slice, __anon_1, !2055 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64 }, __anon_2 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !2056 + store v14 to v13 + v15 = get_local __ptr b256, contract_id_, !2057 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !2057 + mem_copy_val v16, v10 + v17 = get_local __ptr { u64 }, args_, !2057 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, asset_id_, !2057 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !2058 + v20 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val14 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !2059 + mem_copy_val v23, v21 + v24 = get_local __ptr { u64 }, args_, !2060 + v25 = get_local __ptr { u64 }, item_, !2061 + mem_copy_val v25, v24 + v26 = get_local __ptr { u64 }, item_, !2062 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { u64 }, __tmp_arg8 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 + v32 = call abi_encode_131(v29, v30, v31) + v33 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2063 + mem_copy_val v33, v31 + v34 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2064 + v35 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v35, v34 + v36 = get_local __ptr slice, __ret_val8 + v37 = call as_raw_slice_22(v35, v36) + v38 = get_local __ptr slice, second_parameter, !2065 + mem_copy_val v38, v36 + v39 = get_local __ptr b256, contract_id_, !2066 + v40 = get_local __ptr slice, first_parameter, !2067 + v41 = get_local __ptr slice, self_, !2068 + mem_copy_val v41, v40 + v42 = get_local __ptr slice, self_, !2069 + v43 = get_local __ptr slice, slice_, !2070 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, slice_, !2071 + v45 = asm(ptr: v44) -> __ptr { ptr, u64 } ptr { + } + v46 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v46, v45 + v47 = get_local __ptr { ptr, u64 }, __anon_01, !2068 + mem_copy_val v47, v46 + v48 = const u64 0 + v49 = get_elem_ptr v47, __ptr ptr, v48, !2072 + v50 = load v49, !2068 + v51 = asm(a: v50) -> u64 a, !2073 { + } + v52 = get_local __ptr slice, second_parameter, !2074 + v53 = get_local __ptr slice, self_0, !2075 + mem_copy_val v53, v52 + v54 = get_local __ptr slice, self_0, !2076 + v55 = get_local __ptr slice, slice_0, !2077 + mem_copy_val v55, v54 + v56 = get_local __ptr slice, slice_0, !2078 + v57 = asm(ptr: v56) -> __ptr { ptr, u64 } ptr { + } + v58 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v58, v57 + v59 = get_local __ptr { ptr, u64 }, __anon_02, !2075 + mem_copy_val v59, v58 + v60 = get_elem_ptr v59, __ptr ptr, v48, !2079 + v61 = load v60, !2075 + v62 = asm(a: v61) -> u64 a, !2080 { + } + v63 = get_local __ptr { b256, u64, u64 }, __anon_00, !2081 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr b256, v64, !2082 + mem_copy_val v65, v39 + v66 = const u64 1 + v67 = get_elem_ptr v63, __ptr u64, v66, !2083 + store v51 to v67, !2084 + v68 = const u64 2 + v69 = get_elem_ptr v63, __ptr u64, v68, !2085 + store v62 to v69, !2086 + v70 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v70, v63 + v71 = get_local __ptr slice, __ret_val15 + v72 = call encode_212(v70, v71) + v73 = get_local __ptr slice, params, !2087 + mem_copy_val v73, v71 + v74 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v75 = call new_21(v74) + v76 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v76, v74 + v77 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v78 = const u64 100, !1772 + v79 = call abi_encode_20(v78, v76, v77) + v80 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2088 + mem_copy_val v80, v77 + v81 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2089 + v82 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v82, v81 + v83 = get_local __ptr slice, __ret_val9 + v84 = call as_raw_slice_22(v82, v83) + v85 = get_local __ptr slice, __log_arg + mem_copy_val v85, v83 + v86 = const u64 1515152261580153489 + log __ptr slice v85, v86 + v87 = get_local __ptr slice, params, !2090 + v88 = get_local __ptr slice, self_1, !2091 + mem_copy_val v88, v87 + v89 = get_local __ptr slice, self_1, !2092 + v90 = get_local __ptr slice, slice_1, !2093 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, slice_1, !2094 + v92 = asm(ptr: v91) -> __ptr { ptr, u64 } ptr { + } + v93 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v93, v92 + v94 = get_local __ptr { ptr, u64 }, __anon_03, !2091 + mem_copy_val v94, v93 + v95 = get_elem_ptr v94, __ptr ptr, v48, !2095 + v96 = load v95, !2091 + v97 = get_local __ptr b256, asset_id_, !2096 + v98 = get_local __ptr b256, __anon_10, !2057 + mem_copy_val v98, v97 + v99 = get_local __ptr b256, __anon_10, !2057 + v100 = const u64 0 + v101 = const u64 18446744073709551615 + v102 = contract_call __ptr () v96, v100, v99, v101, !2097 + v103 = asm() -> ptr ret, !2098 { + } + v104 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v105 = call new_21(v104) + v106 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v106, v104 + v107 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v108 = const u64 101, !1790 + v109 = call abi_encode_20(v108, v106, v107) + v110 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2099 + mem_copy_val v110, v107 + v111 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2100 + v112 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v112, v111 + v113 = get_local __ptr slice, __ret_val10 + v114 = call as_raw_slice_22(v112, v113) + v115 = get_local __ptr slice, __log_arg0 + mem_copy_val v115, v113 + v116 = const u64 1515152261580153489 + log __ptr slice v115, v116 + v117 = get_local __ptr { ptr }, __anon_000, !2101 + v118 = const u64 0 + v119 = get_elem_ptr v117, __ptr ptr, v118, !2102 + store v103 to v119, !2103 + v120 = get_local __ptr { ptr }, buffer, !2104 + mem_copy_val v120, v117 + v121 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v122 = call new_21(v121) + v123 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v123, v121 + v124 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v125 = const u64 102, !1801 + v126 = call abi_encode_20(v125, v123, v124) + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2105 + mem_copy_val v127, v124 + v128 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2106 + v129 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v129, v128 + v130 = get_local __ptr slice, __ret_val11 + v131 = call as_raw_slice_22(v129, v130) + v132 = get_local __ptr slice, __log_arg1 + mem_copy_val v132, v130 + v133 = const u64 1515152261580153489 + log __ptr slice v132, v133 + v134 = get_local __ptr { ptr }, buffer, !2107 + v135 = const u64 0 + v136 = get_elem_ptr v134, __ptr ptr, v135, !2108 + v137 = load v136, !2109 + v138 = asm(ptr: v137, val) -> u64 val, !2110 { + lw val ptr i0, !58 + } + v139 = load v136, !2109 + v140 = const u64 8, !2109 + v141 = add v139, v140, !2109 + store v141 to v136, !2111 + v142 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v143 = call new_21(v142) + v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v144, v142 + v145 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v146 = const u64 103, !1814 + v147 = call abi_encode_20(v146, v144, v145) + v148 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2112 + mem_copy_val v148, v145 + v149 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2113 + v150 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v150, v149 + v151 = get_local __ptr slice, __ret_val12 + v152 = call as_raw_slice_22(v150, v151) + v153 = get_local __ptr slice, __log_arg2 + mem_copy_val v153, v151 + v154 = const u64 1515152261580153489 + log __ptr slice v153, v154 + v155 = const unit () + ret () v155 + } + + entry fn cost_of_in_u256() -> (), !2117 { + local u256 _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u256 } __anon_2 + local u256 __const = const u256 0x0000000000000000000000000000000000000000000000000000000000000000 + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local u256 __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local u256 __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { u256 } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { u256 } item_ + local slice method_name_ + local slice params + local u256 r + local slice second_parameter + local { u256 } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr u256, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2118 + v3 = get_global __ptr string<7>, __const_global33 + v4 = cast_ptr v3 to ptr, !2119 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2119 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2119 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 7 + store v10 to v9, !2119 + v11 = get_local __ptr slice, __anon_1, !2119 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr { u256 }, __anon_2 + v13 = const u64 0 + v14 = get_elem_ptr v12, __ptr u256, v13 + mem_copy_val v14, v0 + v15 = get_local __ptr b256, contract_id_, !2120 + mem_copy_val v15, v2 + v16 = get_local __ptr slice, method_name_, !2120 + mem_copy_val v16, v11 + v17 = get_local __ptr { u256 }, args_, !2120 + mem_copy_val v17, v12 + v18 = get_local __ptr b256, asset_id_, !2120 + mem_copy_val v18, v1 + v19 = get_local __ptr slice, method_name_, !2121 + v20 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val15 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !2122 + mem_copy_val v23, v21 + v24 = get_local __ptr { u256 }, args_, !2123 + v25 = get_local __ptr { u256 }, item_, !2124 + mem_copy_val v25, v24 + v26 = get_local __ptr { u256 }, item_, !2125 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { u256 }, self_, !2126 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2127 + mem_copy_val v30, v27 + v31 = get_local __ptr { u256 }, self_, !2128 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr u256, v32, !2129 + v34 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2130 + v35 = get_local __ptr u256, __tmp_arg8 + mem_copy_val v35, v33 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v38 = call abi_encode_188(v35, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2131 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2132 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2133 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2134 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val8 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !2135 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !2136 + v48 = get_local __ptr slice, first_parameter, !2137 + v49 = get_local __ptr slice, self_0, !2138 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !2139 + v51 = get_local __ptr slice, slice_, !2140 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !2141 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !2138 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !2142 + v58 = load v57, !2138 + v59 = asm(a: v58) -> u64 a, !2143 { + } + v60 = get_local __ptr slice, second_parameter, !2144 + v61 = get_local __ptr slice, self_1, !2145 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !2146 + v63 = get_local __ptr slice, slice_0, !2147 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !2148 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !2145 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !2149 + v69 = load v68, !2145 + v70 = asm(a: v69) -> u64 a, !2150 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2151 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !2152 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !2153 + store v59 to v75, !2154 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !2155 + store v70 to v77, !2156 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val16 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !2157 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2158 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2159 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val9 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !2160 + v96 = get_local __ptr slice, self_2, !2161 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !2162 + v98 = get_local __ptr slice, slice_1, !2163 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !2164 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !2161 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !2165 + v104 = load v103, !2161 + v105 = get_local __ptr b256, asset_id_, !2166 + v106 = get_local __ptr b256, __anon_10, !2120 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !2120 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !2167 + v111 = asm() -> ptr ret, !2168 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2169 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2170 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val10 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !2171 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !2172 + store v111 to v127, !2173 + v128 = get_local __ptr { ptr }, buffer, !2174 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2175 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2176 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val11 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !2177 + v143 = get_local __ptr u256, __ret_val13 + v144 = call abi_decode_184(v142, v143) + v145 = get_local __ptr u256, r, !2179 + mem_copy_val v145, v143 + v146 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v147 = call new_21(v146) + v148 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v148, v146 + v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v150 = const u64 103, !1814 + v151 = call abi_encode_20(v150, v148, v149) + v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2180 + mem_copy_val v152, v149 + v153 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2181 + v154 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v154, v153 + v155 = get_local __ptr slice, __ret_val12 + v156 = call as_raw_slice_22(v154, v155) + v157 = get_local __ptr slice, __log_arg2 + mem_copy_val v157, v155 + v158 = const u64 1515152261580153489 + log __ptr slice v157, v158 + v159 = get_local __ptr u256, r, !2183 + v160 = get_local __ptr u256, _, !2184 + mem_copy_val v160, v159 + v161 = const unit () + ret () v161 + } + + entry fn cost_of_in_b256() -> (), !2188 { + local b256 _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { b256 } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local b256 __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local b256 __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { b256 } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { b256 } item_ + local slice method_name_ + local slice params + local b256 r + local slice second_parameter + local { b256 } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2189 + v3 = get_global __ptr string<7>, __const_global34 + v4 = cast_ptr v3 to ptr, !2190 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2190 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2190 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 7 + store v10 to v9, !2190 + v11 = get_local __ptr slice, __anon_1, !2190 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr { b256 }, __anon_2 + v13 = const u64 0 + v14 = get_elem_ptr v12, __ptr b256, v13 + mem_copy_val v14, v0 + v15 = get_local __ptr b256, contract_id_, !2191 + mem_copy_val v15, v2 + v16 = get_local __ptr slice, method_name_, !2191 + mem_copy_val v16, v11 + v17 = get_local __ptr { b256 }, args_, !2191 + mem_copy_val v17, v12 + v18 = get_local __ptr b256, asset_id_, !2191 + mem_copy_val v18, v1 + v19 = get_local __ptr slice, method_name_, !2192 + v20 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val15 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !2193 + mem_copy_val v23, v21 + v24 = get_local __ptr { b256 }, args_, !2194 + v25 = get_local __ptr { b256 }, item_, !2195 + mem_copy_val v25, v24 + v26 = get_local __ptr { b256 }, item_, !2196 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { b256 }, self_, !2197 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2198 + mem_copy_val v30, v27 + v31 = get_local __ptr { b256 }, self_, !2199 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr b256, v32, !2200 + v34 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2201 + v35 = get_local __ptr b256, __tmp_arg8 + mem_copy_val v35, v33 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v38 = call abi_encode_68(v35, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2202 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2203 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2204 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2205 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val8 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !2206 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !2207 + v48 = get_local __ptr slice, first_parameter, !2208 + v49 = get_local __ptr slice, self_0, !2209 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !2210 + v51 = get_local __ptr slice, slice_, !2211 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !2212 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !2209 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !2213 + v58 = load v57, !2209 + v59 = asm(a: v58) -> u64 a, !2214 { + } + v60 = get_local __ptr slice, second_parameter, !2215 + v61 = get_local __ptr slice, self_1, !2216 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !2217 + v63 = get_local __ptr slice, slice_0, !2218 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !2219 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !2216 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !2220 + v69 = load v68, !2216 + v70 = asm(a: v69) -> u64 a, !2221 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2222 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !2223 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !2224 + store v59 to v75, !2225 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !2226 + store v70 to v77, !2227 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val16 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !2228 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2229 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2230 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val9 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !2231 + v96 = get_local __ptr slice, self_2, !2232 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !2233 + v98 = get_local __ptr slice, slice_1, !2234 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !2235 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !2232 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !2236 + v104 = load v103, !2232 + v105 = get_local __ptr b256, asset_id_, !2237 + v106 = get_local __ptr b256, __anon_10, !2191 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !2191 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !2238 + v111 = asm() -> ptr ret, !2239 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2240 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2241 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val10 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !2242 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !2243 + store v111 to v127, !2244 + v128 = get_local __ptr { ptr }, buffer, !2245 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2246 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2247 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val11 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !2248 + v143 = get_local __ptr b256, __ret_val13 + v144 = call abi_decode_64(v142, v143) + v145 = get_local __ptr b256, r, !2249 + mem_copy_val v145, v143 + v146 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v147 = call new_21(v146) + v148 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v148, v146 + v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v150 = const u64 103, !1814 + v151 = call abi_encode_20(v150, v148, v149) + v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2250 + mem_copy_val v152, v149 + v153 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2251 + v154 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v154, v153 + v155 = get_local __ptr slice, __ret_val12 + v156 = call as_raw_slice_22(v154, v155) + v157 = get_local __ptr slice, __log_arg2 + mem_copy_val v157, v155 + v158 = const u64 1515152261580153489 + log __ptr slice v157, v158 + v159 = get_local __ptr b256, r, !2252 + v160 = get_local __ptr b256, _, !2253 + mem_copy_val v160, v159 + v161 = const unit () + ret () v161 + } + + entry fn cost_of_in_str_0() -> (), !2257 { + local string<0> _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut string<0> __aggr_memcpy_03 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local { ptr, u64 } __anon_04 + local slice __anon_1 + local b256 __anon_10 + local string<0> __anon_2 + local { string<0> } __anon_3 + local string<0> __const = const string<0> "" + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local slice __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local string<0> __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { string<0> } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice data + local slice first_parameter + local { string<0> } item_ + local slice method_name_ + local slice params + local string<0> r + local slice second_parameter + local { string<0> } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice self_3 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_2 + + entry(): + v0 = get_local __ptr string<0>, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2258 + v3 = get_global __ptr string<8>, __const_global35 + v4 = cast_ptr v3 to ptr, !2259 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2259 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2259 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 8 + store v10 to v9, !2259 + v11 = get_local __ptr slice, __anon_1, !2259 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr string<0>, __anon_2 + mem_copy_val v12, v0 + v13 = get_local __ptr { string<0> }, __anon_3 + v14 = const u64 0 + v15 = get_elem_ptr v13, __ptr string<0>, v14 + mem_copy_val v15, v12 + v16 = get_local __ptr b256, contract_id_, !2260 + mem_copy_val v16, v2 + v17 = get_local __ptr slice, method_name_, !2260 + mem_copy_val v17, v11 + v18 = get_local __ptr { string<0> }, args_, !2260 + mem_copy_val v18, v13 + v19 = get_local __ptr b256, asset_id_, !2260 + mem_copy_val v19, v1 + v20 = get_local __ptr slice, method_name_, !2261 + v21 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v21, v20 + v22 = get_local __ptr slice, __ret_val15 + v23 = call encode_208(v21, v22) + v24 = get_local __ptr slice, first_parameter, !2262 + mem_copy_val v24, v22 + v25 = get_local __ptr { string<0> }, args_, !2263 + v26 = get_local __ptr { string<0> }, item_, !2264 + mem_copy_val v26, v25 + v27 = get_local __ptr { string<0> }, item_, !2265 + v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v29 = call new_21(v28) + v30 = get_local __ptr { string<0> }, self_, !2266 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2267 + mem_copy_val v31, v28 + v32 = get_local __ptr { string<0> }, self_, !2268 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr string<0>, v33, !2269 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2270 + v36 = get_local __ptr string<0>, __tmp_arg8 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v37, v35 + v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v39 = call abi_encode_101(v36, v37, v38) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2271 + mem_copy_val v40, v38 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2272 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2273 + mem_copy_val v42, v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2274 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v44, v43 + v45 = get_local __ptr slice, __ret_val9 + v46 = call as_raw_slice_22(v44, v45) + v47 = get_local __ptr slice, second_parameter, !2275 + mem_copy_val v47, v45 + v48 = get_local __ptr b256, contract_id_, !2276 + v49 = get_local __ptr slice, first_parameter, !2277 + v50 = get_local __ptr slice, self_0, !2278 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, self_0, !2279 + v52 = get_local __ptr slice, slice_, !2280 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, slice_, !2281 + v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { + } + v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v55, v54 + v56 = get_local __ptr { ptr, u64 }, __anon_01, !2278 + mem_copy_val v56, v55 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr ptr, v57, !2282 + v59 = load v58, !2278 + v60 = asm(a: v59) -> u64 a, !2283 { + } + v61 = get_local __ptr slice, second_parameter, !2284 + v62 = get_local __ptr slice, self_1, !2285 + mem_copy_val v62, v61 + v63 = get_local __ptr slice, self_1, !2286 + v64 = get_local __ptr slice, slice_0, !2287 + mem_copy_val v64, v63 + v65 = get_local __ptr slice, slice_0, !2288 + v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { + } + v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v67, v66 + v68 = get_local __ptr { ptr, u64 }, __anon_02, !2285 + mem_copy_val v68, v67 + v69 = get_elem_ptr v68, __ptr ptr, v57, !2289 + v70 = load v69, !2285 + v71 = asm(a: v70) -> u64 a, !2290 { + } + v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2291 + v73 = const u64 0 + v74 = get_elem_ptr v72, __ptr b256, v73, !2292 + mem_copy_val v74, v48 + v75 = const u64 1 + v76 = get_elem_ptr v72, __ptr u64, v75, !2293 + store v60 to v76, !2294 + v77 = const u64 2 + v78 = get_elem_ptr v72, __ptr u64, v77, !2295 + store v71 to v78, !2296 + v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v79, v72 + v80 = get_local __ptr slice, __ret_val16 + v81 = call encode_212(v79, v80) + v82 = get_local __ptr slice, params, !2297 + mem_copy_val v82, v80 + v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v84 = call new_21(v83) + v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v85, v83 + v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v87 = const u64 100, !1772 + v88 = call abi_encode_20(v87, v85, v86) + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2298 + mem_copy_val v89, v86 + v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2299 + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, __ret_val10 + v93 = call as_raw_slice_22(v91, v92) + v94 = get_local __ptr slice, __log_arg + mem_copy_val v94, v92 + v95 = const u64 1515152261580153489 + log __ptr slice v94, v95 + v96 = get_local __ptr slice, params, !2300 + v97 = get_local __ptr slice, self_2, !2301 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, self_2, !2302 + v99 = get_local __ptr slice, slice_1, !2303 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, slice_1, !2304 + v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { + } + v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v102, v101 + v103 = get_local __ptr { ptr, u64 }, __anon_03, !2301 + mem_copy_val v103, v102 + v104 = get_elem_ptr v103, __ptr ptr, v57, !2305 + v105 = load v104, !2301 + v106 = get_local __ptr b256, asset_id_, !2306 + v107 = get_local __ptr b256, __anon_10, !2260 + mem_copy_val v107, v106 + v108 = get_local __ptr b256, __anon_10, !2260 + v109 = const u64 0 + v110 = const u64 18446744073709551615 + v111 = contract_call __ptr () v105, v109, v108, v110, !2307 + v112 = asm() -> ptr ret, !2308 { + } + v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v114 = call new_21(v113) + v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v115, v113 + v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v117 = const u64 101, !1790 + v118 = call abi_encode_20(v117, v115, v116) + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2309 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2310 + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v121, v120 + v122 = get_local __ptr slice, __ret_val11 + v123 = call as_raw_slice_22(v121, v122) + v124 = get_local __ptr slice, __log_arg0 + mem_copy_val v124, v122 + v125 = const u64 1515152261580153489 + log __ptr slice v124, v125 + v126 = get_local __ptr { ptr }, __anon_000, !2311 + v127 = const u64 0 + v128 = get_elem_ptr v126, __ptr ptr, v127, !2312 + store v112 to v128, !2313 + v129 = get_local __ptr { ptr }, buffer, !2314 + mem_copy_val v129, v126 + v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v131 = call new_21(v130) + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v132, v130 + v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v134 = const u64 102, !1801 + v135 = call abi_encode_20(v134, v132, v133) + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2315 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2316 + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v138, v137 + v139 = get_local __ptr slice, __ret_val12 + v140 = call as_raw_slice_22(v138, v139) + v141 = get_local __ptr slice, __log_arg1 + mem_copy_val v141, v139 + v142 = const u64 1515152261580153489 + log __ptr slice v141, v142 + v143 = get_local __ptr { ptr }, buffer, !2317 + v144 = get_local __ptr slice, __ret_val + v145 = const u64 0 + v146 = call read_bytes_8(v143, v145, v144) + v147 = get_local __ptr slice, data, !2318 + mem_copy_val v147, v144 + v148 = get_local __ptr slice, data, !2319 + v149 = get_local __ptr slice, self_3, !2320 + mem_copy_val v149, v148 + v150 = get_local __ptr slice, self_3, !2321 + v151 = get_local __ptr slice, slice_2, !2322 + mem_copy_val v151, v150 + v152 = get_local __ptr slice, slice_2, !2323 + v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { + } + v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v154, v153 + v155 = get_local __ptr { ptr, u64 }, __anon_04, !2320 + mem_copy_val v155, v154 + v156 = get_elem_ptr v155, __ptr ptr, v57, !2324 + v157 = load v156, !2320 + v158 = asm(s: v157) -> __ptr string<0> s { + } + v159 = get_local __ptr string<0>, __aggr_memcpy_03 + mem_copy_val v159, v158 + v160 = get_local __ptr string<0>, r, !2325 + mem_copy_val v160, v159 + v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v162 = call new_21(v161) + v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v163, v161 + v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v165 = const u64 103, !1814 + v166 = call abi_encode_20(v165, v163, v164) + v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2326 + mem_copy_val v167, v164 + v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2327 + v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v169, v168 + v170 = get_local __ptr slice, __ret_val13 + v171 = call as_raw_slice_22(v169, v170) + v172 = get_local __ptr slice, __log_arg2 + mem_copy_val v172, v170 + v173 = const u64 1515152261580153489 + log __ptr slice v172, v173 + v174 = get_local __ptr string<0>, r, !2328 + v175 = get_local __ptr string<0>, _, !2329 + mem_copy_val v175, v174 + v176 = const unit () + ret () v176 + } + + entry fn cost_of_in_str_1() -> (), !2333 { + local string<1> _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut string<1> __aggr_memcpy_03 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local { ptr, u64 } __anon_04 + local slice __anon_1 + local b256 __anon_10 + local string<1> __anon_2 + local { string<1> } __anon_3 + local string<1> __const = const string<1> "1" + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local slice __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local string<1> __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { string<1> } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice data + local slice first_parameter + local { string<1> } item_ + local slice method_name_ + local slice params + local string<1> r + local slice second_parameter + local { string<1> } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice self_3 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_2 + + entry(): + v0 = get_local __ptr string<1>, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2334 + v3 = get_global __ptr string<8>, __const_global36 + v4 = cast_ptr v3 to ptr, !2335 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2335 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2335 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 8 + store v10 to v9, !2335 + v11 = get_local __ptr slice, __anon_1, !2335 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr string<1>, __anon_2 + mem_copy_val v12, v0 + v13 = get_local __ptr { string<1> }, __anon_3 + v14 = const u64 0 + v15 = get_elem_ptr v13, __ptr string<1>, v14 + mem_copy_val v15, v12 + v16 = get_local __ptr b256, contract_id_, !2336 + mem_copy_val v16, v2 + v17 = get_local __ptr slice, method_name_, !2336 + mem_copy_val v17, v11 + v18 = get_local __ptr { string<1> }, args_, !2336 + mem_copy_val v18, v13 + v19 = get_local __ptr b256, asset_id_, !2336 + mem_copy_val v19, v1 + v20 = get_local __ptr slice, method_name_, !2337 + v21 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v21, v20 + v22 = get_local __ptr slice, __ret_val15 + v23 = call encode_208(v21, v22) + v24 = get_local __ptr slice, first_parameter, !2338 + mem_copy_val v24, v22 + v25 = get_local __ptr { string<1> }, args_, !2339 + v26 = get_local __ptr { string<1> }, item_, !2340 + mem_copy_val v26, v25 + v27 = get_local __ptr { string<1> }, item_, !2341 + v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v29 = call new_21(v28) + v30 = get_local __ptr { string<1> }, self_, !2342 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2343 + mem_copy_val v31, v28 + v32 = get_local __ptr { string<1> }, self_, !2344 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr string<1>, v33, !2345 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2346 + v36 = get_local __ptr string<1>, __tmp_arg8 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v37, v35 + v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v39 = call abi_encode_107(v36, v37, v38) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2347 + mem_copy_val v40, v38 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2348 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2349 + mem_copy_val v42, v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2350 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v44, v43 + v45 = get_local __ptr slice, __ret_val9 + v46 = call as_raw_slice_22(v44, v45) + v47 = get_local __ptr slice, second_parameter, !2351 + mem_copy_val v47, v45 + v48 = get_local __ptr b256, contract_id_, !2352 + v49 = get_local __ptr slice, first_parameter, !2353 + v50 = get_local __ptr slice, self_0, !2354 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, self_0, !2355 + v52 = get_local __ptr slice, slice_, !2356 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, slice_, !2357 + v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { + } + v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v55, v54 + v56 = get_local __ptr { ptr, u64 }, __anon_01, !2354 + mem_copy_val v56, v55 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr ptr, v57, !2358 + v59 = load v58, !2354 + v60 = asm(a: v59) -> u64 a, !2359 { + } + v61 = get_local __ptr slice, second_parameter, !2360 + v62 = get_local __ptr slice, self_1, !2361 + mem_copy_val v62, v61 + v63 = get_local __ptr slice, self_1, !2362 + v64 = get_local __ptr slice, slice_0, !2363 + mem_copy_val v64, v63 + v65 = get_local __ptr slice, slice_0, !2364 + v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { + } + v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v67, v66 + v68 = get_local __ptr { ptr, u64 }, __anon_02, !2361 + mem_copy_val v68, v67 + v69 = get_elem_ptr v68, __ptr ptr, v57, !2365 + v70 = load v69, !2361 + v71 = asm(a: v70) -> u64 a, !2366 { + } + v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2367 + v73 = const u64 0 + v74 = get_elem_ptr v72, __ptr b256, v73, !2368 + mem_copy_val v74, v48 + v75 = const u64 1 + v76 = get_elem_ptr v72, __ptr u64, v75, !2369 + store v60 to v76, !2370 + v77 = const u64 2 + v78 = get_elem_ptr v72, __ptr u64, v77, !2371 + store v71 to v78, !2372 + v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v79, v72 + v80 = get_local __ptr slice, __ret_val16 + v81 = call encode_212(v79, v80) + v82 = get_local __ptr slice, params, !2373 + mem_copy_val v82, v80 + v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v84 = call new_21(v83) + v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v85, v83 + v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v87 = const u64 100, !1772 + v88 = call abi_encode_20(v87, v85, v86) + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2374 + mem_copy_val v89, v86 + v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2375 + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, __ret_val10 + v93 = call as_raw_slice_22(v91, v92) + v94 = get_local __ptr slice, __log_arg + mem_copy_val v94, v92 + v95 = const u64 1515152261580153489 + log __ptr slice v94, v95 + v96 = get_local __ptr slice, params, !2376 + v97 = get_local __ptr slice, self_2, !2377 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, self_2, !2378 + v99 = get_local __ptr slice, slice_1, !2379 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, slice_1, !2380 + v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { + } + v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v102, v101 + v103 = get_local __ptr { ptr, u64 }, __anon_03, !2377 + mem_copy_val v103, v102 + v104 = get_elem_ptr v103, __ptr ptr, v57, !2381 + v105 = load v104, !2377 + v106 = get_local __ptr b256, asset_id_, !2382 + v107 = get_local __ptr b256, __anon_10, !2336 + mem_copy_val v107, v106 + v108 = get_local __ptr b256, __anon_10, !2336 + v109 = const u64 0 + v110 = const u64 18446744073709551615 + v111 = contract_call __ptr () v105, v109, v108, v110, !2383 + v112 = asm() -> ptr ret, !2384 { + } + v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v114 = call new_21(v113) + v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v115, v113 + v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v117 = const u64 101, !1790 + v118 = call abi_encode_20(v117, v115, v116) + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2385 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2386 + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v121, v120 + v122 = get_local __ptr slice, __ret_val11 + v123 = call as_raw_slice_22(v121, v122) + v124 = get_local __ptr slice, __log_arg0 + mem_copy_val v124, v122 + v125 = const u64 1515152261580153489 + log __ptr slice v124, v125 + v126 = get_local __ptr { ptr }, __anon_000, !2387 + v127 = const u64 0 + v128 = get_elem_ptr v126, __ptr ptr, v127, !2388 + store v112 to v128, !2389 + v129 = get_local __ptr { ptr }, buffer, !2390 + mem_copy_val v129, v126 + v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v131 = call new_21(v130) + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v132, v130 + v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v134 = const u64 102, !1801 + v135 = call abi_encode_20(v134, v132, v133) + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2391 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2392 + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v138, v137 + v139 = get_local __ptr slice, __ret_val12 + v140 = call as_raw_slice_22(v138, v139) + v141 = get_local __ptr slice, __log_arg1 + mem_copy_val v141, v139 + v142 = const u64 1515152261580153489 + log __ptr slice v141, v142 + v143 = get_local __ptr { ptr }, buffer, !2393 + v144 = get_local __ptr slice, __ret_val + v145 = const u64 1 + v146 = call read_bytes_8(v143, v145, v144) + v147 = get_local __ptr slice, data, !2394 + mem_copy_val v147, v144 + v148 = get_local __ptr slice, data, !2395 + v149 = get_local __ptr slice, self_3, !2396 + mem_copy_val v149, v148 + v150 = get_local __ptr slice, self_3, !2397 + v151 = get_local __ptr slice, slice_2, !2398 + mem_copy_val v151, v150 + v152 = get_local __ptr slice, slice_2, !2399 + v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { + } + v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v154, v153 + v155 = get_local __ptr { ptr, u64 }, __anon_04, !2396 + mem_copy_val v155, v154 + v156 = get_elem_ptr v155, __ptr ptr, v57, !2400 + v157 = load v156, !2396 + v158 = asm(s: v157) -> __ptr string<1> s { + } + v159 = get_local __ptr string<1>, __aggr_memcpy_03 + mem_copy_val v159, v158 + v160 = get_local __ptr string<1>, r, !2401 + mem_copy_val v160, v159 + v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v162 = call new_21(v161) + v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v163, v161 + v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v165 = const u64 103, !1814 + v166 = call abi_encode_20(v165, v163, v164) + v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2402 + mem_copy_val v167, v164 + v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2403 + v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v169, v168 + v170 = get_local __ptr slice, __ret_val13 + v171 = call as_raw_slice_22(v169, v170) + v172 = get_local __ptr slice, __log_arg2 + mem_copy_val v172, v170 + v173 = const u64 1515152261580153489 + log __ptr slice v172, v173 + v174 = get_local __ptr string<1>, r, !2404 + v175 = get_local __ptr string<1>, _, !2405 + mem_copy_val v175, v174 + v176 = const unit () + ret () v176 + } + + entry fn cost_of_in_str_8() -> (), !2409 { + local string<8> _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut string<8> __aggr_memcpy_03 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local { ptr, u64 } __anon_04 + local slice __anon_1 + local b256 __anon_10 + local string<8> __anon_2 + local { string<8> } __anon_3 + local string<8> __const = const string<8> "12345678" + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local slice __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local string<8> __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { string<8> } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice data + local slice first_parameter + local { string<8> } item_ + local slice method_name_ + local slice params + local string<8> r + local slice second_parameter + local { string<8> } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice self_3 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_2 + + entry(): + v0 = get_local __ptr string<8>, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2410 + v3 = get_global __ptr string<8>, __const_global37 + v4 = cast_ptr v3 to ptr, !2411 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2411 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2411 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 8 + store v10 to v9, !2411 + v11 = get_local __ptr slice, __anon_1, !2411 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr string<8>, __anon_2 + mem_copy_val v12, v0 + v13 = get_local __ptr { string<8> }, __anon_3 + v14 = const u64 0 + v15 = get_elem_ptr v13, __ptr string<8>, v14 + mem_copy_val v15, v12 + v16 = get_local __ptr b256, contract_id_, !2412 + mem_copy_val v16, v2 + v17 = get_local __ptr slice, method_name_, !2412 + mem_copy_val v17, v11 + v18 = get_local __ptr { string<8> }, args_, !2412 + mem_copy_val v18, v13 + v19 = get_local __ptr b256, asset_id_, !2412 + mem_copy_val v19, v1 + v20 = get_local __ptr slice, method_name_, !2413 + v21 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v21, v20 + v22 = get_local __ptr slice, __ret_val15 + v23 = call encode_208(v21, v22) + v24 = get_local __ptr slice, first_parameter, !2414 + mem_copy_val v24, v22 + v25 = get_local __ptr { string<8> }, args_, !2415 + v26 = get_local __ptr { string<8> }, item_, !2416 + mem_copy_val v26, v25 + v27 = get_local __ptr { string<8> }, item_, !2417 + v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v29 = call new_21(v28) + v30 = get_local __ptr { string<8> }, self_, !2418 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2419 + mem_copy_val v31, v28 + v32 = get_local __ptr { string<8> }, self_, !2420 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr string<8>, v33, !2421 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2422 + v36 = get_local __ptr string<8>, __tmp_arg8 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v37, v35 + v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v39 = call abi_encode_125(v36, v37, v38) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2423 + mem_copy_val v40, v38 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2424 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2425 + mem_copy_val v42, v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2426 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v44, v43 + v45 = get_local __ptr slice, __ret_val9 + v46 = call as_raw_slice_22(v44, v45) + v47 = get_local __ptr slice, second_parameter, !2427 + mem_copy_val v47, v45 + v48 = get_local __ptr b256, contract_id_, !2428 + v49 = get_local __ptr slice, first_parameter, !2429 + v50 = get_local __ptr slice, self_0, !2430 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, self_0, !2431 + v52 = get_local __ptr slice, slice_, !2432 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, slice_, !2433 + v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { + } + v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v55, v54 + v56 = get_local __ptr { ptr, u64 }, __anon_01, !2430 + mem_copy_val v56, v55 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr ptr, v57, !2434 + v59 = load v58, !2430 + v60 = asm(a: v59) -> u64 a, !2435 { + } + v61 = get_local __ptr slice, second_parameter, !2436 + v62 = get_local __ptr slice, self_1, !2437 + mem_copy_val v62, v61 + v63 = get_local __ptr slice, self_1, !2438 + v64 = get_local __ptr slice, slice_0, !2439 + mem_copy_val v64, v63 + v65 = get_local __ptr slice, slice_0, !2440 + v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { + } + v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v67, v66 + v68 = get_local __ptr { ptr, u64 }, __anon_02, !2437 + mem_copy_val v68, v67 + v69 = get_elem_ptr v68, __ptr ptr, v57, !2441 + v70 = load v69, !2437 + v71 = asm(a: v70) -> u64 a, !2442 { + } + v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2443 + v73 = const u64 0 + v74 = get_elem_ptr v72, __ptr b256, v73, !2444 + mem_copy_val v74, v48 + v75 = const u64 1 + v76 = get_elem_ptr v72, __ptr u64, v75, !2445 + store v60 to v76, !2446 + v77 = const u64 2 + v78 = get_elem_ptr v72, __ptr u64, v77, !2447 + store v71 to v78, !2448 + v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v79, v72 + v80 = get_local __ptr slice, __ret_val16 + v81 = call encode_212(v79, v80) + v82 = get_local __ptr slice, params, !2449 + mem_copy_val v82, v80 + v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v84 = call new_21(v83) + v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v85, v83 + v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v87 = const u64 100, !1772 + v88 = call abi_encode_20(v87, v85, v86) + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2450 + mem_copy_val v89, v86 + v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2451 + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, __ret_val10 + v93 = call as_raw_slice_22(v91, v92) + v94 = get_local __ptr slice, __log_arg + mem_copy_val v94, v92 + v95 = const u64 1515152261580153489 + log __ptr slice v94, v95 + v96 = get_local __ptr slice, params, !2452 + v97 = get_local __ptr slice, self_2, !2453 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, self_2, !2454 + v99 = get_local __ptr slice, slice_1, !2455 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, slice_1, !2456 + v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { + } + v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v102, v101 + v103 = get_local __ptr { ptr, u64 }, __anon_03, !2453 + mem_copy_val v103, v102 + v104 = get_elem_ptr v103, __ptr ptr, v57, !2457 + v105 = load v104, !2453 + v106 = get_local __ptr b256, asset_id_, !2458 + v107 = get_local __ptr b256, __anon_10, !2412 + mem_copy_val v107, v106 + v108 = get_local __ptr b256, __anon_10, !2412 + v109 = const u64 0 + v110 = const u64 18446744073709551615 + v111 = contract_call __ptr () v105, v109, v108, v110, !2459 + v112 = asm() -> ptr ret, !2460 { + } + v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v114 = call new_21(v113) + v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v115, v113 + v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v117 = const u64 101, !1790 + v118 = call abi_encode_20(v117, v115, v116) + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2461 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2462 + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v121, v120 + v122 = get_local __ptr slice, __ret_val11 + v123 = call as_raw_slice_22(v121, v122) + v124 = get_local __ptr slice, __log_arg0 + mem_copy_val v124, v122 + v125 = const u64 1515152261580153489 + log __ptr slice v124, v125 + v126 = get_local __ptr { ptr }, __anon_000, !2463 + v127 = const u64 0 + v128 = get_elem_ptr v126, __ptr ptr, v127, !2464 + store v112 to v128, !2465 + v129 = get_local __ptr { ptr }, buffer, !2466 + mem_copy_val v129, v126 + v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v131 = call new_21(v130) + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v132, v130 + v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v134 = const u64 102, !1801 + v135 = call abi_encode_20(v134, v132, v133) + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2467 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2468 + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v138, v137 + v139 = get_local __ptr slice, __ret_val12 + v140 = call as_raw_slice_22(v138, v139) + v141 = get_local __ptr slice, __log_arg1 + mem_copy_val v141, v139 + v142 = const u64 1515152261580153489 + log __ptr slice v141, v142 + v143 = get_local __ptr { ptr }, buffer, !2469 + v144 = get_local __ptr slice, __ret_val + v145 = const u64 8 + v146 = call read_bytes_8(v143, v145, v144) + v147 = get_local __ptr slice, data, !2470 + mem_copy_val v147, v144 + v148 = get_local __ptr slice, data, !2471 + v149 = get_local __ptr slice, self_3, !2472 + mem_copy_val v149, v148 + v150 = get_local __ptr slice, self_3, !2473 + v151 = get_local __ptr slice, slice_2, !2474 + mem_copy_val v151, v150 + v152 = get_local __ptr slice, slice_2, !2475 + v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { + } + v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v154, v153 + v155 = get_local __ptr { ptr, u64 }, __anon_04, !2472 + mem_copy_val v155, v154 + v156 = get_elem_ptr v155, __ptr ptr, v57, !2476 + v157 = load v156, !2472 + v158 = asm(s: v157) -> __ptr string<8> s { + } + v159 = get_local __ptr string<8>, __aggr_memcpy_03 + mem_copy_val v159, v158 + v160 = get_local __ptr string<8>, r, !2477 + mem_copy_val v160, v159 + v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v162 = call new_21(v161) + v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v163, v161 + v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v165 = const u64 103, !1814 + v166 = call abi_encode_20(v165, v163, v164) + v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2478 + mem_copy_val v167, v164 + v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2479 + v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v169, v168 + v170 = get_local __ptr slice, __ret_val13 + v171 = call as_raw_slice_22(v169, v170) + v172 = get_local __ptr slice, __log_arg2 + mem_copy_val v172, v170 + v173 = const u64 1515152261580153489 + log __ptr slice v172, v173 + v174 = get_local __ptr string<8>, r, !2480 + v175 = get_local __ptr string<8>, _, !2481 + mem_copy_val v175, v174 + v176 = const unit () + ret () v176 + } + + entry fn cost_of_in_str_16() -> (), !2485 { + local string<16> _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut string<16> __aggr_memcpy_03 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local { ptr, u64 } __anon_04 + local slice __anon_1 + local b256 __anon_10 + local string<16> __anon_2 + local { string<16> } __anon_3 + local string<16> __const = const string<16> "1234567890123456" + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local slice __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local string<16> __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { string<16> } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice data + local slice first_parameter + local { string<16> } item_ + local slice method_name_ + local slice params + local string<16> r + local slice second_parameter + local { string<16> } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice self_3 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_2 + + entry(): + v0 = get_local __ptr string<16>, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2486 + v3 = get_global __ptr string<9>, __const_global38 + v4 = cast_ptr v3 to ptr, !2487 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2487 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2487 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 9 + store v10 to v9, !2487 + v11 = get_local __ptr slice, __anon_1, !2487 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr string<16>, __anon_2 + mem_copy_val v12, v0 + v13 = get_local __ptr { string<16> }, __anon_3 + v14 = const u64 0 + v15 = get_elem_ptr v13, __ptr string<16>, v14 + mem_copy_val v15, v12 + v16 = get_local __ptr b256, contract_id_, !2488 + mem_copy_val v16, v2 + v17 = get_local __ptr slice, method_name_, !2488 + mem_copy_val v17, v11 + v18 = get_local __ptr { string<16> }, args_, !2488 + mem_copy_val v18, v13 + v19 = get_local __ptr b256, asset_id_, !2488 + mem_copy_val v19, v1 + v20 = get_local __ptr slice, method_name_, !2489 + v21 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v21, v20 + v22 = get_local __ptr slice, __ret_val15 + v23 = call encode_208(v21, v22) + v24 = get_local __ptr slice, first_parameter, !2490 + mem_copy_val v24, v22 + v25 = get_local __ptr { string<16> }, args_, !2491 + v26 = get_local __ptr { string<16> }, item_, !2492 + mem_copy_val v26, v25 + v27 = get_local __ptr { string<16> }, item_, !2493 + v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v29 = call new_21(v28) + v30 = get_local __ptr { string<16> }, self_, !2494 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2495 + mem_copy_val v31, v28 + v32 = get_local __ptr { string<16> }, self_, !2496 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr string<16>, v33, !2497 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2498 + v36 = get_local __ptr string<16>, __tmp_arg8 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v37, v35 + v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v39 = call abi_encode_113(v36, v37, v38) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2499 + mem_copy_val v40, v38 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2500 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2501 + mem_copy_val v42, v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2502 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v44, v43 + v45 = get_local __ptr slice, __ret_val9 + v46 = call as_raw_slice_22(v44, v45) + v47 = get_local __ptr slice, second_parameter, !2503 + mem_copy_val v47, v45 + v48 = get_local __ptr b256, contract_id_, !2504 + v49 = get_local __ptr slice, first_parameter, !2505 + v50 = get_local __ptr slice, self_0, !2506 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, self_0, !2507 + v52 = get_local __ptr slice, slice_, !2508 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, slice_, !2509 + v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { + } + v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v55, v54 + v56 = get_local __ptr { ptr, u64 }, __anon_01, !2506 + mem_copy_val v56, v55 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr ptr, v57, !2510 + v59 = load v58, !2506 + v60 = asm(a: v59) -> u64 a, !2511 { + } + v61 = get_local __ptr slice, second_parameter, !2512 + v62 = get_local __ptr slice, self_1, !2513 + mem_copy_val v62, v61 + v63 = get_local __ptr slice, self_1, !2514 + v64 = get_local __ptr slice, slice_0, !2515 + mem_copy_val v64, v63 + v65 = get_local __ptr slice, slice_0, !2516 + v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { + } + v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v67, v66 + v68 = get_local __ptr { ptr, u64 }, __anon_02, !2513 + mem_copy_val v68, v67 + v69 = get_elem_ptr v68, __ptr ptr, v57, !2517 + v70 = load v69, !2513 + v71 = asm(a: v70) -> u64 a, !2518 { + } + v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2519 + v73 = const u64 0 + v74 = get_elem_ptr v72, __ptr b256, v73, !2520 + mem_copy_val v74, v48 + v75 = const u64 1 + v76 = get_elem_ptr v72, __ptr u64, v75, !2521 + store v60 to v76, !2522 + v77 = const u64 2 + v78 = get_elem_ptr v72, __ptr u64, v77, !2523 + store v71 to v78, !2524 + v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v79, v72 + v80 = get_local __ptr slice, __ret_val16 + v81 = call encode_212(v79, v80) + v82 = get_local __ptr slice, params, !2525 + mem_copy_val v82, v80 + v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v84 = call new_21(v83) + v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v85, v83 + v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v87 = const u64 100, !1772 + v88 = call abi_encode_20(v87, v85, v86) + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2526 + mem_copy_val v89, v86 + v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2527 + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, __ret_val10 + v93 = call as_raw_slice_22(v91, v92) + v94 = get_local __ptr slice, __log_arg + mem_copy_val v94, v92 + v95 = const u64 1515152261580153489 + log __ptr slice v94, v95 + v96 = get_local __ptr slice, params, !2528 + v97 = get_local __ptr slice, self_2, !2529 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, self_2, !2530 + v99 = get_local __ptr slice, slice_1, !2531 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, slice_1, !2532 + v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { + } + v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v102, v101 + v103 = get_local __ptr { ptr, u64 }, __anon_03, !2529 + mem_copy_val v103, v102 + v104 = get_elem_ptr v103, __ptr ptr, v57, !2533 + v105 = load v104, !2529 + v106 = get_local __ptr b256, asset_id_, !2534 + v107 = get_local __ptr b256, __anon_10, !2488 + mem_copy_val v107, v106 + v108 = get_local __ptr b256, __anon_10, !2488 + v109 = const u64 0 + v110 = const u64 18446744073709551615 + v111 = contract_call __ptr () v105, v109, v108, v110, !2535 + v112 = asm() -> ptr ret, !2536 { + } + v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v114 = call new_21(v113) + v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v115, v113 + v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v117 = const u64 101, !1790 + v118 = call abi_encode_20(v117, v115, v116) + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2537 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2538 + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v121, v120 + v122 = get_local __ptr slice, __ret_val11 + v123 = call as_raw_slice_22(v121, v122) + v124 = get_local __ptr slice, __log_arg0 + mem_copy_val v124, v122 + v125 = const u64 1515152261580153489 + log __ptr slice v124, v125 + v126 = get_local __ptr { ptr }, __anon_000, !2539 + v127 = const u64 0 + v128 = get_elem_ptr v126, __ptr ptr, v127, !2540 + store v112 to v128, !2541 + v129 = get_local __ptr { ptr }, buffer, !2542 + mem_copy_val v129, v126 + v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v131 = call new_21(v130) + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v132, v130 + v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v134 = const u64 102, !1801 + v135 = call abi_encode_20(v134, v132, v133) + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2543 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2544 + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v138, v137 + v139 = get_local __ptr slice, __ret_val12 + v140 = call as_raw_slice_22(v138, v139) + v141 = get_local __ptr slice, __log_arg1 + mem_copy_val v141, v139 + v142 = const u64 1515152261580153489 + log __ptr slice v141, v142 + v143 = get_local __ptr { ptr }, buffer, !2545 + v144 = get_local __ptr slice, __ret_val + v145 = const u64 16 + v146 = call read_bytes_8(v143, v145, v144) + v147 = get_local __ptr slice, data, !2546 + mem_copy_val v147, v144 + v148 = get_local __ptr slice, data, !2547 + v149 = get_local __ptr slice, self_3, !2548 + mem_copy_val v149, v148 + v150 = get_local __ptr slice, self_3, !2549 + v151 = get_local __ptr slice, slice_2, !2550 + mem_copy_val v151, v150 + v152 = get_local __ptr slice, slice_2, !2551 + v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { + } + v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v154, v153 + v155 = get_local __ptr { ptr, u64 }, __anon_04, !2548 + mem_copy_val v155, v154 + v156 = get_elem_ptr v155, __ptr ptr, v57, !2552 + v157 = load v156, !2548 + v158 = asm(s: v157) -> __ptr string<16> s { + } + v159 = get_local __ptr string<16>, __aggr_memcpy_03 + mem_copy_val v159, v158 + v160 = get_local __ptr string<16>, r, !2553 + mem_copy_val v160, v159 + v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v162 = call new_21(v161) + v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v163, v161 + v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v165 = const u64 103, !1814 + v166 = call abi_encode_20(v165, v163, v164) + v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2554 + mem_copy_val v167, v164 + v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2555 + v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v169, v168 + v170 = get_local __ptr slice, __ret_val13 + v171 = call as_raw_slice_22(v169, v170) + v172 = get_local __ptr slice, __log_arg2 + mem_copy_val v172, v170 + v173 = const u64 1515152261580153489 + log __ptr slice v172, v173 + v174 = get_local __ptr string<16>, r, !2556 + v175 = get_local __ptr string<16>, _, !2557 + mem_copy_val v175, v174 + v176 = const unit () + ret () v176 + } + + entry fn cost_of_in_str_32() -> (), !2561 { + local string<32> _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local mut { ptr, u64 } __aggr_memcpy_02 + local mut string<32> __aggr_memcpy_03 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local { ptr, u64 } __anon_04 + local slice __anon_1 + local b256 __anon_10 + local string<32> __anon_2 + local { string<32> } __anon_3 + local string<32> __const = const string<32> "12345678901234567890123456789012" + local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local slice __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local string<32> __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { string<32> } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice data + local slice first_parameter + local { string<32> } item_ + local slice method_name_ + local slice params + local string<32> r + local slice second_parameter + local { string<32> } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice self_3 + local slice slice_ + local slice slice_0 + local slice slice_1 + local slice slice_2 + + entry(): + v0 = get_local __ptr string<32>, __const + v1 = get_local __ptr b256, __const0 + v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2562 + v3 = get_global __ptr string<9>, __const_global39 + v4 = cast_ptr v3 to ptr, !2563 + v5 = get_local __ptr { ptr, u64 }, __anon_0, !2563 + v6 = const u64 0 + v7 = get_elem_ptr v5, __ptr ptr, v6 + store v4 to v7, !2563 + v8 = const u64 1 + v9 = get_elem_ptr v5, __ptr u64, v8 + v10 = const u64 9 + store v10 to v9, !2563 + v11 = get_local __ptr slice, __anon_1, !2563 + mem_copy_bytes v11, v5, 16 + v12 = get_local __ptr string<32>, __anon_2 + mem_copy_val v12, v0 + v13 = get_local __ptr { string<32> }, __anon_3 + v14 = const u64 0 + v15 = get_elem_ptr v13, __ptr string<32>, v14 + mem_copy_val v15, v12 + v16 = get_local __ptr b256, contract_id_, !2564 + mem_copy_val v16, v2 + v17 = get_local __ptr slice, method_name_, !2564 + mem_copy_val v17, v11 + v18 = get_local __ptr { string<32> }, args_, !2564 + mem_copy_val v18, v13 + v19 = get_local __ptr b256, asset_id_, !2564 + mem_copy_val v19, v1 + v20 = get_local __ptr slice, method_name_, !2565 + v21 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v21, v20 + v22 = get_local __ptr slice, __ret_val15 + v23 = call encode_208(v21, v22) + v24 = get_local __ptr slice, first_parameter, !2566 + mem_copy_val v24, v22 + v25 = get_local __ptr { string<32> }, args_, !2567 + v26 = get_local __ptr { string<32> }, item_, !2568 + mem_copy_val v26, v25 + v27 = get_local __ptr { string<32> }, item_, !2569 + v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v29 = call new_21(v28) + v30 = get_local __ptr { string<32> }, self_, !2570 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2571 + mem_copy_val v31, v28 + v32 = get_local __ptr { string<32> }, self_, !2572 + v33 = const u64 0 + v34 = get_elem_ptr v32, __ptr string<32>, v33, !2573 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2574 + v36 = get_local __ptr string<32>, __tmp_arg8 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v37, v35 + v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v39 = call abi_encode_119(v36, v37, v38) + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2575 + mem_copy_val v40, v38 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2576 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2577 + mem_copy_val v42, v41 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2578 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v44, v43 + v45 = get_local __ptr slice, __ret_val9 + v46 = call as_raw_slice_22(v44, v45) + v47 = get_local __ptr slice, second_parameter, !2579 + mem_copy_val v47, v45 + v48 = get_local __ptr b256, contract_id_, !2580 + v49 = get_local __ptr slice, first_parameter, !2581 + v50 = get_local __ptr slice, self_0, !2582 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, self_0, !2583 + v52 = get_local __ptr slice, slice_, !2584 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, slice_, !2585 + v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { + } + v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v55, v54 + v56 = get_local __ptr { ptr, u64 }, __anon_01, !2582 + mem_copy_val v56, v55 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr ptr, v57, !2586 + v59 = load v58, !2582 + v60 = asm(a: v59) -> u64 a, !2587 { + } + v61 = get_local __ptr slice, second_parameter, !2588 + v62 = get_local __ptr slice, self_1, !2589 + mem_copy_val v62, v61 + v63 = get_local __ptr slice, self_1, !2590 + v64 = get_local __ptr slice, slice_0, !2591 + mem_copy_val v64, v63 + v65 = get_local __ptr slice, slice_0, !2592 + v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { + } + v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v67, v66 + v68 = get_local __ptr { ptr, u64 }, __anon_02, !2589 + mem_copy_val v68, v67 + v69 = get_elem_ptr v68, __ptr ptr, v57, !2593 + v70 = load v69, !2589 + v71 = asm(a: v70) -> u64 a, !2594 { + } + v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2595 + v73 = const u64 0 + v74 = get_elem_ptr v72, __ptr b256, v73, !2596 + mem_copy_val v74, v48 + v75 = const u64 1 + v76 = get_elem_ptr v72, __ptr u64, v75, !2597 + store v60 to v76, !2598 + v77 = const u64 2 + v78 = get_elem_ptr v72, __ptr u64, v77, !2599 + store v71 to v78, !2600 + v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v79, v72 + v80 = get_local __ptr slice, __ret_val16 + v81 = call encode_212(v79, v80) + v82 = get_local __ptr slice, params, !2601 + mem_copy_val v82, v80 + v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v84 = call new_21(v83) + v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v85, v83 + v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v87 = const u64 100, !1772 + v88 = call abi_encode_20(v87, v85, v86) + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2602 + mem_copy_val v89, v86 + v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2603 + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, __ret_val10 + v93 = call as_raw_slice_22(v91, v92) + v94 = get_local __ptr slice, __log_arg + mem_copy_val v94, v92 + v95 = const u64 1515152261580153489 + log __ptr slice v94, v95 + v96 = get_local __ptr slice, params, !2604 + v97 = get_local __ptr slice, self_2, !2605 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, self_2, !2606 + v99 = get_local __ptr slice, slice_1, !2607 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, slice_1, !2608 + v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { + } + v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v102, v101 + v103 = get_local __ptr { ptr, u64 }, __anon_03, !2605 + mem_copy_val v103, v102 + v104 = get_elem_ptr v103, __ptr ptr, v57, !2609 + v105 = load v104, !2605 + v106 = get_local __ptr b256, asset_id_, !2610 + v107 = get_local __ptr b256, __anon_10, !2564 + mem_copy_val v107, v106 + v108 = get_local __ptr b256, __anon_10, !2564 + v109 = const u64 0 + v110 = const u64 18446744073709551615 + v111 = contract_call __ptr () v105, v109, v108, v110, !2611 + v112 = asm() -> ptr ret, !2612 { + } + v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v114 = call new_21(v113) + v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v115, v113 + v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v117 = const u64 101, !1790 + v118 = call abi_encode_20(v117, v115, v116) + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2613 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2614 + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v121, v120 + v122 = get_local __ptr slice, __ret_val11 + v123 = call as_raw_slice_22(v121, v122) + v124 = get_local __ptr slice, __log_arg0 + mem_copy_val v124, v122 + v125 = const u64 1515152261580153489 + log __ptr slice v124, v125 + v126 = get_local __ptr { ptr }, __anon_000, !2615 + v127 = const u64 0 + v128 = get_elem_ptr v126, __ptr ptr, v127, !2616 + store v112 to v128, !2617 + v129 = get_local __ptr { ptr }, buffer, !2618 + mem_copy_val v129, v126 + v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v131 = call new_21(v130) + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v132, v130 + v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v134 = const u64 102, !1801 + v135 = call abi_encode_20(v134, v132, v133) + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2619 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2620 + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v138, v137 + v139 = get_local __ptr slice, __ret_val12 + v140 = call as_raw_slice_22(v138, v139) + v141 = get_local __ptr slice, __log_arg1 + mem_copy_val v141, v139 + v142 = const u64 1515152261580153489 + log __ptr slice v141, v142 + v143 = get_local __ptr { ptr }, buffer, !2621 + v144 = get_local __ptr slice, __ret_val + v145 = const u64 32 + v146 = call read_bytes_8(v143, v145, v144) + v147 = get_local __ptr slice, data, !2622 + mem_copy_val v147, v144 + v148 = get_local __ptr slice, data, !2623 + v149 = get_local __ptr slice, self_3, !2624 + mem_copy_val v149, v148 + v150 = get_local __ptr slice, self_3, !2625 + v151 = get_local __ptr slice, slice_2, !2626 + mem_copy_val v151, v150 + v152 = get_local __ptr slice, slice_2, !2627 + v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { + } + v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 + mem_copy_val v154, v153 + v155 = get_local __ptr { ptr, u64 }, __anon_04, !2624 + mem_copy_val v155, v154 + v156 = get_elem_ptr v155, __ptr ptr, v57, !2628 + v157 = load v156, !2624 + v158 = asm(s: v157) -> __ptr string<32> s { + } + v159 = get_local __ptr string<32>, __aggr_memcpy_03 + mem_copy_val v159, v158 + v160 = get_local __ptr string<32>, r, !2629 + mem_copy_val v160, v159 + v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v162 = call new_21(v161) + v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v163, v161 + v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v165 = const u64 103, !1814 + v166 = call abi_encode_20(v165, v163, v164) + v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2630 + mem_copy_val v167, v164 + v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2631 + v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v169, v168 + v170 = get_local __ptr slice, __ret_val13 + v171 = call as_raw_slice_22(v169, v170) + v172 = get_local __ptr slice, __log_arg2 + mem_copy_val v172, v170 + v173 = const u64 1515152261580153489 + log __ptr slice v172, v173 + v174 = get_local __ptr string<32>, r, !2632 + v175 = get_local __ptr string<32>, _, !2633 + mem_copy_val v175, v174 + v176 = const unit () + ret () v176 + } + + entry fn cost_of_in_array_0() -> (), !2637 { + local [u64; 0] _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local [u64; 0] __anon_2 + local { [u64; 0] } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local [u64; 0] __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local { { ptr, u64, u64 } } __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local [u64; 0] __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { [u64; 0] } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { [u64; 0] } item_ + local slice method_name_ + local slice params + local [u64; 0] r + local slice second_parameter + local { [u64; 0] } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2638 + v2 = get_global __ptr string<10>, __const_global40 + v3 = cast_ptr v2 to ptr, !2639 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !2639 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !2639 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !2639 + v10 = get_local __ptr slice, __anon_1, !2639 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr [u64; 0], __anon_2, !2640 + v12 = get_local __ptr { [u64; 0] }, __anon_3 + v13 = const u64 0 + v14 = get_elem_ptr v12, __ptr [u64; 0], v13 + mem_copy_val v14, v11 + v15 = get_local __ptr b256, contract_id_, !2641 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !2641 + mem_copy_val v16, v10 + v17 = get_local __ptr { [u64; 0] }, args_, !2641 + mem_copy_val v17, v12 + v18 = get_local __ptr b256, asset_id_, !2641 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !2642 + v20 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val15 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !2643 + mem_copy_val v23, v21 + v24 = get_local __ptr { [u64; 0] }, args_, !2644 + v25 = get_local __ptr { [u64; 0] }, item_, !2645 + mem_copy_val v25, v24 + v26 = get_local __ptr { [u64; 0] }, item_, !2646 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v28 = call new_21(v27) + v29 = get_local __ptr { [u64; 0] }, self_, !2647 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2648 + mem_copy_val v30, v27 + v31 = get_local __ptr { [u64; 0] }, self_, !2649 + v32 = const u64 0 + v33 = get_elem_ptr v31, __ptr [u64; 0], v32, !2650 + v34 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2651 + v35 = get_local __ptr [u64; 0], __tmp_arg8 + mem_copy_val v35, v33 + v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v36, v34 + v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v38 = call abi_encode_29(v35, v36, v37) + v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2652 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2653 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2654 + mem_copy_val v41, v40 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2655 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v43, v42 + v44 = get_local __ptr slice, __ret_val9 + v45 = call as_raw_slice_22(v43, v44) + v46 = get_local __ptr slice, second_parameter, !2656 + mem_copy_val v46, v44 + v47 = get_local __ptr b256, contract_id_, !2657 + v48 = get_local __ptr slice, first_parameter, !2658 + v49 = get_local __ptr slice, self_0, !2659 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !2660 + v51 = get_local __ptr slice, slice_, !2661 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_, !2662 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_01, !2659 + mem_copy_val v55, v54 + v56 = const u64 0 + v57 = get_elem_ptr v55, __ptr ptr, v56, !2663 + v58 = load v57, !2659 + v59 = asm(a: v58) -> u64 a, !2664 { + } + v60 = get_local __ptr slice, second_parameter, !2665 + v61 = get_local __ptr slice, self_1, !2666 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_1, !2667 + v63 = get_local __ptr slice, slice_0, !2668 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_0, !2669 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_02, !2666 + mem_copy_val v67, v66 + v68 = get_elem_ptr v67, __ptr ptr, v56, !2670 + v69 = load v68, !2666 + v70 = asm(a: v69) -> u64 a, !2671 { + } + v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2672 + v72 = const u64 0 + v73 = get_elem_ptr v71, __ptr b256, v72, !2673 + mem_copy_val v73, v47 + v74 = const u64 1 + v75 = get_elem_ptr v71, __ptr u64, v74, !2674 + store v59 to v75, !2675 + v76 = const u64 2 + v77 = get_elem_ptr v71, __ptr u64, v76, !2676 + store v70 to v77, !2677 + v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v78, v71 + v79 = get_local __ptr slice, __ret_val16 + v80 = call encode_212(v78, v79) + v81 = get_local __ptr slice, params, !2678 + mem_copy_val v81, v79 + v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v83 = call new_21(v82) + v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v86 = const u64 100, !1772 + v87 = call abi_encode_20(v86, v84, v85) + v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2679 + mem_copy_val v88, v85 + v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2680 + v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v90, v89 + v91 = get_local __ptr slice, __ret_val10 + v92 = call as_raw_slice_22(v90, v91) + v93 = get_local __ptr slice, __log_arg + mem_copy_val v93, v91 + v94 = const u64 1515152261580153489 + log __ptr slice v93, v94 + v95 = get_local __ptr slice, params, !2681 + v96 = get_local __ptr slice, self_2, !2682 + mem_copy_val v96, v95 + v97 = get_local __ptr slice, self_2, !2683 + v98 = get_local __ptr slice, slice_1, !2684 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, slice_1, !2685 + v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { + } + v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v101, v100 + v102 = get_local __ptr { ptr, u64 }, __anon_03, !2682 + mem_copy_val v102, v101 + v103 = get_elem_ptr v102, __ptr ptr, v56, !2686 + v104 = load v103, !2682 + v105 = get_local __ptr b256, asset_id_, !2687 + v106 = get_local __ptr b256, __anon_10, !2641 + mem_copy_val v106, v105 + v107 = get_local __ptr b256, __anon_10, !2641 + v108 = const u64 0 + v109 = const u64 18446744073709551615 + v110 = contract_call __ptr () v104, v108, v107, v109, !2688 + v111 = asm() -> ptr ret, !2689 { + } + v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v113 = call new_21(v112) + v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v114, v112 + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v116 = const u64 101, !1790 + v117 = call abi_encode_20(v116, v114, v115) + v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2690 + mem_copy_val v118, v115 + v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2691 + v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v120, v119 + v121 = get_local __ptr slice, __ret_val11 + v122 = call as_raw_slice_22(v120, v121) + v123 = get_local __ptr slice, __log_arg0 + mem_copy_val v123, v121 + v124 = const u64 1515152261580153489 + log __ptr slice v123, v124 + v125 = get_local __ptr { ptr }, __anon_000, !2692 + v126 = const u64 0 + v127 = get_elem_ptr v125, __ptr ptr, v126, !2693 + store v111 to v127, !2694 + v128 = get_local __ptr { ptr }, buffer, !2695 + mem_copy_val v128, v125 + v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v130 = call new_21(v129) + v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v131, v129 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v133 = const u64 102, !1801 + v134 = call abi_encode_20(v133, v131, v132) + v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2696 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2697 + v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v137, v136 + v138 = get_local __ptr slice, __ret_val12 + v139 = call as_raw_slice_22(v137, v138) + v140 = get_local __ptr slice, __log_arg1 + mem_copy_val v140, v138 + v141 = const u64 1515152261580153489 + log __ptr slice v140, v141 + v142 = get_local __ptr { ptr }, buffer, !2698 + v143 = get_local __ptr [u64; 0], __ret_val + v144 = call abi_decode_18(v142, v143) + v145 = get_local __ptr [u64; 0], r, !2699 + mem_copy_val v145, v143 + v146 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 + v147 = call new_21(v146) + v148 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v148, v146 + v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v150 = const u64 103, !1814 + v151 = call abi_encode_20(v150, v148, v149) + v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2700 + mem_copy_val v152, v149 + v153 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2701 + v154 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v154, v153 + v155 = get_local __ptr slice, __ret_val13 + v156 = call as_raw_slice_22(v154, v155) + v157 = get_local __ptr slice, __log_arg2 + mem_copy_val v157, v155 + v158 = const u64 1515152261580153489 + log __ptr slice v157, v158 + v159 = get_local __ptr [u64; 0], r, !2702 + v160 = get_local __ptr [u64; 0], _, !2703 + mem_copy_val v160, v159 + v161 = const unit () + ret () v161 + } + + entry fn cost_of_in_array_1() -> (), !2707 { + local [u64; 1] _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local [u64; 1] __anon_2 + local { [u64; 1] } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local [u64; 1] __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local [u64; 1] __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { [u64; 1] } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { [u64; 1] } item_ + local slice method_name_ + local slice params + local [u64; 1] r + local slice second_parameter + local { [u64; 1] } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2708 + v2 = get_global __ptr string<10>, __const_global41 + v3 = cast_ptr v2 to ptr, !2709 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !2709 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !2709 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !2709 + v10 = get_local __ptr slice, __anon_1, !2709 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr [u64; 1], __anon_2, !2710 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !2711 + store v14 to v13, !2710 + v15 = get_local __ptr { [u64; 1] }, __anon_3 + v16 = const u64 0 + v17 = get_elem_ptr v15, __ptr [u64; 1], v16 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, contract_id_, !2712 + mem_copy_val v18, v1 + v19 = get_local __ptr slice, method_name_, !2712 + mem_copy_val v19, v10 + v20 = get_local __ptr { [u64; 1] }, args_, !2712 + mem_copy_val v20, v15 + v21 = get_local __ptr b256, asset_id_, !2712 + mem_copy_val v21, v0 + v22 = get_local __ptr slice, method_name_, !2713 + v23 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v23, v22 + v24 = get_local __ptr slice, __ret_val15 + v25 = call encode_208(v23, v24) + v26 = get_local __ptr slice, first_parameter, !2714 + mem_copy_val v26, v24 + v27 = get_local __ptr { [u64; 1] }, args_, !2715 + v28 = get_local __ptr { [u64; 1] }, item_, !2716 + mem_copy_val v28, v27 + v29 = get_local __ptr { [u64; 1] }, item_, !2717 + v30 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v31 = call new_21(v30) + v32 = get_local __ptr { [u64; 1] }, self_, !2718 + mem_copy_val v32, v29 + v33 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2719 + mem_copy_val v33, v30 + v34 = get_local __ptr { [u64; 1] }, self_, !2720 + v35 = const u64 0 + v36 = get_elem_ptr v34, __ptr [u64; 1], v35, !2721 + v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2722 + v38 = get_local __ptr [u64; 1], __tmp_arg8 + mem_copy_val v38, v36 + v39 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v39, v37 + v40 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v41 = call abi_encode_37(v38, v39, v40) + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2723 + mem_copy_val v42, v40 + v43 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2724 + v44 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2725 + mem_copy_val v44, v43 + v45 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2726 + v46 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v46, v45 + v47 = get_local __ptr slice, __ret_val8 + v48 = call as_raw_slice_22(v46, v47) + v49 = get_local __ptr slice, second_parameter, !2727 + mem_copy_val v49, v47 + v50 = get_local __ptr b256, contract_id_, !2728 + v51 = get_local __ptr slice, first_parameter, !2729 + v52 = get_local __ptr slice, self_0, !2730 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, self_0, !2731 + v54 = get_local __ptr slice, slice_, !2732 + mem_copy_val v54, v53 + v55 = get_local __ptr slice, slice_, !2733 + v56 = asm(ptr: v55) -> __ptr { ptr, u64 } ptr { + } + v57 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v57, v56 + v58 = get_local __ptr { ptr, u64 }, __anon_01, !2730 + mem_copy_val v58, v57 + v59 = const u64 0 + v60 = get_elem_ptr v58, __ptr ptr, v59, !2734 + v61 = load v60, !2730 + v62 = asm(a: v61) -> u64 a, !2735 { + } + v63 = get_local __ptr slice, second_parameter, !2736 + v64 = get_local __ptr slice, self_1, !2737 + mem_copy_val v64, v63 + v65 = get_local __ptr slice, self_1, !2738 + v66 = get_local __ptr slice, slice_0, !2739 + mem_copy_val v66, v65 + v67 = get_local __ptr slice, slice_0, !2740 + v68 = asm(ptr: v67) -> __ptr { ptr, u64 } ptr { + } + v69 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v69, v68 + v70 = get_local __ptr { ptr, u64 }, __anon_02, !2737 + mem_copy_val v70, v69 + v71 = get_elem_ptr v70, __ptr ptr, v59, !2741 + v72 = load v71, !2737 + v73 = asm(a: v72) -> u64 a, !2742 { + } + v74 = get_local __ptr { b256, u64, u64 }, __anon_00, !2743 + v75 = const u64 0 + v76 = get_elem_ptr v74, __ptr b256, v75, !2744 + mem_copy_val v76, v50 + v77 = const u64 1 + v78 = get_elem_ptr v74, __ptr u64, v77, !2745 + store v62 to v78, !2746 + v79 = const u64 2 + v80 = get_elem_ptr v74, __ptr u64, v79, !2747 + store v73 to v80, !2748 + v81 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v81, v74 + v82 = get_local __ptr slice, __ret_val16 + v83 = call encode_212(v81, v82) + v84 = get_local __ptr slice, params, !2749 + mem_copy_val v84, v82 + v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v86 = call new_21(v85) + v87 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v87, v85 + v88 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v89 = const u64 100, !1772 + v90 = call abi_encode_20(v89, v87, v88) + v91 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2750 + mem_copy_val v91, v88 + v92 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2751 + v93 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v93, v92 + v94 = get_local __ptr slice, __ret_val9 + v95 = call as_raw_slice_22(v93, v94) + v96 = get_local __ptr slice, __log_arg + mem_copy_val v96, v94 + v97 = const u64 1515152261580153489 + log __ptr slice v96, v97 + v98 = get_local __ptr slice, params, !2752 + v99 = get_local __ptr slice, self_2, !2753 + mem_copy_val v99, v98 + v100 = get_local __ptr slice, self_2, !2754 + v101 = get_local __ptr slice, slice_1, !2755 + mem_copy_val v101, v100 + v102 = get_local __ptr slice, slice_1, !2756 + v103 = asm(ptr: v102) -> __ptr { ptr, u64 } ptr { + } + v104 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v104, v103 + v105 = get_local __ptr { ptr, u64 }, __anon_03, !2753 + mem_copy_val v105, v104 + v106 = get_elem_ptr v105, __ptr ptr, v59, !2757 + v107 = load v106, !2753 + v108 = get_local __ptr b256, asset_id_, !2758 + v109 = get_local __ptr b256, __anon_10, !2712 + mem_copy_val v109, v108 + v110 = get_local __ptr b256, __anon_10, !2712 + v111 = const u64 0 + v112 = const u64 18446744073709551615 + v113 = contract_call __ptr () v107, v111, v110, v112, !2759 + v114 = asm() -> ptr ret, !2760 { + } + v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v116 = call new_21(v115) + v117 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v117, v115 + v118 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v119 = const u64 101, !1790 + v120 = call abi_encode_20(v119, v117, v118) + v121 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2761 + mem_copy_val v121, v118 + v122 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2762 + v123 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v123, v122 + v124 = get_local __ptr slice, __ret_val10 + v125 = call as_raw_slice_22(v123, v124) + v126 = get_local __ptr slice, __log_arg0 + mem_copy_val v126, v124 + v127 = const u64 1515152261580153489 + log __ptr slice v126, v127 + v128 = get_local __ptr { ptr }, __anon_000, !2763 + v129 = const u64 0 + v130 = get_elem_ptr v128, __ptr ptr, v129, !2764 + store v114 to v130, !2765 + v131 = get_local __ptr { ptr }, buffer, !2766 + mem_copy_val v131, v128 + v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v133 = call new_21(v132) + v134 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v134, v132 + v135 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v136 = const u64 102, !1801 + v137 = call abi_encode_20(v136, v134, v135) + v138 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2767 + mem_copy_val v138, v135 + v139 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2768 + v140 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v140, v139 + v141 = get_local __ptr slice, __ret_val11 + v142 = call as_raw_slice_22(v140, v141) + v143 = get_local __ptr slice, __log_arg1 + mem_copy_val v143, v141 + v144 = const u64 1515152261580153489 + log __ptr slice v143, v144 + v145 = get_local __ptr { ptr }, buffer, !2769 + v146 = get_local __ptr [u64; 1], __ret_val13 + v147 = call abi_decode_34(v145, v146) + v148 = get_local __ptr [u64; 1], r, !2770 + mem_copy_val v148, v146 + v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v150 = call new_21(v149) + v151 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v151, v149 + v152 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v153 = const u64 103, !1814 + v154 = call abi_encode_20(v153, v151, v152) + v155 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2771 + mem_copy_val v155, v152 + v156 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2772 + v157 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v157, v156 + v158 = get_local __ptr slice, __ret_val12 + v159 = call as_raw_slice_22(v157, v158) + v160 = get_local __ptr slice, __log_arg2 + mem_copy_val v160, v158 + v161 = const u64 1515152261580153489 + log __ptr slice v160, v161 + v162 = get_local __ptr [u64; 1], r, !2773 + v163 = get_local __ptr [u64; 1], _, !2774 + mem_copy_val v163, v162 + v164 = const unit () + ret () v164 + } + + entry fn cost_of_in_array_8() -> (), !2778 { + local [u64; 8] _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local [u64; 8] __anon_2 + local { [u64; 8] } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local [u64; 8] __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local [u64; 8] __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { [u64; 8] } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { [u64; 8] } item_ + local slice method_name_ + local slice params + local [u64; 8] r + local slice second_parameter + local { [u64; 8] } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2779 + v1 = get_global __ptr string<10>, __const_global42 + v2 = cast_ptr v1 to ptr, !2780 + v3 = get_local __ptr { ptr, u64 }, __anon_0, !2780 + v4 = const u64 0 + v5 = get_elem_ptr v3, __ptr ptr, v4 + store v2 to v5, !2780 + v6 = const u64 1 + v7 = get_elem_ptr v3, __ptr u64, v6 + v8 = const u64 10 + store v8 to v7, !2780 + v9 = get_local __ptr slice, __anon_1, !2780 + mem_copy_bytes v9, v3, 16 + v10 = get_local __ptr [u64; 8], __anon_2, !2781 + v11 = const u64 0 + br array_init_loop(v11) + + array_init_loop(v12: u64): + v13 = get_elem_ptr v10, __ptr u64, v12 + v14 = const u64 0, !2782 + store v14 to v13, !2781 + v15 = const u64 1 + v16 = add v12, v15 + v17 = const u64 8 + v18 = cmp lt v16 v17 + cbr v18, array_init_loop(v16), array_init_exit() + + array_init_exit(): + v19 = get_local __ptr b256, __const + v20 = get_local __ptr { [u64; 8] }, __anon_3 + v21 = const u64 0 + v22 = get_elem_ptr v20, __ptr [u64; 8], v21 + mem_copy_val v22, v10 + v23 = get_local __ptr b256, contract_id_, !2783 + mem_copy_val v23, v0 + v24 = get_local __ptr slice, method_name_, !2783 + mem_copy_val v24, v9 + v25 = get_local __ptr { [u64; 8] }, args_, !2783 + mem_copy_val v25, v20 + v26 = get_local __ptr b256, asset_id_, !2783 + mem_copy_val v26, v19 + v27 = get_local __ptr slice, method_name_, !2784 + v28 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v28, v27 + v29 = get_local __ptr slice, __ret_val15 + v30 = call encode_208(v28, v29) + v31 = get_local __ptr slice, first_parameter, !2785 + mem_copy_val v31, v29 + v32 = get_local __ptr { [u64; 8] }, args_, !2786 + v33 = get_local __ptr { [u64; 8] }, item_, !2787 + mem_copy_val v33, v32 + v34 = get_local __ptr { [u64; 8] }, item_, !2788 + v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v36 = call new_21(v35) + v37 = get_local __ptr { [u64; 8] }, self_, !2789 + mem_copy_val v37, v34 + v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2790 + mem_copy_val v38, v35 + v39 = get_local __ptr { [u64; 8] }, self_, !2791 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr [u64; 8], v40, !2792 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2793 + v43 = get_local __ptr [u64; 8], __tmp_arg8 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v44, v42 + v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v46 = call abi_encode_61(v43, v44, v45) + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2794 + mem_copy_val v47, v45 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2795 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2796 + mem_copy_val v49, v48 + v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2797 + v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, __ret_val8 + v53 = call as_raw_slice_22(v51, v52) + v54 = get_local __ptr slice, second_parameter, !2798 + mem_copy_val v54, v52 + v55 = get_local __ptr b256, contract_id_, !2799 + v56 = get_local __ptr slice, first_parameter, !2800 + v57 = get_local __ptr slice, self_0, !2801 + mem_copy_val v57, v56 + v58 = get_local __ptr slice, self_0, !2802 + v59 = get_local __ptr slice, slice_, !2803 + mem_copy_val v59, v58 + v60 = get_local __ptr slice, slice_, !2804 + v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { + } + v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v62, v61 + v63 = get_local __ptr { ptr, u64 }, __anon_01, !2801 + mem_copy_val v63, v62 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr ptr, v64, !2805 + v66 = load v65, !2801 + v67 = asm(a: v66) -> u64 a, !2806 { + } + v68 = get_local __ptr slice, second_parameter, !2807 + v69 = get_local __ptr slice, self_1, !2808 + mem_copy_val v69, v68 + v70 = get_local __ptr slice, self_1, !2809 + v71 = get_local __ptr slice, slice_0, !2810 + mem_copy_val v71, v70 + v72 = get_local __ptr slice, slice_0, !2811 + v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { + } + v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v74, v73 + v75 = get_local __ptr { ptr, u64 }, __anon_02, !2808 + mem_copy_val v75, v74 + v76 = get_elem_ptr v75, __ptr ptr, v64, !2812 + v77 = load v76, !2808 + v78 = asm(a: v77) -> u64 a, !2813 { + } + v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !2814 + v80 = const u64 0 + v81 = get_elem_ptr v79, __ptr b256, v80, !2815 + mem_copy_val v81, v55 + v82 = const u64 1 + v83 = get_elem_ptr v79, __ptr u64, v82, !2816 + store v67 to v83, !2817 + v84 = const u64 2 + v85 = get_elem_ptr v79, __ptr u64, v84, !2818 + store v78 to v85, !2819 + v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v86, v79 + v87 = get_local __ptr slice, __ret_val16 + v88 = call encode_212(v86, v87) + v89 = get_local __ptr slice, params, !2820 + mem_copy_val v89, v87 + v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v91 = call new_21(v90) + v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v92, v90 + v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v94 = const u64 100, !1772 + v95 = call abi_encode_20(v94, v92, v93) + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2821 + mem_copy_val v96, v93 + v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2822 + v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, __ret_val9 + v100 = call as_raw_slice_22(v98, v99) + v101 = get_local __ptr slice, __log_arg + mem_copy_val v101, v99 + v102 = const u64 1515152261580153489 + log __ptr slice v101, v102 + v103 = get_local __ptr slice, params, !2823 + v104 = get_local __ptr slice, self_2, !2824 + mem_copy_val v104, v103 + v105 = get_local __ptr slice, self_2, !2825 + v106 = get_local __ptr slice, slice_1, !2826 + mem_copy_val v106, v105 + v107 = get_local __ptr slice, slice_1, !2827 + v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { + } + v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v109, v108 + v110 = get_local __ptr { ptr, u64 }, __anon_03, !2824 + mem_copy_val v110, v109 + v111 = get_elem_ptr v110, __ptr ptr, v64, !2828 + v112 = load v111, !2824 + v113 = get_local __ptr b256, asset_id_, !2829 + v114 = get_local __ptr b256, __anon_10, !2783 + mem_copy_val v114, v113 + v115 = get_local __ptr b256, __anon_10, !2783 + v116 = const u64 0 + v117 = const u64 18446744073709551615 + v118 = contract_call __ptr () v112, v116, v115, v117, !2830 + v119 = asm() -> ptr ret, !2831 { + } + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v121 = call new_21(v120) + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v122, v120 + v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v124 = const u64 101, !1790 + v125 = call abi_encode_20(v124, v122, v123) + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2832 + mem_copy_val v126, v123 + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2833 + v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v128, v127 + v129 = get_local __ptr slice, __ret_val10 + v130 = call as_raw_slice_22(v128, v129) + v131 = get_local __ptr slice, __log_arg0 + mem_copy_val v131, v129 + v132 = const u64 1515152261580153489 + log __ptr slice v131, v132 + v133 = get_local __ptr { ptr }, __anon_000, !2834 + v134 = const u64 0 + v135 = get_elem_ptr v133, __ptr ptr, v134, !2835 + store v119 to v135, !2836 + v136 = get_local __ptr { ptr }, buffer, !2837 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v141 = const u64 102, !1801 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2838 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2839 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val11 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg1 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = get_local __ptr { ptr }, buffer, !2840 + v151 = get_local __ptr [u64; 8], __ret_val13 + v152 = call abi_decode_58(v150, v151) + v153 = get_local __ptr [u64; 8], r, !2841 + mem_copy_val v153, v151 + v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v155 = call new_21(v154) + v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v156, v154 + v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v158 = const u64 103, !1814 + v159 = call abi_encode_20(v158, v156, v157) + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2842 + mem_copy_val v160, v157 + v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2843 + v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v162, v161 + v163 = get_local __ptr slice, __ret_val12 + v164 = call as_raw_slice_22(v162, v163) + v165 = get_local __ptr slice, __log_arg2 + mem_copy_val v165, v163 + v166 = const u64 1515152261580153489 + log __ptr slice v165, v166 + v167 = get_local __ptr [u64; 8], r, !2844 + v168 = get_local __ptr [u64; 8], _, !2845 + mem_copy_val v168, v167 + v169 = const unit () + ret () v169 + } + + entry fn cost_of_in_array_16() -> (), !2849 { + local [u64; 16] _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local [u64; 16] __anon_2 + local { [u64; 16] } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local [u64; 16] __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local [u64; 16] __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { [u64; 16] } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { [u64; 16] } item_ + local slice method_name_ + local slice params + local [u64; 16] r + local slice second_parameter + local { [u64; 16] } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2850 + v1 = get_global __ptr string<11>, __const_global43 + v2 = cast_ptr v1 to ptr, !2851 + v3 = get_local __ptr { ptr, u64 }, __anon_0, !2851 + v4 = const u64 0 + v5 = get_elem_ptr v3, __ptr ptr, v4 + store v2 to v5, !2851 + v6 = const u64 1 + v7 = get_elem_ptr v3, __ptr u64, v6 + v8 = const u64 11 + store v8 to v7, !2851 + v9 = get_local __ptr slice, __anon_1, !2851 + mem_copy_bytes v9, v3, 16 + v10 = get_local __ptr [u64; 16], __anon_2, !2852 + v11 = const u64 0 + br array_init_loop(v11) + + array_init_loop(v12: u64): + v13 = get_elem_ptr v10, __ptr u64, v12 + v14 = const u64 0, !2853 + store v14 to v13, !2852 + v15 = const u64 1 + v16 = add v12, v15 + v17 = const u64 16 + v18 = cmp lt v16 v17 + cbr v18, array_init_loop(v16), array_init_exit() + + array_init_exit(): + v19 = get_local __ptr b256, __const + v20 = get_local __ptr { [u64; 16] }, __anon_3 + v21 = const u64 0 + v22 = get_elem_ptr v20, __ptr [u64; 16], v21 + mem_copy_val v22, v10 + v23 = get_local __ptr b256, contract_id_, !2854 + mem_copy_val v23, v0 + v24 = get_local __ptr slice, method_name_, !2854 + mem_copy_val v24, v9 + v25 = get_local __ptr { [u64; 16] }, args_, !2854 + mem_copy_val v25, v20 + v26 = get_local __ptr b256, asset_id_, !2854 + mem_copy_val v26, v19 + v27 = get_local __ptr slice, method_name_, !2855 + v28 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v28, v27 + v29 = get_local __ptr slice, __ret_val15 + v30 = call encode_208(v28, v29) + v31 = get_local __ptr slice, first_parameter, !2856 + mem_copy_val v31, v29 + v32 = get_local __ptr { [u64; 16] }, args_, !2857 + v33 = get_local __ptr { [u64; 16] }, item_, !2858 + mem_copy_val v33, v32 + v34 = get_local __ptr { [u64; 16] }, item_, !2859 + v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v36 = call new_21(v35) + v37 = get_local __ptr { [u64; 16] }, self_, !2860 + mem_copy_val v37, v34 + v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2861 + mem_copy_val v38, v35 + v39 = get_local __ptr { [u64; 16] }, self_, !2862 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr [u64; 16], v40, !2863 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2864 + v43 = get_local __ptr [u64; 16], __tmp_arg8 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v44, v42 + v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v46 = call abi_encode_43(v43, v44, v45) + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2865 + mem_copy_val v47, v45 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2866 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2867 + mem_copy_val v49, v48 + v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2868 + v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, __ret_val8 + v53 = call as_raw_slice_22(v51, v52) + v54 = get_local __ptr slice, second_parameter, !2869 + mem_copy_val v54, v52 + v55 = get_local __ptr b256, contract_id_, !2870 + v56 = get_local __ptr slice, first_parameter, !2871 + v57 = get_local __ptr slice, self_0, !2872 + mem_copy_val v57, v56 + v58 = get_local __ptr slice, self_0, !2873 + v59 = get_local __ptr slice, slice_, !2874 + mem_copy_val v59, v58 + v60 = get_local __ptr slice, slice_, !2875 + v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { + } + v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v62, v61 + v63 = get_local __ptr { ptr, u64 }, __anon_01, !2872 + mem_copy_val v63, v62 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr ptr, v64, !2876 + v66 = load v65, !2872 + v67 = asm(a: v66) -> u64 a, !2877 { + } + v68 = get_local __ptr slice, second_parameter, !2878 + v69 = get_local __ptr slice, self_1, !2879 + mem_copy_val v69, v68 + v70 = get_local __ptr slice, self_1, !2880 + v71 = get_local __ptr slice, slice_0, !2881 + mem_copy_val v71, v70 + v72 = get_local __ptr slice, slice_0, !2882 + v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { + } + v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v74, v73 + v75 = get_local __ptr { ptr, u64 }, __anon_02, !2879 + mem_copy_val v75, v74 + v76 = get_elem_ptr v75, __ptr ptr, v64, !2883 + v77 = load v76, !2879 + v78 = asm(a: v77) -> u64 a, !2884 { + } + v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !2885 + v80 = const u64 0 + v81 = get_elem_ptr v79, __ptr b256, v80, !2886 + mem_copy_val v81, v55 + v82 = const u64 1 + v83 = get_elem_ptr v79, __ptr u64, v82, !2887 + store v67 to v83, !2888 + v84 = const u64 2 + v85 = get_elem_ptr v79, __ptr u64, v84, !2889 + store v78 to v85, !2890 + v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v86, v79 + v87 = get_local __ptr slice, __ret_val16 + v88 = call encode_212(v86, v87) + v89 = get_local __ptr slice, params, !2891 + mem_copy_val v89, v87 + v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v91 = call new_21(v90) + v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v92, v90 + v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v94 = const u64 100, !1772 + v95 = call abi_encode_20(v94, v92, v93) + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2892 + mem_copy_val v96, v93 + v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2893 + v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, __ret_val9 + v100 = call as_raw_slice_22(v98, v99) + v101 = get_local __ptr slice, __log_arg + mem_copy_val v101, v99 + v102 = const u64 1515152261580153489 + log __ptr slice v101, v102 + v103 = get_local __ptr slice, params, !2894 + v104 = get_local __ptr slice, self_2, !2895 + mem_copy_val v104, v103 + v105 = get_local __ptr slice, self_2, !2896 + v106 = get_local __ptr slice, slice_1, !2897 + mem_copy_val v106, v105 + v107 = get_local __ptr slice, slice_1, !2898 + v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { + } + v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v109, v108 + v110 = get_local __ptr { ptr, u64 }, __anon_03, !2895 + mem_copy_val v110, v109 + v111 = get_elem_ptr v110, __ptr ptr, v64, !2899 + v112 = load v111, !2895 + v113 = get_local __ptr b256, asset_id_, !2900 + v114 = get_local __ptr b256, __anon_10, !2854 + mem_copy_val v114, v113 + v115 = get_local __ptr b256, __anon_10, !2854 + v116 = const u64 0 + v117 = const u64 18446744073709551615 + v118 = contract_call __ptr () v112, v116, v115, v117, !2901 + v119 = asm() -> ptr ret, !2902 { + } + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v121 = call new_21(v120) + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v122, v120 + v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v124 = const u64 101, !1790 + v125 = call abi_encode_20(v124, v122, v123) + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2903 + mem_copy_val v126, v123 + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2904 + v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v128, v127 + v129 = get_local __ptr slice, __ret_val10 + v130 = call as_raw_slice_22(v128, v129) + v131 = get_local __ptr slice, __log_arg0 + mem_copy_val v131, v129 + v132 = const u64 1515152261580153489 + log __ptr slice v131, v132 + v133 = get_local __ptr { ptr }, __anon_000, !2905 + v134 = const u64 0 + v135 = get_elem_ptr v133, __ptr ptr, v134, !2906 + store v119 to v135, !2907 + v136 = get_local __ptr { ptr }, buffer, !2908 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v141 = const u64 102, !1801 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2909 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2910 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val11 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg1 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = get_local __ptr { ptr }, buffer, !2911 + v151 = get_local __ptr [u64; 16], __ret_val13 + v152 = call abi_decode_40(v150, v151) + v153 = get_local __ptr [u64; 16], r, !2912 + mem_copy_val v153, v151 + v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v155 = call new_21(v154) + v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v156, v154 + v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v158 = const u64 103, !1814 + v159 = call abi_encode_20(v158, v156, v157) + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2913 + mem_copy_val v160, v157 + v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2914 + v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v162, v161 + v163 = get_local __ptr slice, __ret_val12 + v164 = call as_raw_slice_22(v162, v163) + v165 = get_local __ptr slice, __log_arg2 + mem_copy_val v165, v163 + v166 = const u64 1515152261580153489 + log __ptr slice v165, v166 + v167 = get_local __ptr [u64; 16], r, !2915 + v168 = get_local __ptr [u64; 16], _, !2916 + mem_copy_val v168, v167 + v169 = const unit () + ret () v169 + } + + entry fn cost_of_in_array_32() -> (), !2920 { + local [u64; 32] _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local [u64; 32] __anon_2 + local { [u64; 32] } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local [u64; 32] __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local [u64; 32] __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { [u64; 32] } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { [u64; 32] } item_ + local slice method_name_ + local slice params + local [u64; 32] r + local slice second_parameter + local { [u64; 32] } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2921 + v1 = get_global __ptr string<11>, __const_global44 + v2 = cast_ptr v1 to ptr, !2922 + v3 = get_local __ptr { ptr, u64 }, __anon_0, !2922 + v4 = const u64 0 + v5 = get_elem_ptr v3, __ptr ptr, v4 + store v2 to v5, !2922 + v6 = const u64 1 + v7 = get_elem_ptr v3, __ptr u64, v6 + v8 = const u64 11 + store v8 to v7, !2922 + v9 = get_local __ptr slice, __anon_1, !2922 + mem_copy_bytes v9, v3, 16 + v10 = get_local __ptr [u64; 32], __anon_2, !2923 + v11 = const u64 0 + br array_init_loop(v11) + + array_init_loop(v12: u64): + v13 = get_elem_ptr v10, __ptr u64, v12 + v14 = const u64 0, !2924 + store v14 to v13, !2923 + v15 = const u64 1 + v16 = add v12, v15 + v17 = const u64 32 + v18 = cmp lt v16 v17 + cbr v18, array_init_loop(v16), array_init_exit() + + array_init_exit(): + v19 = get_local __ptr b256, __const + v20 = get_local __ptr { [u64; 32] }, __anon_3 + v21 = const u64 0 + v22 = get_elem_ptr v20, __ptr [u64; 32], v21 + mem_copy_val v22, v10 + v23 = get_local __ptr b256, contract_id_, !2925 + mem_copy_val v23, v0 + v24 = get_local __ptr slice, method_name_, !2925 + mem_copy_val v24, v9 + v25 = get_local __ptr { [u64; 32] }, args_, !2925 + mem_copy_val v25, v20 + v26 = get_local __ptr b256, asset_id_, !2925 + mem_copy_val v26, v19 + v27 = get_local __ptr slice, method_name_, !2926 + v28 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v28, v27 + v29 = get_local __ptr slice, __ret_val15 + v30 = call encode_208(v28, v29) + v31 = get_local __ptr slice, first_parameter, !2927 + mem_copy_val v31, v29 + v32 = get_local __ptr { [u64; 32] }, args_, !2928 + v33 = get_local __ptr { [u64; 32] }, item_, !2929 + mem_copy_val v33, v32 + v34 = get_local __ptr { [u64; 32] }, item_, !2930 + v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v36 = call new_21(v35) + v37 = get_local __ptr { [u64; 32] }, self_, !2931 + mem_copy_val v37, v34 + v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2932 + mem_copy_val v38, v35 + v39 = get_local __ptr { [u64; 32] }, self_, !2933 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr [u64; 32], v40, !2934 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2935 + v43 = get_local __ptr [u64; 32], __tmp_arg8 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v44, v42 + v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v46 = call abi_encode_49(v43, v44, v45) + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2936 + mem_copy_val v47, v45 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2937 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2938 + mem_copy_val v49, v48 + v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2939 + v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, __ret_val8 + v53 = call as_raw_slice_22(v51, v52) + v54 = get_local __ptr slice, second_parameter, !2940 + mem_copy_val v54, v52 + v55 = get_local __ptr b256, contract_id_, !2941 + v56 = get_local __ptr slice, first_parameter, !2942 + v57 = get_local __ptr slice, self_0, !2943 + mem_copy_val v57, v56 + v58 = get_local __ptr slice, self_0, !2944 + v59 = get_local __ptr slice, slice_, !2945 + mem_copy_val v59, v58 + v60 = get_local __ptr slice, slice_, !2946 + v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { + } + v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v62, v61 + v63 = get_local __ptr { ptr, u64 }, __anon_01, !2943 + mem_copy_val v63, v62 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr ptr, v64, !2947 + v66 = load v65, !2943 + v67 = asm(a: v66) -> u64 a, !2948 { + } + v68 = get_local __ptr slice, second_parameter, !2949 + v69 = get_local __ptr slice, self_1, !2950 + mem_copy_val v69, v68 + v70 = get_local __ptr slice, self_1, !2951 + v71 = get_local __ptr slice, slice_0, !2952 + mem_copy_val v71, v70 + v72 = get_local __ptr slice, slice_0, !2953 + v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { + } + v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v74, v73 + v75 = get_local __ptr { ptr, u64 }, __anon_02, !2950 + mem_copy_val v75, v74 + v76 = get_elem_ptr v75, __ptr ptr, v64, !2954 + v77 = load v76, !2950 + v78 = asm(a: v77) -> u64 a, !2955 { + } + v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !2956 + v80 = const u64 0 + v81 = get_elem_ptr v79, __ptr b256, v80, !2957 + mem_copy_val v81, v55 + v82 = const u64 1 + v83 = get_elem_ptr v79, __ptr u64, v82, !2958 + store v67 to v83, !2959 + v84 = const u64 2 + v85 = get_elem_ptr v79, __ptr u64, v84, !2960 + store v78 to v85, !2961 + v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v86, v79 + v87 = get_local __ptr slice, __ret_val16 + v88 = call encode_212(v86, v87) + v89 = get_local __ptr slice, params, !2962 + mem_copy_val v89, v87 + v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v91 = call new_21(v90) + v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v92, v90 + v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v94 = const u64 100, !1772 + v95 = call abi_encode_20(v94, v92, v93) + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2963 + mem_copy_val v96, v93 + v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2964 + v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, __ret_val9 + v100 = call as_raw_slice_22(v98, v99) + v101 = get_local __ptr slice, __log_arg + mem_copy_val v101, v99 + v102 = const u64 1515152261580153489 + log __ptr slice v101, v102 + v103 = get_local __ptr slice, params, !2965 + v104 = get_local __ptr slice, self_2, !2966 + mem_copy_val v104, v103 + v105 = get_local __ptr slice, self_2, !2967 + v106 = get_local __ptr slice, slice_1, !2968 + mem_copy_val v106, v105 + v107 = get_local __ptr slice, slice_1, !2969 + v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { + } + v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v109, v108 + v110 = get_local __ptr { ptr, u64 }, __anon_03, !2966 + mem_copy_val v110, v109 + v111 = get_elem_ptr v110, __ptr ptr, v64, !2970 + v112 = load v111, !2966 + v113 = get_local __ptr b256, asset_id_, !2971 + v114 = get_local __ptr b256, __anon_10, !2925 + mem_copy_val v114, v113 + v115 = get_local __ptr b256, __anon_10, !2925 + v116 = const u64 0 + v117 = const u64 18446744073709551615 + v118 = contract_call __ptr () v112, v116, v115, v117, !2972 + v119 = asm() -> ptr ret, !2973 { + } + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v121 = call new_21(v120) + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v122, v120 + v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v124 = const u64 101, !1790 + v125 = call abi_encode_20(v124, v122, v123) + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2974 + mem_copy_val v126, v123 + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2975 + v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v128, v127 + v129 = get_local __ptr slice, __ret_val10 + v130 = call as_raw_slice_22(v128, v129) + v131 = get_local __ptr slice, __log_arg0 + mem_copy_val v131, v129 + v132 = const u64 1515152261580153489 + log __ptr slice v131, v132 + v133 = get_local __ptr { ptr }, __anon_000, !2976 + v134 = const u64 0 + v135 = get_elem_ptr v133, __ptr ptr, v134, !2977 + store v119 to v135, !2978 + v136 = get_local __ptr { ptr }, buffer, !2979 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v141 = const u64 102, !1801 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2980 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2981 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val11 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg1 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = get_local __ptr { ptr }, buffer, !2982 + v151 = get_local __ptr [u64; 32], __ret_val13 + v152 = call abi_decode_46(v150, v151) + v153 = get_local __ptr [u64; 32], r, !2983 + mem_copy_val v153, v151 + v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v155 = call new_21(v154) + v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v156, v154 + v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v158 = const u64 103, !1814 + v159 = call abi_encode_20(v158, v156, v157) + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2984 + mem_copy_val v160, v157 + v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2985 + v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v162, v161 + v163 = get_local __ptr slice, __ret_val12 + v164 = call as_raw_slice_22(v162, v163) + v165 = get_local __ptr slice, __log_arg2 + mem_copy_val v165, v163 + v166 = const u64 1515152261580153489 + log __ptr slice v165, v166 + v167 = get_local __ptr [u64; 32], r, !2986 + v168 = get_local __ptr [u64; 32], _, !2987 + mem_copy_val v168, v167 + v169 = const unit () + ret () v169 + } + + entry fn cost_of_in_array_64() -> (), !2991 { + local [u64; 64] _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local [u64; 64] __anon_2 + local { [u64; 64] } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local [u64; 64] __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local [u64; 64] __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { [u64; 64] } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { [u64; 64] } item_ + local slice method_name_ + local slice params + local [u64; 64] r + local slice second_parameter + local { [u64; 64] } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2992 + v1 = get_global __ptr string<11>, __const_global45 + v2 = cast_ptr v1 to ptr, !2993 + v3 = get_local __ptr { ptr, u64 }, __anon_0, !2993 + v4 = const u64 0 + v5 = get_elem_ptr v3, __ptr ptr, v4 + store v2 to v5, !2993 + v6 = const u64 1 + v7 = get_elem_ptr v3, __ptr u64, v6 + v8 = const u64 11 + store v8 to v7, !2993 + v9 = get_local __ptr slice, __anon_1, !2993 + mem_copy_bytes v9, v3, 16 + v10 = get_local __ptr [u64; 64], __anon_2, !2994 + v11 = const u64 0 + br array_init_loop(v11) + + array_init_loop(v12: u64): + v13 = get_elem_ptr v10, __ptr u64, v12 + v14 = const u64 0, !2995 + store v14 to v13, !2994 + v15 = const u64 1 + v16 = add v12, v15 + v17 = const u64 64 + v18 = cmp lt v16 v17 + cbr v18, array_init_loop(v16), array_init_exit() + + array_init_exit(): + v19 = get_local __ptr b256, __const + v20 = get_local __ptr { [u64; 64] }, __anon_3 + v21 = const u64 0 + v22 = get_elem_ptr v20, __ptr [u64; 64], v21 + mem_copy_val v22, v10 + v23 = get_local __ptr b256, contract_id_, !2996 + mem_copy_val v23, v0 + v24 = get_local __ptr slice, method_name_, !2996 + mem_copy_val v24, v9 + v25 = get_local __ptr { [u64; 64] }, args_, !2996 + mem_copy_val v25, v20 + v26 = get_local __ptr b256, asset_id_, !2996 + mem_copy_val v26, v19 + v27 = get_local __ptr slice, method_name_, !2997 + v28 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v28, v27 + v29 = get_local __ptr slice, __ret_val15 + v30 = call encode_208(v28, v29) + v31 = get_local __ptr slice, first_parameter, !2998 + mem_copy_val v31, v29 + v32 = get_local __ptr { [u64; 64] }, args_, !2999 + v33 = get_local __ptr { [u64; 64] }, item_, !3000 + mem_copy_val v33, v32 + v34 = get_local __ptr { [u64; 64] }, item_, !3001 + v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v36 = call new_21(v35) + v37 = get_local __ptr { [u64; 64] }, self_, !3002 + mem_copy_val v37, v34 + v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3003 + mem_copy_val v38, v35 + v39 = get_local __ptr { [u64; 64] }, self_, !3004 + v40 = const u64 0 + v41 = get_elem_ptr v39, __ptr [u64; 64], v40, !3005 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3006 + v43 = get_local __ptr [u64; 64], __tmp_arg8 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v44, v42 + v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v46 = call abi_encode_55(v43, v44, v45) + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3007 + mem_copy_val v47, v45 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3008 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3009 + mem_copy_val v49, v48 + v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3010 + v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, __ret_val8 + v53 = call as_raw_slice_22(v51, v52) + v54 = get_local __ptr slice, second_parameter, !3011 + mem_copy_val v54, v52 + v55 = get_local __ptr b256, contract_id_, !3012 + v56 = get_local __ptr slice, first_parameter, !3013 + v57 = get_local __ptr slice, self_0, !3014 + mem_copy_val v57, v56 + v58 = get_local __ptr slice, self_0, !3015 + v59 = get_local __ptr slice, slice_, !3016 + mem_copy_val v59, v58 + v60 = get_local __ptr slice, slice_, !3017 + v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { + } + v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v62, v61 + v63 = get_local __ptr { ptr, u64 }, __anon_01, !3014 + mem_copy_val v63, v62 + v64 = const u64 0 + v65 = get_elem_ptr v63, __ptr ptr, v64, !3018 + v66 = load v65, !3014 + v67 = asm(a: v66) -> u64 a, !3019 { + } + v68 = get_local __ptr slice, second_parameter, !3020 + v69 = get_local __ptr slice, self_1, !3021 + mem_copy_val v69, v68 + v70 = get_local __ptr slice, self_1, !3022 + v71 = get_local __ptr slice, slice_0, !3023 + mem_copy_val v71, v70 + v72 = get_local __ptr slice, slice_0, !3024 + v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { + } + v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v74, v73 + v75 = get_local __ptr { ptr, u64 }, __anon_02, !3021 + mem_copy_val v75, v74 + v76 = get_elem_ptr v75, __ptr ptr, v64, !3025 + v77 = load v76, !3021 + v78 = asm(a: v77) -> u64 a, !3026 { + } + v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !3027 + v80 = const u64 0 + v81 = get_elem_ptr v79, __ptr b256, v80, !3028 + mem_copy_val v81, v55 + v82 = const u64 1 + v83 = get_elem_ptr v79, __ptr u64, v82, !3029 + store v67 to v83, !3030 + v84 = const u64 2 + v85 = get_elem_ptr v79, __ptr u64, v84, !3031 + store v78 to v85, !3032 + v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v86, v79 + v87 = get_local __ptr slice, __ret_val16 + v88 = call encode_212(v86, v87) + v89 = get_local __ptr slice, params, !3033 + mem_copy_val v89, v87 + v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v91 = call new_21(v90) + v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v92, v90 + v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v94 = const u64 100, !1772 + v95 = call abi_encode_20(v94, v92, v93) + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3034 + mem_copy_val v96, v93 + v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3035 + v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v98, v97 + v99 = get_local __ptr slice, __ret_val9 + v100 = call as_raw_slice_22(v98, v99) + v101 = get_local __ptr slice, __log_arg + mem_copy_val v101, v99 + v102 = const u64 1515152261580153489 + log __ptr slice v101, v102 + v103 = get_local __ptr slice, params, !3036 + v104 = get_local __ptr slice, self_2, !3037 + mem_copy_val v104, v103 + v105 = get_local __ptr slice, self_2, !3038 + v106 = get_local __ptr slice, slice_1, !3039 + mem_copy_val v106, v105 + v107 = get_local __ptr slice, slice_1, !3040 + v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { + } + v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v109, v108 + v110 = get_local __ptr { ptr, u64 }, __anon_03, !3037 + mem_copy_val v110, v109 + v111 = get_elem_ptr v110, __ptr ptr, v64, !3041 + v112 = load v111, !3037 + v113 = get_local __ptr b256, asset_id_, !3042 + v114 = get_local __ptr b256, __anon_10, !2996 + mem_copy_val v114, v113 + v115 = get_local __ptr b256, __anon_10, !2996 + v116 = const u64 0 + v117 = const u64 18446744073709551615 + v118 = contract_call __ptr () v112, v116, v115, v117, !3043 + v119 = asm() -> ptr ret, !3044 { + } + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v121 = call new_21(v120) + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v122, v120 + v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v124 = const u64 101, !1790 + v125 = call abi_encode_20(v124, v122, v123) + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3045 + mem_copy_val v126, v123 + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3046 + v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v128, v127 + v129 = get_local __ptr slice, __ret_val10 + v130 = call as_raw_slice_22(v128, v129) + v131 = get_local __ptr slice, __log_arg0 + mem_copy_val v131, v129 + v132 = const u64 1515152261580153489 + log __ptr slice v131, v132 + v133 = get_local __ptr { ptr }, __anon_000, !3047 + v134 = const u64 0 + v135 = get_elem_ptr v133, __ptr ptr, v134, !3048 + store v119 to v135, !3049 + v136 = get_local __ptr { ptr }, buffer, !3050 + mem_copy_val v136, v133 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v141 = const u64 102, !1801 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3051 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3052 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val11 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg1 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = get_local __ptr { ptr }, buffer, !3053 + v151 = get_local __ptr [u64; 64], __ret_val13 + v152 = call abi_decode_52(v150, v151) + v153 = get_local __ptr [u64; 64], r, !3054 + mem_copy_val v153, v151 + v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v155 = call new_21(v154) + v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v156, v154 + v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v158 = const u64 103, !1814 + v159 = call abi_encode_20(v158, v156, v157) + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3055 + mem_copy_val v160, v157 + v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3056 + v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v162, v161 + v163 = get_local __ptr slice, __ret_val12 + v164 = call as_raw_slice_22(v162, v163) + v165 = get_local __ptr slice, __log_arg2 + mem_copy_val v165, v163 + v166 = const u64 1515152261580153489 + log __ptr slice v165, v166 + v167 = get_local __ptr [u64; 64], r, !3057 + v168 = get_local __ptr [u64; 64], _, !3058 + mem_copy_val v168, v167 + v169 = const unit () + ret () v169 + } + + entry fn cost_of_in_tuple_0() -> (), !3062 { + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { () } __anon_2 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local slice __ret_val14 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local slice __tmp_arg8 + local { b256, u64, u64 } __tmp_arg9 + local { () } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer_0 + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { () } item_ + local slice method_name_ + local slice params + local slice second_parameter + local { () } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3063 + v2 = get_global __ptr string<10>, __const_global46 + v3 = cast_ptr v2 to ptr, !3064 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3064 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3064 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !3064 + v10 = get_local __ptr slice, __anon_1, !3064 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { () }, __anon_2 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr (), v12 + v14 = const unit (), !3065 + store v14 to v13 + v15 = get_local __ptr b256, contract_id_, !3066 + mem_copy_val v15, v1 + v16 = get_local __ptr slice, method_name_, !3066 + mem_copy_val v16, v10 + v17 = get_local __ptr { () }, args_, !3066 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, asset_id_, !3066 + mem_copy_val v18, v0 + v19 = get_local __ptr slice, method_name_, !3067 + v20 = get_local __ptr slice, __tmp_arg8 + mem_copy_val v20, v19 + v21 = get_local __ptr slice, __ret_val13 + v22 = call encode_208(v20, v21) + v23 = get_local __ptr slice, first_parameter, !3068 + mem_copy_val v23, v21 + v24 = get_local __ptr { () }, args_, !3069 + v25 = get_local __ptr { () }, item_, !3070 + mem_copy_val v25, v24 + v26 = get_local __ptr { () }, item_, !3071 + v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v28 = call new_21(v27) + v29 = get_local __ptr { () }, self_, !3072 + mem_copy_val v29, v26 + v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3073 + mem_copy_val v30, v27 + v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3074 + v32 = get_local __ptr { { ptr, u64, u64 } }, buffer_0, !3077 + mem_copy_val v32, v31 + v33 = get_local __ptr { { ptr, u64, u64 } }, buffer_0, !3079 + v34 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3080 + mem_copy_val v34, v33 + v35 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3081 + v36 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3082 + mem_copy_val v36, v35 + v37 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3083 + v38 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v38, v37 + v39 = get_local __ptr slice, __ret_val8 + v40 = call as_raw_slice_22(v38, v39) + v41 = get_local __ptr slice, second_parameter, !3084 + mem_copy_val v41, v39 + v42 = get_local __ptr b256, contract_id_, !3085 + v43 = get_local __ptr slice, first_parameter, !3086 + v44 = get_local __ptr slice, self_0, !3087 + mem_copy_val v44, v43 + v45 = get_local __ptr slice, self_0, !3088 + v46 = get_local __ptr slice, slice_, !3089 + mem_copy_val v46, v45 + v47 = get_local __ptr slice, slice_, !3090 + v48 = asm(ptr: v47) -> __ptr { ptr, u64 } ptr { + } + v49 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v49, v48 + v50 = get_local __ptr { ptr, u64 }, __anon_01, !3087 + mem_copy_val v50, v49 + v51 = const u64 0 + v52 = get_elem_ptr v50, __ptr ptr, v51, !3091 + v53 = load v52, !3087 + v54 = asm(a: v53) -> u64 a, !3092 { + } + v55 = get_local __ptr slice, second_parameter, !3093 + v56 = get_local __ptr slice, self_1, !3094 + mem_copy_val v56, v55 + v57 = get_local __ptr slice, self_1, !3095 + v58 = get_local __ptr slice, slice_0, !3096 + mem_copy_val v58, v57 + v59 = get_local __ptr slice, slice_0, !3097 + v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { + } + v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v61, v60 + v62 = get_local __ptr { ptr, u64 }, __anon_02, !3094 + mem_copy_val v62, v61 + v63 = get_elem_ptr v62, __ptr ptr, v51, !3098 + v64 = load v63, !3094 + v65 = asm(a: v64) -> u64 a, !3099 { + } + v66 = get_local __ptr { b256, u64, u64 }, __anon_00, !3100 + v67 = const u64 0 + v68 = get_elem_ptr v66, __ptr b256, v67, !3101 + mem_copy_val v68, v42 + v69 = const u64 1 + v70 = get_elem_ptr v66, __ptr u64, v69, !3102 + store v54 to v70, !3103 + v71 = const u64 2 + v72 = get_elem_ptr v66, __ptr u64, v71, !3104 + store v65 to v72, !3105 + v73 = get_local __ptr { b256, u64, u64 }, __tmp_arg9 + mem_copy_val v73, v66 + v74 = get_local __ptr slice, __ret_val14 + v75 = call encode_212(v73, v74) + v76 = get_local __ptr slice, params, !3106 + mem_copy_val v76, v74 + v77 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v78 = call new_21(v77) + v79 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v79, v77 + v80 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v81 = const u64 100, !1772 + v82 = call abi_encode_20(v81, v79, v80) + v83 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3107 + mem_copy_val v83, v80 + v84 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3108 + v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v85, v84 + v86 = get_local __ptr slice, __ret_val9 + v87 = call as_raw_slice_22(v85, v86) + v88 = get_local __ptr slice, __log_arg + mem_copy_val v88, v86 + v89 = const u64 1515152261580153489 + log __ptr slice v88, v89 + v90 = get_local __ptr slice, params, !3109 + v91 = get_local __ptr slice, self_2, !3110 + mem_copy_val v91, v90 + v92 = get_local __ptr slice, self_2, !3111 + v93 = get_local __ptr slice, slice_1, !3112 + mem_copy_val v93, v92 + v94 = get_local __ptr slice, slice_1, !3113 + v95 = asm(ptr: v94) -> __ptr { ptr, u64 } ptr { + } + v96 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v96, v95 + v97 = get_local __ptr { ptr, u64 }, __anon_03, !3110 + mem_copy_val v97, v96 + v98 = get_elem_ptr v97, __ptr ptr, v51, !3114 + v99 = load v98, !3110 + v100 = get_local __ptr b256, asset_id_, !3115 + v101 = get_local __ptr b256, __anon_10, !3066 + mem_copy_val v101, v100 + v102 = get_local __ptr b256, __anon_10, !3066 + v103 = const u64 0 + v104 = const u64 18446744073709551615 + v105 = contract_call __ptr () v99, v103, v102, v104, !3116 + v106 = asm() -> ptr ret, !3117 { + } + v107 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v108 = call new_21(v107) + v109 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v109, v107 + v110 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v111 = const u64 101, !1790 + v112 = call abi_encode_20(v111, v109, v110) + v113 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3118 + mem_copy_val v113, v110 + v114 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3119 + v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v115, v114 + v116 = get_local __ptr slice, __ret_val10 + v117 = call as_raw_slice_22(v115, v116) + v118 = get_local __ptr slice, __log_arg0 + mem_copy_val v118, v116 + v119 = const u64 1515152261580153489 + log __ptr slice v118, v119 + v120 = get_local __ptr { ptr }, __anon_000, !3120 + v121 = const u64 0 + v122 = get_elem_ptr v120, __ptr ptr, v121, !3121 + store v106 to v122, !3122 + v123 = get_local __ptr { ptr }, buffer, !3123 + mem_copy_val v123, v120 + v124 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v125 = call new_21(v124) + v126 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v126, v124 + v127 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v128 = const u64 102, !1801 + v129 = call abi_encode_20(v128, v126, v127) + v130 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3124 + mem_copy_val v130, v127 + v131 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3125 + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v132, v131 + v133 = get_local __ptr slice, __ret_val11 + v134 = call as_raw_slice_22(v132, v133) + v135 = get_local __ptr slice, __log_arg1 + mem_copy_val v135, v133 + v136 = const u64 1515152261580153489 + log __ptr slice v135, v136 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v141 = const u64 103, !1814 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3126 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3127 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val12 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg2 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = const unit () + ret () v150 + } + + entry fn cost_of_in_tuple_1() -> (), !3131 { + local { u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local { ptr, u64 } __anon_04 + local slice __anon_1 + local b256 __anon_10 + local { u64 } __anon_2 + local { { u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local slice __tmp_arg7 + local { b256, u64, u64 } __tmp_arg8 + local { { u64 } } __tmp_arg9 + local { { u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local b256 contract_id_ + local slice first_parameter + local slice method_name_ + local slice params + local { u64 } r + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3132 + v2 = get_global __ptr string<10>, __const_global47 + v3 = cast_ptr v2 to ptr, !3133 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3133 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3133 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !3133 + v10 = get_local __ptr slice, __anon_1, !3133 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64 }, __anon_2, !3134 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !3134 + v14 = const u64 0, !3135 + store v14 to v13, !3134 + v15 = get_local __ptr { { u64 } }, __anon_3 + v16 = const u64 0 + v17 = get_elem_ptr v15, __ptr { u64 }, v16 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, contract_id_, !3136 + mem_copy_val v18, v1 + v19 = get_local __ptr slice, method_name_, !3136 + mem_copy_val v19, v10 + v20 = get_local __ptr { { u64 } }, args_, !3136 + mem_copy_val v20, v15 + v21 = get_local __ptr b256, asset_id_, !3136 + mem_copy_val v21, v0 + v22 = get_local __ptr slice, method_name_, !3137 + v23 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v23, v22 + v24 = get_local __ptr slice, __ret_val11 + v25 = call encode_208(v23, v24) + v26 = get_local __ptr slice, first_parameter, !3138 + mem_copy_val v26, v24 + v27 = get_local __ptr { { u64 } }, args_, !3139 + v28 = get_local __ptr { { u64 } }, __tmp_arg9 + mem_copy_val v28, v27 + v29 = get_local __ptr slice, __ret_val13 + v30 = call encode_281(v28, v29) + v31 = get_local __ptr slice, second_parameter, !3140 + mem_copy_val v31, v29 + v32 = get_local __ptr b256, contract_id_, !3141 + v33 = get_local __ptr slice, first_parameter, !3142 + v34 = get_local __ptr slice, self_, !3143 + mem_copy_val v34, v33 + v35 = get_local __ptr slice, self_, !3144 + v36 = get_local __ptr slice, slice_, !3145 + mem_copy_val v36, v35 + v37 = get_local __ptr slice, slice_, !3146 + v38 = asm(ptr: v37) -> __ptr { ptr, u64 } ptr { + } + v39 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v39, v38 + v40 = get_local __ptr { ptr, u64 }, __anon_02, !3143 + mem_copy_val v40, v39 + v41 = const u64 0 + v42 = get_elem_ptr v40, __ptr ptr, v41, !3147 + v43 = load v42, !3143 + v44 = asm(a: v43) -> u64 a, !3148 { + } + v45 = get_local __ptr slice, second_parameter, !3149 + v46 = get_local __ptr slice, self_0, !3150 + mem_copy_val v46, v45 + v47 = get_local __ptr slice, self_0, !3151 + v48 = get_local __ptr slice, slice_0, !3152 + mem_copy_val v48, v47 + v49 = get_local __ptr slice, slice_0, !3153 + v50 = asm(ptr: v49) -> __ptr { ptr, u64 } ptr { + } + v51 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v51, v50 + v52 = get_local __ptr { ptr, u64 }, __anon_03, !3150 + mem_copy_val v52, v51 + v53 = get_elem_ptr v52, __ptr ptr, v41, !3154 + v54 = load v53, !3150 + v55 = asm(a: v54) -> u64 a, !3155 { + } + v56 = get_local __ptr { b256, u64, u64 }, __anon_00, !3156 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr b256, v57, !3157 + mem_copy_val v58, v32 + v59 = const u64 1 + v60 = get_elem_ptr v56, __ptr u64, v59, !3158 + store v44 to v60, !3159 + v61 = const u64 2 + v62 = get_elem_ptr v56, __ptr u64, v61, !3160 + store v55 to v62, !3161 + v63 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 + mem_copy_val v63, v56 + v64 = get_local __ptr slice, __ret_val12 + v65 = call encode_212(v63, v64) + v66 = get_local __ptr slice, params, !3162 + mem_copy_val v66, v64 + v67 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v68 = call new_21(v67) + v69 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v69, v67 + v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v71 = const u64 100, !1772 + v72 = call abi_encode_20(v71, v69, v70) + v73 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3163 + mem_copy_val v73, v70 + v74 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3164 + v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v75, v74 + v76 = get_local __ptr slice, __ret_val7 + v77 = call as_raw_slice_22(v75, v76) + v78 = get_local __ptr slice, __log_arg + mem_copy_val v78, v76 + v79 = const u64 1515152261580153489 + log __ptr slice v78, v79 + v80 = get_local __ptr slice, params, !3165 + v81 = get_local __ptr slice, self_1, !3166 + mem_copy_val v81, v80 + v82 = get_local __ptr slice, self_1, !3167 + v83 = get_local __ptr slice, slice_1, !3168 + mem_copy_val v83, v82 + v84 = get_local __ptr slice, slice_1, !3169 + v85 = asm(ptr: v84) -> __ptr { ptr, u64 } ptr { + } + v86 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v86, v85 + v87 = get_local __ptr { ptr, u64 }, __anon_04, !3166 + mem_copy_val v87, v86 + v88 = get_elem_ptr v87, __ptr ptr, v41, !3170 + v89 = load v88, !3166 + v90 = get_local __ptr b256, asset_id_, !3171 + v91 = get_local __ptr b256, __anon_10, !3136 + mem_copy_val v91, v90 + v92 = get_local __ptr b256, __anon_10, !3136 + v93 = const u64 0 + v94 = const u64 18446744073709551615 + v95 = contract_call __ptr () v89, v93, v92, v94, !3172 + v96 = asm() -> ptr ret, !3173 { + } + v97 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v98 = call new_21(v97) + v99 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v99, v97 + v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v101 = const u64 101, !1790 + v102 = call abi_encode_20(v101, v99, v100) + v103 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3174 + mem_copy_val v103, v100 + v104 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3175 + v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v105, v104 + v106 = get_local __ptr slice, __ret_val8 + v107 = call as_raw_slice_22(v105, v106) + v108 = get_local __ptr slice, __log_arg0 + mem_copy_val v108, v106 + v109 = const u64 1515152261580153489 + log __ptr slice v108, v109 + v110 = get_local __ptr { ptr }, __anon_000, !3176 + v111 = const u64 0 + v112 = get_elem_ptr v110, __ptr ptr, v111, !3177 + store v96 to v112, !3178 + v113 = get_local __ptr { ptr }, buffer, !3179 + mem_copy_val v113, v110 + v114 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v115 = call new_21(v114) + v116 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v116, v114 + v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v118 = const u64 102, !1801 + v119 = call abi_encode_20(v118, v116, v117) + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3180 + mem_copy_val v120, v117 + v121 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3181 + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v122, v121 + v123 = get_local __ptr slice, __ret_val9 + v124 = call as_raw_slice_22(v122, v123) + v125 = get_local __ptr slice, __log_arg1 + mem_copy_val v125, v123 + v126 = const u64 1515152261580153489 + log __ptr slice v125, v126 + v127 = get_local __ptr { ptr }, buffer, !3182 + v128 = const u64 0 + v129 = get_elem_ptr v127, __ptr ptr, v128, !3183 + v130 = load v129, !3184 + v131 = asm(ptr: v130, val) -> u64 val, !3185 { + lw val ptr i0, !58 + } + v132 = load v129, !3184 + v133 = const u64 8, !3184 + v134 = add v132, v133, !3184 + store v134 to v129, !3186 + v135 = get_local __ptr { u64 }, __anon_01, !3187 + v136 = const u64 0 + v137 = get_elem_ptr v135, __ptr u64, v136, !3188 + store v131 to v137, !3189 + v138 = get_local __ptr { u64 }, r, !3190 + mem_copy_val v138, v135 + v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v140 = call new_21(v139) + v141 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v141, v139 + v142 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v143 = const u64 103, !1814 + v144 = call abi_encode_20(v143, v141, v142) + v145 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3191 + mem_copy_val v145, v142 + v146 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3192 + v147 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v147, v146 + v148 = get_local __ptr slice, __ret_val10 + v149 = call as_raw_slice_22(v147, v148) + v150 = get_local __ptr slice, __log_arg2 + mem_copy_val v150, v148 + v151 = const u64 1515152261580153489 + log __ptr slice v150, v151 + v152 = get_local __ptr { u64 }, r, !3193 + v153 = get_local __ptr { u64 }, _, !3194 + mem_copy_val v153, v152 + v154 = const unit () + ret () v154 + } + + entry fn cost_of_in_tuple_2() -> (), !3198 { + local { u64, u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, u64 } __anon_2 + local { { u64, u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local { u64, u64 } __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local slice __ret_val14 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local slice __tmp_arg7 + local { b256, u64, u64 } __tmp_arg8 + local { { u64, u64 } } __tmp_arg9 + local { { u64, u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local b256 contract_id_ + local slice first_parameter + local slice method_name_ + local slice params + local { u64, u64 } r + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3199 + v2 = get_global __ptr string<10>, __const_global48 + v3 = cast_ptr v2 to ptr, !3200 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3200 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3200 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !3200 + v10 = get_local __ptr slice, __anon_1, !3200 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, u64 }, __anon_2, !3201 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !3201 + v14 = const u64 0, !3202 + store v14 to v13, !3201 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15, !3201 + v17 = const u64 0, !3203 + store v17 to v16, !3201 + v18 = get_local __ptr { { u64, u64 } }, __anon_3 + v19 = const u64 0 + v20 = get_elem_ptr v18, __ptr { u64, u64 }, v19 + mem_copy_val v20, v11 + v21 = get_local __ptr b256, contract_id_, !3204 + mem_copy_val v21, v1 + v22 = get_local __ptr slice, method_name_, !3204 + mem_copy_val v22, v10 + v23 = get_local __ptr { { u64, u64 } }, args_, !3204 + mem_copy_val v23, v18 + v24 = get_local __ptr b256, asset_id_, !3204 + mem_copy_val v24, v0 + v25 = get_local __ptr slice, method_name_, !3205 + v26 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v26, v25 + v27 = get_local __ptr slice, __ret_val12 + v28 = call encode_208(v26, v27) + v29 = get_local __ptr slice, first_parameter, !3206 + mem_copy_val v29, v27 + v30 = get_local __ptr { { u64, u64 } }, args_, !3207 + v31 = get_local __ptr { { u64, u64 } }, __tmp_arg9 + mem_copy_val v31, v30 + v32 = get_local __ptr slice, __ret_val14 + v33 = call encode_284(v31, v32) + v34 = get_local __ptr slice, second_parameter, !3208 + mem_copy_val v34, v32 + v35 = get_local __ptr b256, contract_id_, !3209 + v36 = get_local __ptr slice, first_parameter, !3210 + v37 = get_local __ptr slice, self_, !3211 + mem_copy_val v37, v36 + v38 = get_local __ptr slice, self_, !3212 + v39 = get_local __ptr slice, slice_, !3213 + mem_copy_val v39, v38 + v40 = get_local __ptr slice, slice_, !3214 + v41 = asm(ptr: v40) -> __ptr { ptr, u64 } ptr { + } + v42 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v42, v41 + v43 = get_local __ptr { ptr, u64 }, __anon_01, !3211 + mem_copy_val v43, v42 + v44 = const u64 0 + v45 = get_elem_ptr v43, __ptr ptr, v44, !3215 + v46 = load v45, !3211 + v47 = asm(a: v46) -> u64 a, !3216 { + } + v48 = get_local __ptr slice, second_parameter, !3217 + v49 = get_local __ptr slice, self_0, !3218 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !3219 + v51 = get_local __ptr slice, slice_0, !3220 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_0, !3221 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_02, !3218 + mem_copy_val v55, v54 + v56 = get_elem_ptr v55, __ptr ptr, v44, !3222 + v57 = load v56, !3218 + v58 = asm(a: v57) -> u64 a, !3223 { + } + v59 = get_local __ptr { b256, u64, u64 }, __anon_00, !3224 + v60 = const u64 0 + v61 = get_elem_ptr v59, __ptr b256, v60, !3225 + mem_copy_val v61, v35 + v62 = const u64 1 + v63 = get_elem_ptr v59, __ptr u64, v62, !3226 + store v47 to v63, !3227 + v64 = const u64 2 + v65 = get_elem_ptr v59, __ptr u64, v64, !3228 + store v58 to v65, !3229 + v66 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 + mem_copy_val v66, v59 + v67 = get_local __ptr slice, __ret_val13 + v68 = call encode_212(v66, v67) + v69 = get_local __ptr slice, params, !3230 + mem_copy_val v69, v67 + v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v71 = call new_21(v70) + v72 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v72, v70 + v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v74 = const u64 100, !1772 + v75 = call abi_encode_20(v74, v72, v73) + v76 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3231 + mem_copy_val v76, v73 + v77 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3232 + v78 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v78, v77 + v79 = get_local __ptr slice, __ret_val7 + v80 = call as_raw_slice_22(v78, v79) + v81 = get_local __ptr slice, __log_arg + mem_copy_val v81, v79 + v82 = const u64 1515152261580153489 + log __ptr slice v81, v82 + v83 = get_local __ptr slice, params, !3233 + v84 = get_local __ptr slice, self_1, !3234 + mem_copy_val v84, v83 + v85 = get_local __ptr slice, self_1, !3235 + v86 = get_local __ptr slice, slice_1, !3236 + mem_copy_val v86, v85 + v87 = get_local __ptr slice, slice_1, !3237 + v88 = asm(ptr: v87) -> __ptr { ptr, u64 } ptr { + } + v89 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v89, v88 + v90 = get_local __ptr { ptr, u64 }, __anon_03, !3234 + mem_copy_val v90, v89 + v91 = get_elem_ptr v90, __ptr ptr, v44, !3238 + v92 = load v91, !3234 + v93 = get_local __ptr b256, asset_id_, !3239 + v94 = get_local __ptr b256, __anon_10, !3204 + mem_copy_val v94, v93 + v95 = get_local __ptr b256, __anon_10, !3204 + v96 = const u64 0 + v97 = const u64 18446744073709551615 + v98 = contract_call __ptr () v92, v96, v95, v97, !3240 + v99 = asm() -> ptr ret, !3241 { + } + v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v101 = call new_21(v100) + v102 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v102, v100 + v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v104 = const u64 101, !1790 + v105 = call abi_encode_20(v104, v102, v103) + v106 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3242 + mem_copy_val v106, v103 + v107 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3243 + v108 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v108, v107 + v109 = get_local __ptr slice, __ret_val8 + v110 = call as_raw_slice_22(v108, v109) + v111 = get_local __ptr slice, __log_arg0 + mem_copy_val v111, v109 + v112 = const u64 1515152261580153489 + log __ptr slice v111, v112 + v113 = get_local __ptr { ptr }, __anon_000, !3244 + v114 = const u64 0 + v115 = get_elem_ptr v113, __ptr ptr, v114, !3245 + store v99 to v115, !3246 + v116 = get_local __ptr { ptr }, buffer, !3247 + mem_copy_val v116, v113 + v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v118 = call new_21(v117) + v119 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v119, v117 + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v121 = const u64 102, !1801 + v122 = call abi_encode_20(v121, v119, v120) + v123 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3248 + mem_copy_val v123, v120 + v124 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3249 + v125 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v125, v124 + v126 = get_local __ptr slice, __ret_val9 + v127 = call as_raw_slice_22(v125, v126) + v128 = get_local __ptr slice, __log_arg1 + mem_copy_val v128, v126 + v129 = const u64 1515152261580153489 + log __ptr slice v128, v129 + v130 = get_local __ptr { ptr }, buffer, !3250 + v131 = get_local __ptr { u64, u64 }, __ret_val11 + v132 = call abi_decode_134(v130, v131) + v133 = get_local __ptr { u64, u64 }, r, !3251 + mem_copy_val v133, v131 + v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v135 = call new_21(v134) + v136 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v136, v134 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v138 = const u64 103, !1814 + v139 = call abi_encode_20(v138, v136, v137) + v140 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3252 + mem_copy_val v140, v137 + v141 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3253 + v142 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v142, v141 + v143 = get_local __ptr slice, __ret_val10 + v144 = call as_raw_slice_22(v142, v143) + v145 = get_local __ptr slice, __log_arg2 + mem_copy_val v145, v143 + v146 = const u64 1515152261580153489 + log __ptr slice v145, v146 + v147 = get_local __ptr { u64, u64 }, r, !3254 + v148 = get_local __ptr { u64, u64 }, _, !3255 + mem_copy_val v148, v147 + v149 = const unit () + ret () v149 + } + + entry fn cost_of_in_tuple_3() -> (), !3259 { + local { u64, u64, u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, u64, u64 } __anon_2 + local { { u64, u64, u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local { u64, u64, u64 } __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local slice __ret_val14 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local slice __tmp_arg7 + local { b256, u64, u64 } __tmp_arg8 + local { { u64, u64, u64 } } __tmp_arg9 + local { { u64, u64, u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local b256 contract_id_ + local slice first_parameter + local slice method_name_ + local slice params + local { u64, u64, u64 } r + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3260 + v2 = get_global __ptr string<10>, __const_global49 + v3 = cast_ptr v2 to ptr, !3261 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3261 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3261 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !3261 + v10 = get_local __ptr slice, __anon_1, !3261 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, u64, u64 }, __anon_2, !3262 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !3262 + v14 = const u64 0, !3263 + store v14 to v13, !3262 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15, !3262 + v17 = const u64 0, !3264 + store v17 to v16, !3262 + v18 = const u64 2 + v19 = get_elem_ptr v11, __ptr u64, v18, !3262 + v20 = const u64 0, !3265 + store v20 to v19, !3262 + v21 = get_local __ptr { { u64, u64, u64 } }, __anon_3 + v22 = const u64 0 + v23 = get_elem_ptr v21, __ptr { u64, u64, u64 }, v22 + mem_copy_val v23, v11 + v24 = get_local __ptr b256, contract_id_, !3266 + mem_copy_val v24, v1 + v25 = get_local __ptr slice, method_name_, !3266 + mem_copy_val v25, v10 + v26 = get_local __ptr { { u64, u64, u64 } }, args_, !3266 + mem_copy_val v26, v21 + v27 = get_local __ptr b256, asset_id_, !3266 + mem_copy_val v27, v0 + v28 = get_local __ptr slice, method_name_, !3267 + v29 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v29, v28 + v30 = get_local __ptr slice, __ret_val12 + v31 = call encode_208(v29, v30) + v32 = get_local __ptr slice, first_parameter, !3268 + mem_copy_val v32, v30 + v33 = get_local __ptr { { u64, u64, u64 } }, args_, !3269 + v34 = get_local __ptr { { u64, u64, u64 } }, __tmp_arg9 + mem_copy_val v34, v33 + v35 = get_local __ptr slice, __ret_val14 + v36 = call encode_287(v34, v35) + v37 = get_local __ptr slice, second_parameter, !3270 + mem_copy_val v37, v35 + v38 = get_local __ptr b256, contract_id_, !3271 + v39 = get_local __ptr slice, first_parameter, !3272 + v40 = get_local __ptr slice, self_, !3273 + mem_copy_val v40, v39 + v41 = get_local __ptr slice, self_, !3274 + v42 = get_local __ptr slice, slice_, !3275 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, slice_, !3276 + v44 = asm(ptr: v43) -> __ptr { ptr, u64 } ptr { + } + v45 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v45, v44 + v46 = get_local __ptr { ptr, u64 }, __anon_01, !3273 + mem_copy_val v46, v45 + v47 = const u64 0 + v48 = get_elem_ptr v46, __ptr ptr, v47, !3277 + v49 = load v48, !3273 + v50 = asm(a: v49) -> u64 a, !3278 { + } + v51 = get_local __ptr slice, second_parameter, !3279 + v52 = get_local __ptr slice, self_0, !3280 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, self_0, !3281 + v54 = get_local __ptr slice, slice_0, !3282 + mem_copy_val v54, v53 + v55 = get_local __ptr slice, slice_0, !3283 + v56 = asm(ptr: v55) -> __ptr { ptr, u64 } ptr { + } + v57 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v57, v56 + v58 = get_local __ptr { ptr, u64 }, __anon_02, !3280 + mem_copy_val v58, v57 + v59 = get_elem_ptr v58, __ptr ptr, v47, !3284 + v60 = load v59, !3280 + v61 = asm(a: v60) -> u64 a, !3285 { + } + v62 = get_local __ptr { b256, u64, u64 }, __anon_00, !3286 + v63 = const u64 0 + v64 = get_elem_ptr v62, __ptr b256, v63, !3287 + mem_copy_val v64, v38 + v65 = const u64 1 + v66 = get_elem_ptr v62, __ptr u64, v65, !3288 + store v50 to v66, !3289 + v67 = const u64 2 + v68 = get_elem_ptr v62, __ptr u64, v67, !3290 + store v61 to v68, !3291 + v69 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 + mem_copy_val v69, v62 + v70 = get_local __ptr slice, __ret_val13 + v71 = call encode_212(v69, v70) + v72 = get_local __ptr slice, params, !3292 + mem_copy_val v72, v70 + v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v74 = call new_21(v73) + v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v75, v73 + v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v77 = const u64 100, !1772 + v78 = call abi_encode_20(v77, v75, v76) + v79 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3293 + mem_copy_val v79, v76 + v80 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3294 + v81 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v81, v80 + v82 = get_local __ptr slice, __ret_val7 + v83 = call as_raw_slice_22(v81, v82) + v84 = get_local __ptr slice, __log_arg + mem_copy_val v84, v82 + v85 = const u64 1515152261580153489 + log __ptr slice v84, v85 + v86 = get_local __ptr slice, params, !3295 + v87 = get_local __ptr slice, self_1, !3296 + mem_copy_val v87, v86 + v88 = get_local __ptr slice, self_1, !3297 + v89 = get_local __ptr slice, slice_1, !3298 + mem_copy_val v89, v88 + v90 = get_local __ptr slice, slice_1, !3299 + v91 = asm(ptr: v90) -> __ptr { ptr, u64 } ptr { + } + v92 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v92, v91 + v93 = get_local __ptr { ptr, u64 }, __anon_03, !3296 + mem_copy_val v93, v92 + v94 = get_elem_ptr v93, __ptr ptr, v47, !3300 + v95 = load v94, !3296 + v96 = get_local __ptr b256, asset_id_, !3301 + v97 = get_local __ptr b256, __anon_10, !3266 + mem_copy_val v97, v96 + v98 = get_local __ptr b256, __anon_10, !3266 + v99 = const u64 0 + v100 = const u64 18446744073709551615 + v101 = contract_call __ptr () v95, v99, v98, v100, !3302 + v102 = asm() -> ptr ret, !3303 { + } + v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v104 = call new_21(v103) + v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v105, v103 + v106 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v107 = const u64 101, !1790 + v108 = call abi_encode_20(v107, v105, v106) + v109 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3304 + mem_copy_val v109, v106 + v110 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3305 + v111 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v111, v110 + v112 = get_local __ptr slice, __ret_val8 + v113 = call as_raw_slice_22(v111, v112) + v114 = get_local __ptr slice, __log_arg0 + mem_copy_val v114, v112 + v115 = const u64 1515152261580153489 + log __ptr slice v114, v115 + v116 = get_local __ptr { ptr }, __anon_000, !3306 + v117 = const u64 0 + v118 = get_elem_ptr v116, __ptr ptr, v117, !3307 + store v102 to v118, !3308 + v119 = get_local __ptr { ptr }, buffer, !3309 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v121 = call new_21(v120) + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v122, v120 + v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v124 = const u64 102, !1801 + v125 = call abi_encode_20(v124, v122, v123) + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3310 + mem_copy_val v126, v123 + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3311 + v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v128, v127 + v129 = get_local __ptr slice, __ret_val9 + v130 = call as_raw_slice_22(v128, v129) + v131 = get_local __ptr slice, __log_arg1 + mem_copy_val v131, v129 + v132 = const u64 1515152261580153489 + log __ptr slice v131, v132 + v133 = get_local __ptr { ptr }, buffer, !3312 + v134 = get_local __ptr { u64, u64, u64 }, __ret_val11 + v135 = call abi_decode_162(v133, v134) + v136 = get_local __ptr { u64, u64, u64 }, r, !3313 + mem_copy_val v136, v134 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v141 = const u64 103, !1814 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3314 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3315 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val10 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg2 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = get_local __ptr { u64, u64, u64 }, r, !3316 + v151 = get_local __ptr { u64, u64, u64 }, _, !3317 + mem_copy_val v151, v150 + v152 = const unit () + ret () v152 + } + + entry fn cost_of_in_tuple_4() -> (), !3321 { + local { u64, u64, u64, u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, u64, u64, u64 } __anon_2 + local { { u64, u64, u64, u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { u64, u64, u64, u64 } __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { u64, u64, u64, u64 } __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { { u64, u64, u64, u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { { u64, u64, u64, u64 } } item_ + local slice method_name_ + local slice params + local { u64, u64, u64, u64 } r + local slice second_parameter + local { { u64, u64, u64, u64 } } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3322 + v2 = get_global __ptr string<10>, __const_global50 + v3 = cast_ptr v2 to ptr, !3323 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3323 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3323 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 10 + store v9 to v8, !3323 + v10 = get_local __ptr slice, __anon_1, !3323 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, u64, u64, u64 }, __anon_2, !3324 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !3324 + v14 = const u64 0, !3325 + store v14 to v13, !3324 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15, !3324 + v17 = const u64 0, !3326 + store v17 to v16, !3324 + v18 = const u64 2 + v19 = get_elem_ptr v11, __ptr u64, v18, !3324 + v20 = const u64 0, !3327 + store v20 to v19, !3324 + v21 = const u64 3 + v22 = get_elem_ptr v11, __ptr u64, v21, !3324 + v23 = const u64 0, !3328 + store v23 to v22, !3324 + v24 = get_local __ptr { { u64, u64, u64, u64 } }, __anon_3 + v25 = const u64 0 + v26 = get_elem_ptr v24, __ptr { u64, u64, u64, u64 }, v25 + mem_copy_val v26, v11 + v27 = get_local __ptr b256, contract_id_, !3329 + mem_copy_val v27, v1 + v28 = get_local __ptr slice, method_name_, !3329 + mem_copy_val v28, v10 + v29 = get_local __ptr { { u64, u64, u64, u64 } }, args_, !3329 + mem_copy_val v29, v24 + v30 = get_local __ptr b256, asset_id_, !3329 + mem_copy_val v30, v0 + v31 = get_local __ptr slice, method_name_, !3330 + v32 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v32, v31 + v33 = get_local __ptr slice, __ret_val15 + v34 = call encode_208(v32, v33) + v35 = get_local __ptr slice, first_parameter, !3331 + mem_copy_val v35, v33 + v36 = get_local __ptr { { u64, u64, u64, u64 } }, args_, !3332 + v37 = get_local __ptr { { u64, u64, u64, u64 } }, item_, !3333 + mem_copy_val v37, v36 + v38 = get_local __ptr { { u64, u64, u64, u64 } }, item_, !3334 + v39 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v40 = call new_21(v39) + v41 = get_local __ptr { { u64, u64, u64, u64 } }, self_, !3335 + mem_copy_val v41, v38 + v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3336 + mem_copy_val v42, v39 + v43 = get_local __ptr { { u64, u64, u64, u64 } }, self_, !3337 + v44 = const u64 0 + v45 = get_elem_ptr v43, __ptr { u64, u64, u64, u64 }, v44, !3338 + v46 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3339 + v47 = get_local __ptr { u64, u64, u64, u64 }, __tmp_arg8 + mem_copy_val v47, v45 + v48 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v48, v46 + v49 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v50 = call abi_encode_171(v47, v48, v49) + v51 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3340 + mem_copy_val v51, v49 + v52 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3341 + v53 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3342 + mem_copy_val v53, v52 + v54 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3343 + v55 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v55, v54 + v56 = get_local __ptr slice, __ret_val8 + v57 = call as_raw_slice_22(v55, v56) + v58 = get_local __ptr slice, second_parameter, !3344 + mem_copy_val v58, v56 + v59 = get_local __ptr b256, contract_id_, !3345 + v60 = get_local __ptr slice, first_parameter, !3346 + v61 = get_local __ptr slice, self_0, !3347 + mem_copy_val v61, v60 + v62 = get_local __ptr slice, self_0, !3348 + v63 = get_local __ptr slice, slice_, !3349 + mem_copy_val v63, v62 + v64 = get_local __ptr slice, slice_, !3350 + v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { + } + v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v66, v65 + v67 = get_local __ptr { ptr, u64 }, __anon_01, !3347 + mem_copy_val v67, v66 + v68 = const u64 0 + v69 = get_elem_ptr v67, __ptr ptr, v68, !3351 + v70 = load v69, !3347 + v71 = asm(a: v70) -> u64 a, !3352 { + } + v72 = get_local __ptr slice, second_parameter, !3353 + v73 = get_local __ptr slice, self_1, !3354 + mem_copy_val v73, v72 + v74 = get_local __ptr slice, self_1, !3355 + v75 = get_local __ptr slice, slice_0, !3356 + mem_copy_val v75, v74 + v76 = get_local __ptr slice, slice_0, !3357 + v77 = asm(ptr: v76) -> __ptr { ptr, u64 } ptr { + } + v78 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v78, v77 + v79 = get_local __ptr { ptr, u64 }, __anon_02, !3354 + mem_copy_val v79, v78 + v80 = get_elem_ptr v79, __ptr ptr, v68, !3358 + v81 = load v80, !3354 + v82 = asm(a: v81) -> u64 a, !3359 { + } + v83 = get_local __ptr { b256, u64, u64 }, __anon_00, !3360 + v84 = const u64 0 + v85 = get_elem_ptr v83, __ptr b256, v84, !3361 + mem_copy_val v85, v59 + v86 = const u64 1 + v87 = get_elem_ptr v83, __ptr u64, v86, !3362 + store v71 to v87, !3363 + v88 = const u64 2 + v89 = get_elem_ptr v83, __ptr u64, v88, !3364 + store v82 to v89, !3365 + v90 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v90, v83 + v91 = get_local __ptr slice, __ret_val16 + v92 = call encode_212(v90, v91) + v93 = get_local __ptr slice, params, !3366 + mem_copy_val v93, v91 + v94 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v95 = call new_21(v94) + v96 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v96, v94 + v97 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v98 = const u64 100, !1772 + v99 = call abi_encode_20(v98, v96, v97) + v100 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3367 + mem_copy_val v100, v97 + v101 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3368 + v102 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v102, v101 + v103 = get_local __ptr slice, __ret_val9 + v104 = call as_raw_slice_22(v102, v103) + v105 = get_local __ptr slice, __log_arg + mem_copy_val v105, v103 + v106 = const u64 1515152261580153489 + log __ptr slice v105, v106 + v107 = get_local __ptr slice, params, !3369 + v108 = get_local __ptr slice, self_2, !3370 + mem_copy_val v108, v107 + v109 = get_local __ptr slice, self_2, !3371 + v110 = get_local __ptr slice, slice_1, !3372 + mem_copy_val v110, v109 + v111 = get_local __ptr slice, slice_1, !3373 + v112 = asm(ptr: v111) -> __ptr { ptr, u64 } ptr { + } + v113 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v113, v112 + v114 = get_local __ptr { ptr, u64 }, __anon_03, !3370 + mem_copy_val v114, v113 + v115 = get_elem_ptr v114, __ptr ptr, v68, !3374 + v116 = load v115, !3370 + v117 = get_local __ptr b256, asset_id_, !3375 + v118 = get_local __ptr b256, __anon_10, !3329 + mem_copy_val v118, v117 + v119 = get_local __ptr b256, __anon_10, !3329 + v120 = const u64 0 + v121 = const u64 18446744073709551615 + v122 = contract_call __ptr () v116, v120, v119, v121, !3376 + v123 = asm() -> ptr ret, !3377 { + } + v124 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v125 = call new_21(v124) + v126 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v126, v124 + v127 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v128 = const u64 101, !1790 + v129 = call abi_encode_20(v128, v126, v127) + v130 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3378 + mem_copy_val v130, v127 + v131 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3379 + v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v132, v131 + v133 = get_local __ptr slice, __ret_val10 + v134 = call as_raw_slice_22(v132, v133) + v135 = get_local __ptr slice, __log_arg0 + mem_copy_val v135, v133 + v136 = const u64 1515152261580153489 + log __ptr slice v135, v136 + v137 = get_local __ptr { ptr }, __anon_000, !3380 + v138 = const u64 0 + v139 = get_elem_ptr v137, __ptr ptr, v138, !3381 + store v123 to v139, !3382 + v140 = get_local __ptr { ptr }, buffer, !3383 + mem_copy_val v140, v137 + v141 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v142 = call new_21(v141) + v143 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v143, v141 + v144 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v145 = const u64 102, !1801 + v146 = call abi_encode_20(v145, v143, v144) + v147 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3384 + mem_copy_val v147, v144 + v148 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3385 + v149 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v149, v148 + v150 = get_local __ptr slice, __ret_val11 + v151 = call as_raw_slice_22(v149, v150) + v152 = get_local __ptr slice, __log_arg1 + mem_copy_val v152, v150 + v153 = const u64 1515152261580153489 + log __ptr slice v152, v153 + v154 = get_local __ptr { ptr }, buffer, !3386 + v155 = get_local __ptr { u64, u64, u64, u64 }, __ret_val13 + v156 = call abi_decode_168(v154, v155) + v157 = get_local __ptr { u64, u64, u64, u64 }, r, !3387 + mem_copy_val v157, v155 + v158 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v159 = call new_21(v158) + v160 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v160, v158 + v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v162 = const u64 103, !1814 + v163 = call abi_encode_20(v162, v160, v161) + v164 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3388 + mem_copy_val v164, v161 + v165 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3389 + v166 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v166, v165 + v167 = get_local __ptr slice, __ret_val12 + v168 = call as_raw_slice_22(v166, v167) + v169 = get_local __ptr slice, __log_arg2 + mem_copy_val v169, v167 + v170 = const u64 1515152261580153489 + log __ptr slice v169, v170 + v171 = get_local __ptr { u64, u64, u64, u64 }, r, !3390 + v172 = get_local __ptr { u64, u64, u64, u64 }, _, !3391 + mem_copy_val v172, v171 + v173 = const unit () + ret () v173 + } + + entry fn in_struct_u64() -> (), !3395 { + local { u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64 } __anon_2 + local { { u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local { u64 } __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local slice __ret_val14 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local slice __tmp_arg7 + local { b256, u64, u64 } __tmp_arg8 + local { { u64 } } __tmp_arg9 + local { { u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local b256 contract_id_ + local slice first_parameter + local slice method_name_ + local slice params + local { u64 } r + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3396 + v2 = get_global __ptr string<13>, __const_global51 + v3 = cast_ptr v2 to ptr, !3397 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3397 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3397 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 13 + store v9 to v8, !3397 + v10 = get_local __ptr slice, __anon_1, !3397 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64 }, __anon_2, !3398 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !3399 + store v14 to v13, !3398 + v15 = get_local __ptr { { u64 } }, __anon_3 + v16 = const u64 0 + v17 = get_elem_ptr v15, __ptr { u64 }, v16 + mem_copy_val v17, v11 + v18 = get_local __ptr b256, contract_id_, !3400 + mem_copy_val v18, v1 + v19 = get_local __ptr slice, method_name_, !3400 + mem_copy_val v19, v10 + v20 = get_local __ptr { { u64 } }, args_, !3400 + mem_copy_val v20, v15 + v21 = get_local __ptr b256, asset_id_, !3400 + mem_copy_val v21, v0 + v22 = get_local __ptr slice, method_name_, !3401 + v23 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v23, v22 + v24 = get_local __ptr slice, __ret_val12 + v25 = call encode_208(v23, v24) + v26 = get_local __ptr slice, first_parameter, !3402 + mem_copy_val v26, v24 + v27 = get_local __ptr { { u64 } }, args_, !3403 + v28 = get_local __ptr { { u64 } }, __tmp_arg9 + mem_copy_val v28, v27 + v29 = get_local __ptr slice, __ret_val14 + v30 = call encode_281(v28, v29) + v31 = get_local __ptr slice, second_parameter, !3404 + mem_copy_val v31, v29 + v32 = get_local __ptr b256, contract_id_, !3405 + v33 = get_local __ptr slice, first_parameter, !3406 + v34 = get_local __ptr slice, self_, !3407 + mem_copy_val v34, v33 + v35 = get_local __ptr slice, self_, !3408 + v36 = get_local __ptr slice, slice_, !3409 + mem_copy_val v36, v35 + v37 = get_local __ptr slice, slice_, !3410 + v38 = asm(ptr: v37) -> __ptr { ptr, u64 } ptr { + } + v39 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v39, v38 + v40 = get_local __ptr { ptr, u64 }, __anon_01, !3407 + mem_copy_val v40, v39 + v41 = const u64 0 + v42 = get_elem_ptr v40, __ptr ptr, v41, !3411 + v43 = load v42, !3407 + v44 = asm(a: v43) -> u64 a, !3412 { + } + v45 = get_local __ptr slice, second_parameter, !3413 + v46 = get_local __ptr slice, self_0, !3414 + mem_copy_val v46, v45 + v47 = get_local __ptr slice, self_0, !3415 + v48 = get_local __ptr slice, slice_0, !3416 + mem_copy_val v48, v47 + v49 = get_local __ptr slice, slice_0, !3417 + v50 = asm(ptr: v49) -> __ptr { ptr, u64 } ptr { + } + v51 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v51, v50 + v52 = get_local __ptr { ptr, u64 }, __anon_02, !3414 + mem_copy_val v52, v51 + v53 = get_elem_ptr v52, __ptr ptr, v41, !3418 + v54 = load v53, !3414 + v55 = asm(a: v54) -> u64 a, !3419 { + } + v56 = get_local __ptr { b256, u64, u64 }, __anon_00, !3420 + v57 = const u64 0 + v58 = get_elem_ptr v56, __ptr b256, v57, !3421 + mem_copy_val v58, v32 + v59 = const u64 1 + v60 = get_elem_ptr v56, __ptr u64, v59, !3422 + store v44 to v60, !3423 + v61 = const u64 2 + v62 = get_elem_ptr v56, __ptr u64, v61, !3424 + store v55 to v62, !3425 + v63 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 + mem_copy_val v63, v56 + v64 = get_local __ptr slice, __ret_val13 + v65 = call encode_212(v63, v64) + v66 = get_local __ptr slice, params, !3426 + mem_copy_val v66, v64 + v67 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v68 = call new_21(v67) + v69 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v69, v67 + v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v71 = const u64 100, !1772 + v72 = call abi_encode_20(v71, v69, v70) + v73 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3427 + mem_copy_val v73, v70 + v74 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3428 + v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v75, v74 + v76 = get_local __ptr slice, __ret_val7 + v77 = call as_raw_slice_22(v75, v76) + v78 = get_local __ptr slice, __log_arg + mem_copy_val v78, v76 + v79 = const u64 1515152261580153489 + log __ptr slice v78, v79 + v80 = get_local __ptr slice, params, !3429 + v81 = get_local __ptr slice, self_1, !3430 + mem_copy_val v81, v80 + v82 = get_local __ptr slice, self_1, !3431 + v83 = get_local __ptr slice, slice_1, !3432 + mem_copy_val v83, v82 + v84 = get_local __ptr slice, slice_1, !3433 + v85 = asm(ptr: v84) -> __ptr { ptr, u64 } ptr { + } + v86 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v86, v85 + v87 = get_local __ptr { ptr, u64 }, __anon_03, !3430 + mem_copy_val v87, v86 + v88 = get_elem_ptr v87, __ptr ptr, v41, !3434 + v89 = load v88, !3430 + v90 = get_local __ptr b256, asset_id_, !3435 + v91 = get_local __ptr b256, __anon_10, !3400 + mem_copy_val v91, v90 + v92 = get_local __ptr b256, __anon_10, !3400 + v93 = const u64 0 + v94 = const u64 18446744073709551615 + v95 = contract_call __ptr () v89, v93, v92, v94, !3436 + v96 = asm() -> ptr ret, !3437 { + } + v97 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v98 = call new_21(v97) + v99 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v99, v97 + v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v101 = const u64 101, !1790 + v102 = call abi_encode_20(v101, v99, v100) + v103 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3438 + mem_copy_val v103, v100 + v104 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3439 + v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v105, v104 + v106 = get_local __ptr slice, __ret_val8 + v107 = call as_raw_slice_22(v105, v106) + v108 = get_local __ptr slice, __log_arg0 + mem_copy_val v108, v106 + v109 = const u64 1515152261580153489 + log __ptr slice v108, v109 + v110 = get_local __ptr { ptr }, __anon_000, !3440 + v111 = const u64 0 + v112 = get_elem_ptr v110, __ptr ptr, v111, !3441 + store v96 to v112, !3442 + v113 = get_local __ptr { ptr }, buffer, !3443 + mem_copy_val v113, v110 + v114 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v115 = call new_21(v114) + v116 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v116, v114 + v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v118 = const u64 102, !1801 + v119 = call abi_encode_20(v118, v116, v117) + v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3444 + mem_copy_val v120, v117 + v121 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3445 + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v122, v121 + v123 = get_local __ptr slice, __ret_val9 + v124 = call as_raw_slice_22(v122, v123) + v125 = get_local __ptr slice, __log_arg1 + mem_copy_val v125, v123 + v126 = const u64 1515152261580153489 + log __ptr slice v125, v126 + v127 = get_local __ptr { ptr }, buffer, !3446 + v128 = get_local __ptr { u64 }, __ret_val11 + v129 = call abi_decode_128(v127, v128) + v130 = get_local __ptr { u64 }, r, !3447 + mem_copy_val v130, v128 + v131 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v132 = call new_21(v131) + v133 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v133, v131 + v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v135 = const u64 103, !1814 + v136 = call abi_encode_20(v135, v133, v134) + v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3448 + mem_copy_val v137, v134 + v138 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3449 + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v139, v138 + v140 = get_local __ptr slice, __ret_val10 + v141 = call as_raw_slice_22(v139, v140) + v142 = get_local __ptr slice, __log_arg2 + mem_copy_val v142, v140 + v143 = const u64 1515152261580153489 + log __ptr slice v142, v143 + v144 = get_local __ptr { u64 }, r, !3450 + v145 = get_local __ptr { u64 }, _, !3451 + mem_copy_val v145, v144 + v146 = const unit () + ret () v146 + } + + pub fn encode_281(item: __ptr { { u64 } }, __ret_value: __ptr slice) -> (), !3452 { + local { { ptr, u64, u64 } } __ret_val + local slice __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + + entry(item: __ptr { { u64 } }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3453 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr { u64 }, v3, !3454 + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v7 = call abi_encode_131(v4, v5, v6) + v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3455 + mem_copy_val v8, v6 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v10 = get_local __ptr slice, __ret_val0 + v11 = call as_raw_slice_22(v9, v10) + mem_copy_val __ret_value, v10 + v12 = const unit () + ret () v12 + } + + entry fn in_struct_u64_u64() -> (), !3459 { + local { u64, u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, u64 } __anon_2 + local { { u64, u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local { u64, u64 } __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local slice __ret_val14 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local slice __tmp_arg7 + local { b256, u64, u64 } __tmp_arg8 + local { { u64, u64 } } __tmp_arg9 + local { { u64, u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local b256 contract_id_ + local slice first_parameter + local slice method_name_ + local slice params + local { u64, u64 } r + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3460 + v2 = get_global __ptr string<17>, __const_global52 + v3 = cast_ptr v2 to ptr, !3461 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3461 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3461 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 17 + store v9 to v8, !3461 + v10 = get_local __ptr slice, __anon_1, !3461 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, u64 }, __anon_2, !3462 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !3463 + store v14 to v13, !3462 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15 + v17 = const u64 0, !3464 + store v17 to v16, !3462 + v18 = get_local __ptr { { u64, u64 } }, __anon_3 + v19 = const u64 0 + v20 = get_elem_ptr v18, __ptr { u64, u64 }, v19 + mem_copy_val v20, v11 + v21 = get_local __ptr b256, contract_id_, !3465 + mem_copy_val v21, v1 + v22 = get_local __ptr slice, method_name_, !3465 + mem_copy_val v22, v10 + v23 = get_local __ptr { { u64, u64 } }, args_, !3465 + mem_copy_val v23, v18 + v24 = get_local __ptr b256, asset_id_, !3465 + mem_copy_val v24, v0 + v25 = get_local __ptr slice, method_name_, !3466 + v26 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v26, v25 + v27 = get_local __ptr slice, __ret_val12 + v28 = call encode_208(v26, v27) + v29 = get_local __ptr slice, first_parameter, !3467 + mem_copy_val v29, v27 + v30 = get_local __ptr { { u64, u64 } }, args_, !3468 + v31 = get_local __ptr { { u64, u64 } }, __tmp_arg9 + mem_copy_val v31, v30 + v32 = get_local __ptr slice, __ret_val14 + v33 = call encode_284(v31, v32) + v34 = get_local __ptr slice, second_parameter, !3469 + mem_copy_val v34, v32 + v35 = get_local __ptr b256, contract_id_, !3470 + v36 = get_local __ptr slice, first_parameter, !3471 + v37 = get_local __ptr slice, self_, !3472 + mem_copy_val v37, v36 + v38 = get_local __ptr slice, self_, !3473 + v39 = get_local __ptr slice, slice_, !3474 + mem_copy_val v39, v38 + v40 = get_local __ptr slice, slice_, !3475 + v41 = asm(ptr: v40) -> __ptr { ptr, u64 } ptr { + } + v42 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v42, v41 + v43 = get_local __ptr { ptr, u64 }, __anon_01, !3472 + mem_copy_val v43, v42 + v44 = const u64 0 + v45 = get_elem_ptr v43, __ptr ptr, v44, !3476 + v46 = load v45, !3472 + v47 = asm(a: v46) -> u64 a, !3477 { + } + v48 = get_local __ptr slice, second_parameter, !3478 + v49 = get_local __ptr slice, self_0, !3479 + mem_copy_val v49, v48 + v50 = get_local __ptr slice, self_0, !3480 + v51 = get_local __ptr slice, slice_0, !3481 + mem_copy_val v51, v50 + v52 = get_local __ptr slice, slice_0, !3482 + v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { + } + v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v54, v53 + v55 = get_local __ptr { ptr, u64 }, __anon_02, !3479 + mem_copy_val v55, v54 + v56 = get_elem_ptr v55, __ptr ptr, v44, !3483 + v57 = load v56, !3479 + v58 = asm(a: v57) -> u64 a, !3484 { + } + v59 = get_local __ptr { b256, u64, u64 }, __anon_00, !3485 + v60 = const u64 0 + v61 = get_elem_ptr v59, __ptr b256, v60, !3486 + mem_copy_val v61, v35 + v62 = const u64 1 + v63 = get_elem_ptr v59, __ptr u64, v62, !3487 + store v47 to v63, !3488 + v64 = const u64 2 + v65 = get_elem_ptr v59, __ptr u64, v64, !3489 + store v58 to v65, !3490 + v66 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 + mem_copy_val v66, v59 + v67 = get_local __ptr slice, __ret_val13 + v68 = call encode_212(v66, v67) + v69 = get_local __ptr slice, params, !3491 + mem_copy_val v69, v67 + v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v71 = call new_21(v70) + v72 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v72, v70 + v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v74 = const u64 100, !1772 + v75 = call abi_encode_20(v74, v72, v73) + v76 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3492 + mem_copy_val v76, v73 + v77 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3493 + v78 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v78, v77 + v79 = get_local __ptr slice, __ret_val7 + v80 = call as_raw_slice_22(v78, v79) + v81 = get_local __ptr slice, __log_arg + mem_copy_val v81, v79 + v82 = const u64 1515152261580153489 + log __ptr slice v81, v82 + v83 = get_local __ptr slice, params, !3494 + v84 = get_local __ptr slice, self_1, !3495 + mem_copy_val v84, v83 + v85 = get_local __ptr slice, self_1, !3496 + v86 = get_local __ptr slice, slice_1, !3497 + mem_copy_val v86, v85 + v87 = get_local __ptr slice, slice_1, !3498 + v88 = asm(ptr: v87) -> __ptr { ptr, u64 } ptr { + } + v89 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v89, v88 + v90 = get_local __ptr { ptr, u64 }, __anon_03, !3495 + mem_copy_val v90, v89 + v91 = get_elem_ptr v90, __ptr ptr, v44, !3499 + v92 = load v91, !3495 + v93 = get_local __ptr b256, asset_id_, !3500 + v94 = get_local __ptr b256, __anon_10, !3465 + mem_copy_val v94, v93 + v95 = get_local __ptr b256, __anon_10, !3465 + v96 = const u64 0 + v97 = const u64 18446744073709551615 + v98 = contract_call __ptr () v92, v96, v95, v97, !3501 + v99 = asm() -> ptr ret, !3502 { + } + v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v101 = call new_21(v100) + v102 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v102, v100 + v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v104 = const u64 101, !1790 + v105 = call abi_encode_20(v104, v102, v103) + v106 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3503 + mem_copy_val v106, v103 + v107 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3504 + v108 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v108, v107 + v109 = get_local __ptr slice, __ret_val8 + v110 = call as_raw_slice_22(v108, v109) + v111 = get_local __ptr slice, __log_arg0 + mem_copy_val v111, v109 + v112 = const u64 1515152261580153489 + log __ptr slice v111, v112 + v113 = get_local __ptr { ptr }, __anon_000, !3505 + v114 = const u64 0 + v115 = get_elem_ptr v113, __ptr ptr, v114, !3506 + store v99 to v115, !3507 + v116 = get_local __ptr { ptr }, buffer, !3508 + mem_copy_val v116, v113 + v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v118 = call new_21(v117) + v119 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v119, v117 + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v121 = const u64 102, !1801 + v122 = call abi_encode_20(v121, v119, v120) + v123 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3509 + mem_copy_val v123, v120 + v124 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3510 + v125 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v125, v124 + v126 = get_local __ptr slice, __ret_val9 + v127 = call as_raw_slice_22(v125, v126) + v128 = get_local __ptr slice, __log_arg1 + mem_copy_val v128, v126 + v129 = const u64 1515152261580153489 + log __ptr slice v128, v129 + v130 = get_local __ptr { ptr }, buffer, !3511 + v131 = get_local __ptr { u64, u64 }, __ret_val11 + v132 = call abi_decode_134(v130, v131) + v133 = get_local __ptr { u64, u64 }, r, !3512 + mem_copy_val v133, v131 + v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v135 = call new_21(v134) + v136 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v136, v134 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v138 = const u64 103, !1814 + v139 = call abi_encode_20(v138, v136, v137) + v140 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3513 + mem_copy_val v140, v137 + v141 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3514 + v142 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v142, v141 + v143 = get_local __ptr slice, __ret_val10 + v144 = call as_raw_slice_22(v142, v143) + v145 = get_local __ptr slice, __log_arg2 + mem_copy_val v145, v143 + v146 = const u64 1515152261580153489 + log __ptr slice v145, v146 + v147 = get_local __ptr { u64, u64 }, r, !3515 + v148 = get_local __ptr { u64, u64 }, _, !3516 + mem_copy_val v148, v147 + v149 = const unit () + ret () v149 + } + + pub fn encode_284(item: __ptr { { u64, u64 } }, __ret_value: __ptr slice) -> (), !3517 { + local { { ptr, u64, u64 } } __ret_val + local slice __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + + entry(item: __ptr { { u64, u64 } }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3518 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr { u64, u64 }, v3, !3519 + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v7 = call abi_encode_159(v4, v5, v6) + v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3520 + mem_copy_val v8, v6 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v10 = get_local __ptr slice, __ret_val0 + v11 = call as_raw_slice_22(v9, v10) + mem_copy_val __ret_value, v10 + v12 = const unit () + ret () v12 + } + + entry fn in_struct_u64_u64_u64() -> (), !3524 { + local { u64, u64, u64 } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, u64, u64 } __anon_2 + local { { u64, u64, u64 } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local { u64, u64, u64 } __ret_val11 + local slice __ret_val12 + local slice __ret_val13 + local slice __ret_val14 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local slice __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local slice __tmp_arg7 + local { b256, u64, u64 } __tmp_arg8 + local { { u64, u64, u64 } } __tmp_arg9 + local { { u64, u64, u64 } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local b256 contract_id_ + local slice first_parameter + local slice method_name_ + local slice params + local { u64, u64, u64 } r + local slice second_parameter + local slice self_ + local slice self_0 + local slice self_1 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3525 + v2 = get_global __ptr string<21>, __const_global53 + v3 = cast_ptr v2 to ptr, !3526 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3526 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3526 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 21 + store v9 to v8, !3526 + v10 = get_local __ptr slice, __anon_1, !3526 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, u64, u64 }, __anon_2, !3527 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12 + v14 = const u64 0, !3528 + store v14 to v13, !3527 + v15 = const u64 1 + v16 = get_elem_ptr v11, __ptr u64, v15 + v17 = const u64 0, !3529 + store v17 to v16, !3527 + v18 = const u64 2 + v19 = get_elem_ptr v11, __ptr u64, v18 + v20 = const u64 0, !3530 + store v20 to v19, !3527 + v21 = get_local __ptr { { u64, u64, u64 } }, __anon_3 + v22 = const u64 0 + v23 = get_elem_ptr v21, __ptr { u64, u64, u64 }, v22 + mem_copy_val v23, v11 + v24 = get_local __ptr b256, contract_id_, !3531 + mem_copy_val v24, v1 + v25 = get_local __ptr slice, method_name_, !3531 + mem_copy_val v25, v10 + v26 = get_local __ptr { { u64, u64, u64 } }, args_, !3531 + mem_copy_val v26, v21 + v27 = get_local __ptr b256, asset_id_, !3531 + mem_copy_val v27, v0 + v28 = get_local __ptr slice, method_name_, !3532 + v29 = get_local __ptr slice, __tmp_arg7 + mem_copy_val v29, v28 + v30 = get_local __ptr slice, __ret_val12 + v31 = call encode_208(v29, v30) + v32 = get_local __ptr slice, first_parameter, !3533 + mem_copy_val v32, v30 + v33 = get_local __ptr { { u64, u64, u64 } }, args_, !3534 + v34 = get_local __ptr { { u64, u64, u64 } }, __tmp_arg9 + mem_copy_val v34, v33 + v35 = get_local __ptr slice, __ret_val14 + v36 = call encode_287(v34, v35) + v37 = get_local __ptr slice, second_parameter, !3535 + mem_copy_val v37, v35 + v38 = get_local __ptr b256, contract_id_, !3536 + v39 = get_local __ptr slice, first_parameter, !3537 + v40 = get_local __ptr slice, self_, !3538 + mem_copy_val v40, v39 + v41 = get_local __ptr slice, self_, !3539 + v42 = get_local __ptr slice, slice_, !3540 + mem_copy_val v42, v41 + v43 = get_local __ptr slice, slice_, !3541 + v44 = asm(ptr: v43) -> __ptr { ptr, u64 } ptr { + } + v45 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v45, v44 + v46 = get_local __ptr { ptr, u64 }, __anon_01, !3538 + mem_copy_val v46, v45 + v47 = const u64 0 + v48 = get_elem_ptr v46, __ptr ptr, v47, !3542 + v49 = load v48, !3538 + v50 = asm(a: v49) -> u64 a, !3543 { + } + v51 = get_local __ptr slice, second_parameter, !3544 + v52 = get_local __ptr slice, self_0, !3545 + mem_copy_val v52, v51 + v53 = get_local __ptr slice, self_0, !3546 + v54 = get_local __ptr slice, slice_0, !3547 + mem_copy_val v54, v53 + v55 = get_local __ptr slice, slice_0, !3548 + v56 = asm(ptr: v55) -> __ptr { ptr, u64 } ptr { + } + v57 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v57, v56 + v58 = get_local __ptr { ptr, u64 }, __anon_02, !3545 + mem_copy_val v58, v57 + v59 = get_elem_ptr v58, __ptr ptr, v47, !3549 + v60 = load v59, !3545 + v61 = asm(a: v60) -> u64 a, !3550 { + } + v62 = get_local __ptr { b256, u64, u64 }, __anon_00, !3551 + v63 = const u64 0 + v64 = get_elem_ptr v62, __ptr b256, v63, !3552 + mem_copy_val v64, v38 + v65 = const u64 1 + v66 = get_elem_ptr v62, __ptr u64, v65, !3553 + store v50 to v66, !3554 + v67 = const u64 2 + v68 = get_elem_ptr v62, __ptr u64, v67, !3555 + store v61 to v68, !3556 + v69 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 + mem_copy_val v69, v62 + v70 = get_local __ptr slice, __ret_val13 + v71 = call encode_212(v69, v70) + v72 = get_local __ptr slice, params, !3557 + mem_copy_val v72, v70 + v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v74 = call new_21(v73) + v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v75, v73 + v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v77 = const u64 100, !1772 + v78 = call abi_encode_20(v77, v75, v76) + v79 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3558 + mem_copy_val v79, v76 + v80 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3559 + v81 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v81, v80 + v82 = get_local __ptr slice, __ret_val7 + v83 = call as_raw_slice_22(v81, v82) + v84 = get_local __ptr slice, __log_arg + mem_copy_val v84, v82 + v85 = const u64 1515152261580153489 + log __ptr slice v84, v85 + v86 = get_local __ptr slice, params, !3560 + v87 = get_local __ptr slice, self_1, !3561 + mem_copy_val v87, v86 + v88 = get_local __ptr slice, self_1, !3562 + v89 = get_local __ptr slice, slice_1, !3563 + mem_copy_val v89, v88 + v90 = get_local __ptr slice, slice_1, !3564 + v91 = asm(ptr: v90) -> __ptr { ptr, u64 } ptr { + } + v92 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v92, v91 + v93 = get_local __ptr { ptr, u64 }, __anon_03, !3561 + mem_copy_val v93, v92 + v94 = get_elem_ptr v93, __ptr ptr, v47, !3565 + v95 = load v94, !3561 + v96 = get_local __ptr b256, asset_id_, !3566 + v97 = get_local __ptr b256, __anon_10, !3531 + mem_copy_val v97, v96 + v98 = get_local __ptr b256, __anon_10, !3531 + v99 = const u64 0 + v100 = const u64 18446744073709551615 + v101 = contract_call __ptr () v95, v99, v98, v100, !3567 + v102 = asm() -> ptr ret, !3568 { + } + v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v104 = call new_21(v103) + v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v105, v103 + v106 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v107 = const u64 101, !1790 + v108 = call abi_encode_20(v107, v105, v106) + v109 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3569 + mem_copy_val v109, v106 + v110 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3570 + v111 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v111, v110 + v112 = get_local __ptr slice, __ret_val8 + v113 = call as_raw_slice_22(v111, v112) + v114 = get_local __ptr slice, __log_arg0 + mem_copy_val v114, v112 + v115 = const u64 1515152261580153489 + log __ptr slice v114, v115 + v116 = get_local __ptr { ptr }, __anon_000, !3571 + v117 = const u64 0 + v118 = get_elem_ptr v116, __ptr ptr, v117, !3572 + store v102 to v118, !3573 + v119 = get_local __ptr { ptr }, buffer, !3574 + mem_copy_val v119, v116 + v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v121 = call new_21(v120) + v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v122, v120 + v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v124 = const u64 102, !1801 + v125 = call abi_encode_20(v124, v122, v123) + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3575 + mem_copy_val v126, v123 + v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3576 + v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v128, v127 + v129 = get_local __ptr slice, __ret_val9 + v130 = call as_raw_slice_22(v128, v129) + v131 = get_local __ptr slice, __log_arg1 + mem_copy_val v131, v129 + v132 = const u64 1515152261580153489 + log __ptr slice v131, v132 + v133 = get_local __ptr { ptr }, buffer, !3577 + v134 = get_local __ptr { u64, u64, u64 }, __ret_val11 + v135 = call abi_decode_162(v133, v134) + v136 = get_local __ptr { u64, u64, u64 }, r, !3578 + mem_copy_val v136, v134 + v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v138 = call new_21(v137) + v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v139, v137 + v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v141 = const u64 103, !1814 + v142 = call abi_encode_20(v141, v139, v140) + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3579 + mem_copy_val v143, v140 + v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3580 + v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v145, v144 + v146 = get_local __ptr slice, __ret_val10 + v147 = call as_raw_slice_22(v145, v146) + v148 = get_local __ptr slice, __log_arg2 + mem_copy_val v148, v146 + v149 = const u64 1515152261580153489 + log __ptr slice v148, v149 + v150 = get_local __ptr { u64, u64, u64 }, r, !3581 + v151 = get_local __ptr { u64, u64, u64 }, _, !3582 + mem_copy_val v151, v150 + v152 = const unit () + ret () v152 + } + + pub fn encode_287(item: __ptr { { u64, u64, u64 } }, __ret_value: __ptr slice) -> (), !3583 { + local { { ptr, u64, u64 } } __ret_val + local slice __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + + entry(item: __ptr { { u64, u64, u64 } }, __ret_value: __ptr slice): + v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v1 = call new_21(v0) + v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3584 + mem_copy_val v2, v0 + v3 = const u64 0 + v4 = get_elem_ptr item, __ptr { u64, u64, u64 }, v3, !3585 + v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ + v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v7 = call abi_encode_143(v4, v5, v6) + v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3586 + mem_copy_val v8, v6 + v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ + v10 = get_local __ptr slice, __ret_val0 + v11 = call as_raw_slice_22(v9, v10) + mem_copy_val __ret_value, v10 + v12 = const unit () + ret () v12 + } + + entry fn in_enum_u64() -> (), !3590 { + local { u64, ( u64 ) } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, ( u64 ) } __anon_2 + local { { u64, ( u64 ) } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { u64, ( u64 ) } __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { u64, ( u64 ) } __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { { u64, ( u64 ) } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { { u64, ( u64 ) } } item_ + local slice method_name_ + local slice params + local { u64, ( u64 ) } r + local slice second_parameter + local { { u64, ( u64 ) } } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3591 + v2 = get_global __ptr string<11>, __const_global54 + v3 = cast_ptr v2 to ptr, !3592 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3592 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3592 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 11 + store v9 to v8, !3592 + v10 = get_local __ptr slice, __anon_1, !3592 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, ( u64 ) }, __anon_2, !1385 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !1385 + v14 = const u64 0, !1385 + store v14 to v13, !1385 + v15 = const u64 1 + v16 = const u64 0 + v17 = get_elem_ptr v11, __ptr u64, v15, v16, !1385 + v18 = const u64 0, !3593 + store v18 to v17, !1385 + v19 = get_local __ptr { { u64, ( u64 ) } }, __anon_3 + v20 = const u64 0 + v21 = get_elem_ptr v19, __ptr { u64, ( u64 ) }, v20 + mem_copy_val v21, v11 + v22 = get_local __ptr b256, contract_id_, !3594 + mem_copy_val v22, v1 + v23 = get_local __ptr slice, method_name_, !3594 + mem_copy_val v23, v10 + v24 = get_local __ptr { { u64, ( u64 ) } }, args_, !3594 + mem_copy_val v24, v19 + v25 = get_local __ptr b256, asset_id_, !3594 + mem_copy_val v25, v0 + v26 = get_local __ptr slice, method_name_, !3595 + v27 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v27, v26 + v28 = get_local __ptr slice, __ret_val15 + v29 = call encode_208(v27, v28) + v30 = get_local __ptr slice, first_parameter, !3596 + mem_copy_val v30, v28 + v31 = get_local __ptr { { u64, ( u64 ) } }, args_, !3597 + v32 = get_local __ptr { { u64, ( u64 ) } }, item_, !3598 + mem_copy_val v32, v31 + v33 = get_local __ptr { { u64, ( u64 ) } }, item_, !3599 + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v35 = call new_21(v34) + v36 = get_local __ptr { { u64, ( u64 ) } }, self_, !3600 + mem_copy_val v36, v33 + v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3601 + mem_copy_val v37, v34 + v38 = get_local __ptr { { u64, ( u64 ) } }, self_, !3602 + v39 = const u64 0 + v40 = get_elem_ptr v38, __ptr { u64, ( u64 ) }, v39, !3603 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3604 + v42 = get_local __ptr { u64, ( u64 ) }, __tmp_arg8 + mem_copy_val v42, v40 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v45 = call abi_encode_83(v42, v43, v44) + v46 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3605 + mem_copy_val v46, v44 + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3606 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3607 + mem_copy_val v48, v47 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3608 + v50 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, __ret_val8 + v52 = call as_raw_slice_22(v50, v51) + v53 = get_local __ptr slice, second_parameter, !3609 + mem_copy_val v53, v51 + v54 = get_local __ptr b256, contract_id_, !3610 + v55 = get_local __ptr slice, first_parameter, !3611 + v56 = get_local __ptr slice, self_0, !3612 + mem_copy_val v56, v55 + v57 = get_local __ptr slice, self_0, !3613 + v58 = get_local __ptr slice, slice_, !3614 + mem_copy_val v58, v57 + v59 = get_local __ptr slice, slice_, !3615 + v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { + } + v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v61, v60 + v62 = get_local __ptr { ptr, u64 }, __anon_01, !3612 + mem_copy_val v62, v61 + v63 = const u64 0 + v64 = get_elem_ptr v62, __ptr ptr, v63, !3616 + v65 = load v64, !3612 + v66 = asm(a: v65) -> u64 a, !3617 { + } + v67 = get_local __ptr slice, second_parameter, !3618 + v68 = get_local __ptr slice, self_1, !3619 + mem_copy_val v68, v67 + v69 = get_local __ptr slice, self_1, !3620 + v70 = get_local __ptr slice, slice_0, !3621 + mem_copy_val v70, v69 + v71 = get_local __ptr slice, slice_0, !3622 + v72 = asm(ptr: v71) -> __ptr { ptr, u64 } ptr { + } + v73 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v73, v72 + v74 = get_local __ptr { ptr, u64 }, __anon_02, !3619 + mem_copy_val v74, v73 + v75 = get_elem_ptr v74, __ptr ptr, v63, !3623 + v76 = load v75, !3619 + v77 = asm(a: v76) -> u64 a, !3624 { + } + v78 = get_local __ptr { b256, u64, u64 }, __anon_00, !3625 + v79 = const u64 0 + v80 = get_elem_ptr v78, __ptr b256, v79, !3626 + mem_copy_val v80, v54 + v81 = const u64 1 + v82 = get_elem_ptr v78, __ptr u64, v81, !3627 + store v66 to v82, !3628 + v83 = const u64 2 + v84 = get_elem_ptr v78, __ptr u64, v83, !3629 + store v77 to v84, !3630 + v85 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v85, v78 + v86 = get_local __ptr slice, __ret_val16 + v87 = call encode_212(v85, v86) + v88 = get_local __ptr slice, params, !3631 + mem_copy_val v88, v86 + v89 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v90 = call new_21(v89) + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v91, v89 + v92 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v93 = const u64 100, !1772 + v94 = call abi_encode_20(v93, v91, v92) + v95 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3632 + mem_copy_val v95, v92 + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3633 + v97 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, __ret_val9 + v99 = call as_raw_slice_22(v97, v98) + v100 = get_local __ptr slice, __log_arg + mem_copy_val v100, v98 + v101 = const u64 1515152261580153489 + log __ptr slice v100, v101 + v102 = get_local __ptr slice, params, !3634 + v103 = get_local __ptr slice, self_2, !3635 + mem_copy_val v103, v102 + v104 = get_local __ptr slice, self_2, !3636 + v105 = get_local __ptr slice, slice_1, !3637 + mem_copy_val v105, v104 + v106 = get_local __ptr slice, slice_1, !3638 + v107 = asm(ptr: v106) -> __ptr { ptr, u64 } ptr { + } + v108 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v108, v107 + v109 = get_local __ptr { ptr, u64 }, __anon_03, !3635 + mem_copy_val v109, v108 + v110 = get_elem_ptr v109, __ptr ptr, v63, !3639 + v111 = load v110, !3635 + v112 = get_local __ptr b256, asset_id_, !3640 + v113 = get_local __ptr b256, __anon_10, !3594 + mem_copy_val v113, v112 + v114 = get_local __ptr b256, __anon_10, !3594 + v115 = const u64 0 + v116 = const u64 18446744073709551615 + v117 = contract_call __ptr () v111, v115, v114, v116, !3641 + v118 = asm() -> ptr ret, !3642 { + } + v119 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v120 = call new_21(v119) + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v121, v119 + v122 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v123 = const u64 101, !1790 + v124 = call abi_encode_20(v123, v121, v122) + v125 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3643 + mem_copy_val v125, v122 + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3644 + v127 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v127, v126 + v128 = get_local __ptr slice, __ret_val10 + v129 = call as_raw_slice_22(v127, v128) + v130 = get_local __ptr slice, __log_arg0 + mem_copy_val v130, v128 + v131 = const u64 1515152261580153489 + log __ptr slice v130, v131 + v132 = get_local __ptr { ptr }, __anon_000, !3645 + v133 = const u64 0 + v134 = get_elem_ptr v132, __ptr ptr, v133, !3646 + store v118 to v134, !3647 + v135 = get_local __ptr { ptr }, buffer, !3648 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v137 = call new_21(v136) + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v138, v136 + v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v140 = const u64 102, !1801 + v141 = call abi_encode_20(v140, v138, v139) + v142 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3649 + mem_copy_val v142, v139 + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3650 + v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v144, v143 + v145 = get_local __ptr slice, __ret_val11 + v146 = call as_raw_slice_22(v144, v145) + v147 = get_local __ptr slice, __log_arg1 + mem_copy_val v147, v145 + v148 = const u64 1515152261580153489 + log __ptr slice v147, v148 + v149 = get_local __ptr { ptr }, buffer, !3651 + v150 = get_local __ptr { u64, ( u64 ) }, __ret_val13 + v151 = call abi_decode_80(v149, v150) + v152 = get_local __ptr { u64, ( u64 ) }, r, !3652 + mem_copy_val v152, v150 + v153 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v154 = call new_21(v153) + v155 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v155, v153 + v156 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v157 = const u64 103, !1814 + v158 = call abi_encode_20(v157, v155, v156) + v159 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3653 + mem_copy_val v159, v156 + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3654 + v161 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v161, v160 + v162 = get_local __ptr slice, __ret_val12 + v163 = call as_raw_slice_22(v161, v162) + v164 = get_local __ptr slice, __log_arg2 + mem_copy_val v164, v162 + v165 = const u64 1515152261580153489 + log __ptr slice v164, v165 + v166 = get_local __ptr { u64, ( u64 ) }, r, !3655 + v167 = get_local __ptr { u64, ( u64 ) }, _, !3656 + mem_copy_val v167, v166 + v168 = const unit () + ret () v168 + } + + entry fn in_enum_u64_u64() -> (), !3660 { + local { u64, ( u64 | u64 ) } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, ( u64 | u64 ) } __anon_2 + local { { u64, ( u64 | u64 ) } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { u64, ( u64 | u64 ) } __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { u64, ( u64 | u64 ) } __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { { u64, ( u64 | u64 ) } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { { u64, ( u64 | u64 ) } } item_ + local slice method_name_ + local slice params + local { u64, ( u64 | u64 ) } r + local slice second_parameter + local { { u64, ( u64 | u64 ) } } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3661 + v2 = get_global __ptr string<15>, __const_global55 + v3 = cast_ptr v2 to ptr, !3662 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3662 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3662 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 15 + store v9 to v8, !3662 + v10 = get_local __ptr slice, __anon_1, !3662 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_2, !1417 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !1417 + v14 = const u64 0, !1417 + store v14 to v13, !1417 + v15 = const u64 1 + v16 = const u64 0 + v17 = get_elem_ptr v11, __ptr u64, v15, v16, !1417 + v18 = const u64 0, !3663 + store v18 to v17, !1417 + v19 = get_local __ptr { { u64, ( u64 | u64 ) } }, __anon_3 + v20 = const u64 0 + v21 = get_elem_ptr v19, __ptr { u64, ( u64 | u64 ) }, v20 + mem_copy_val v21, v11 + v22 = get_local __ptr b256, contract_id_, !3664 + mem_copy_val v22, v1 + v23 = get_local __ptr slice, method_name_, !3664 + mem_copy_val v23, v10 + v24 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_, !3664 + mem_copy_val v24, v19 + v25 = get_local __ptr b256, asset_id_, !3664 + mem_copy_val v25, v0 + v26 = get_local __ptr slice, method_name_, !3665 + v27 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v27, v26 + v28 = get_local __ptr slice, __ret_val15 + v29 = call encode_208(v27, v28) + v30 = get_local __ptr slice, first_parameter, !3666 + mem_copy_val v30, v28 + v31 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_, !3667 + v32 = get_local __ptr { { u64, ( u64 | u64 ) } }, item_, !3668 + mem_copy_val v32, v31 + v33 = get_local __ptr { { u64, ( u64 | u64 ) } }, item_, !3669 + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v35 = call new_21(v34) + v36 = get_local __ptr { { u64, ( u64 | u64 ) } }, self_, !3670 + mem_copy_val v36, v33 + v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3671 + mem_copy_val v37, v34 + v38 = get_local __ptr { { u64, ( u64 | u64 ) } }, self_, !3672 + v39 = const u64 0 + v40 = get_elem_ptr v38, __ptr { u64, ( u64 | u64 ) }, v39, !3673 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3674 + v42 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_arg8 + mem_copy_val v42, v40 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v45 = call abi_encode_89(v42, v43, v44) + v46 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3675 + mem_copy_val v46, v44 + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3676 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3677 + mem_copy_val v48, v47 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3678 + v50 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, __ret_val8 + v52 = call as_raw_slice_22(v50, v51) + v53 = get_local __ptr slice, second_parameter, !3679 + mem_copy_val v53, v51 + v54 = get_local __ptr b256, contract_id_, !3680 + v55 = get_local __ptr slice, first_parameter, !3681 + v56 = get_local __ptr slice, self_0, !3682 + mem_copy_val v56, v55 + v57 = get_local __ptr slice, self_0, !3683 + v58 = get_local __ptr slice, slice_, !3684 + mem_copy_val v58, v57 + v59 = get_local __ptr slice, slice_, !3685 + v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { + } + v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v61, v60 + v62 = get_local __ptr { ptr, u64 }, __anon_01, !3682 + mem_copy_val v62, v61 + v63 = const u64 0 + v64 = get_elem_ptr v62, __ptr ptr, v63, !3686 + v65 = load v64, !3682 + v66 = asm(a: v65) -> u64 a, !3687 { + } + v67 = get_local __ptr slice, second_parameter, !3688 + v68 = get_local __ptr slice, self_1, !3689 + mem_copy_val v68, v67 + v69 = get_local __ptr slice, self_1, !3690 + v70 = get_local __ptr slice, slice_0, !3691 + mem_copy_val v70, v69 + v71 = get_local __ptr slice, slice_0, !3692 + v72 = asm(ptr: v71) -> __ptr { ptr, u64 } ptr { + } + v73 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v73, v72 + v74 = get_local __ptr { ptr, u64 }, __anon_02, !3689 + mem_copy_val v74, v73 + v75 = get_elem_ptr v74, __ptr ptr, v63, !3693 + v76 = load v75, !3689 + v77 = asm(a: v76) -> u64 a, !3694 { + } + v78 = get_local __ptr { b256, u64, u64 }, __anon_00, !3695 + v79 = const u64 0 + v80 = get_elem_ptr v78, __ptr b256, v79, !3696 + mem_copy_val v80, v54 + v81 = const u64 1 + v82 = get_elem_ptr v78, __ptr u64, v81, !3697 + store v66 to v82, !3698 + v83 = const u64 2 + v84 = get_elem_ptr v78, __ptr u64, v83, !3699 + store v77 to v84, !3700 + v85 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v85, v78 + v86 = get_local __ptr slice, __ret_val16 + v87 = call encode_212(v85, v86) + v88 = get_local __ptr slice, params, !3701 + mem_copy_val v88, v86 + v89 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v90 = call new_21(v89) + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v91, v89 + v92 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v93 = const u64 100, !1772 + v94 = call abi_encode_20(v93, v91, v92) + v95 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3702 + mem_copy_val v95, v92 + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3703 + v97 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, __ret_val9 + v99 = call as_raw_slice_22(v97, v98) + v100 = get_local __ptr slice, __log_arg + mem_copy_val v100, v98 + v101 = const u64 1515152261580153489 + log __ptr slice v100, v101 + v102 = get_local __ptr slice, params, !3704 + v103 = get_local __ptr slice, self_2, !3705 + mem_copy_val v103, v102 + v104 = get_local __ptr slice, self_2, !3706 + v105 = get_local __ptr slice, slice_1, !3707 + mem_copy_val v105, v104 + v106 = get_local __ptr slice, slice_1, !3708 + v107 = asm(ptr: v106) -> __ptr { ptr, u64 } ptr { + } + v108 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v108, v107 + v109 = get_local __ptr { ptr, u64 }, __anon_03, !3705 + mem_copy_val v109, v108 + v110 = get_elem_ptr v109, __ptr ptr, v63, !3709 + v111 = load v110, !3705 + v112 = get_local __ptr b256, asset_id_, !3710 + v113 = get_local __ptr b256, __anon_10, !3664 + mem_copy_val v113, v112 + v114 = get_local __ptr b256, __anon_10, !3664 + v115 = const u64 0 + v116 = const u64 18446744073709551615 + v117 = contract_call __ptr () v111, v115, v114, v116, !3711 + v118 = asm() -> ptr ret, !3712 { + } + v119 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v120 = call new_21(v119) + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v121, v119 + v122 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v123 = const u64 101, !1790 + v124 = call abi_encode_20(v123, v121, v122) + v125 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3713 + mem_copy_val v125, v122 + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3714 + v127 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v127, v126 + v128 = get_local __ptr slice, __ret_val10 + v129 = call as_raw_slice_22(v127, v128) + v130 = get_local __ptr slice, __log_arg0 + mem_copy_val v130, v128 + v131 = const u64 1515152261580153489 + log __ptr slice v130, v131 + v132 = get_local __ptr { ptr }, __anon_000, !3715 + v133 = const u64 0 + v134 = get_elem_ptr v132, __ptr ptr, v133, !3716 + store v118 to v134, !3717 + v135 = get_local __ptr { ptr }, buffer, !3718 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v137 = call new_21(v136) + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v138, v136 + v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v140 = const u64 102, !1801 + v141 = call abi_encode_20(v140, v138, v139) + v142 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3719 + mem_copy_val v142, v139 + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3720 + v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v144, v143 + v145 = get_local __ptr slice, __ret_val11 + v146 = call as_raw_slice_22(v144, v145) + v147 = get_local __ptr slice, __log_arg1 + mem_copy_val v147, v145 + v148 = const u64 1515152261580153489 + log __ptr slice v147, v148 + v149 = get_local __ptr { ptr }, buffer, !3721 + v150 = get_local __ptr { u64, ( u64 | u64 ) }, __ret_val13 + v151 = call abi_decode_86(v149, v150) + v152 = get_local __ptr { u64, ( u64 | u64 ) }, r, !3722 + mem_copy_val v152, v150 + v153 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v154 = call new_21(v153) + v155 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v155, v153 + v156 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v157 = const u64 103, !1814 + v158 = call abi_encode_20(v157, v155, v156) + v159 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3723 + mem_copy_val v159, v156 + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3724 + v161 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v161, v160 + v162 = get_local __ptr slice, __ret_val12 + v163 = call as_raw_slice_22(v161, v162) + v164 = get_local __ptr slice, __log_arg2 + mem_copy_val v164, v162 + v165 = const u64 1515152261580153489 + log __ptr slice v164, v165 + v166 = get_local __ptr { u64, ( u64 | u64 ) }, r, !3725 + v167 = get_local __ptr { u64, ( u64 | u64 ) }, _, !3726 + mem_copy_val v167, v166 + v168 = const unit () + ret () v168 + } + + entry fn in_enum_u64_u64_u64() -> (), !3730 { + local { u64, ( u64 | u64 | u64 ) } _ + local mut { ptr, u64 } __aggr_memcpy_0 + local mut { ptr, u64 } __aggr_memcpy_00 + local mut { ptr, u64 } __aggr_memcpy_01 + local { ptr, u64 } __anon_0 + local { b256, u64, u64 } __anon_00 + local { ptr } __anon_000 + local { ptr, u64 } __anon_01 + local { ptr, u64 } __anon_02 + local { ptr, u64 } __anon_03 + local slice __anon_1 + local b256 __anon_10 + local { u64, ( u64 | u64 | u64 ) } __anon_2 + local { { u64, ( u64 | u64 | u64 ) } } __anon_3 + local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 + local slice __log_arg + local slice __log_arg0 + local slice __log_arg1 + local slice __log_arg2 + local { { ptr, u64, u64 } } __ret_val + local { { ptr, u64, u64 } } __ret_val0 + local { { ptr, u64, u64 } } __ret_val1 + local slice __ret_val10 + local slice __ret_val11 + local slice __ret_val12 + local { u64, ( u64 | u64 | u64 ) } __ret_val13 + local { { ptr, u64, u64 } } __ret_val14 + local slice __ret_val15 + local slice __ret_val16 + local { { ptr, u64, u64 } } __ret_val2 + local { { ptr, u64, u64 } } __ret_val3 + local { { ptr, u64, u64 } } __ret_val4 + local { { ptr, u64, u64 } } __ret_val5 + local { { ptr, u64, u64 } } __ret_val6 + local { { ptr, u64, u64 } } __ret_val7 + local slice __ret_val8 + local slice __ret_val9 + local { { ptr, u64, u64 } } __tmp_arg + local { { ptr, u64, u64 } } __tmp_arg0 + local { { ptr, u64, u64 } } __tmp_arg1 + local slice __tmp_arg10 + local { b256, u64, u64 } __tmp_arg11 + local { { ptr, u64, u64 } } __tmp_arg2 + local { { ptr, u64, u64 } } __tmp_arg3 + local { { ptr, u64, u64 } } __tmp_arg4 + local { { ptr, u64, u64 } } __tmp_arg5 + local { { ptr, u64, u64 } } __tmp_arg6 + local { { ptr, u64, u64 } } __tmp_arg7 + local { u64, ( u64 | u64 | u64 ) } __tmp_arg8 + local { { ptr, u64, u64 } } __tmp_arg9 + local { { u64, ( u64 | u64 | u64 ) } } args_ + local b256 asset_id_ + local mut { ptr } buffer + local { { ptr, u64, u64 } } buffer0 + local { { ptr, u64, u64 } } buffer1 + local { { ptr, u64, u64 } } buffer2 + local { { ptr, u64, u64 } } buffer3 + local { { ptr, u64, u64 } } buffer4 + local { { ptr, u64, u64 } } buffer_ + local { { ptr, u64, u64 } } buffer__ + local b256 contract_id_ + local slice first_parameter + local { { u64, ( u64 | u64 | u64 ) } } item_ + local slice method_name_ + local slice params + local { u64, ( u64 | u64 | u64 ) } r + local slice second_parameter + local { { u64, ( u64 | u64 | u64 ) } } self_ + local slice self_0 + local slice self_1 + local slice self_2 + local slice slice_ + local slice slice_0 + local slice slice_1 + + entry(): + v0 = get_local __ptr b256, __const + v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3731 + v2 = get_global __ptr string<19>, __const_global56 + v3 = cast_ptr v2 to ptr, !3732 + v4 = get_local __ptr { ptr, u64 }, __anon_0, !3732 + v5 = const u64 0 + v6 = get_elem_ptr v4, __ptr ptr, v5 + store v3 to v6, !3732 + v7 = const u64 1 + v8 = get_elem_ptr v4, __ptr u64, v7 + v9 = const u64 19 + store v9 to v8, !3732 + v10 = get_local __ptr slice, __anon_1, !3732 + mem_copy_bytes v10, v4, 16 + v11 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_2, !1463 + v12 = const u64 0 + v13 = get_elem_ptr v11, __ptr u64, v12, !1463 + v14 = const u64 0, !1463 + store v14 to v13, !1463 + v15 = const u64 1 + v16 = const u64 0 + v17 = get_elem_ptr v11, __ptr u64, v15, v16, !1463 + v18 = const u64 0, !3733 + store v18 to v17, !1463 + v19 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, __anon_3 + v20 = const u64 0 + v21 = get_elem_ptr v19, __ptr { u64, ( u64 | u64 | u64 ) }, v20 + mem_copy_val v21, v11 + v22 = get_local __ptr b256, contract_id_, !3734 + mem_copy_val v22, v1 + v23 = get_local __ptr slice, method_name_, !3734 + mem_copy_val v23, v10 + v24 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args_, !3734 + mem_copy_val v24, v19 + v25 = get_local __ptr b256, asset_id_, !3734 + mem_copy_val v25, v0 + v26 = get_local __ptr slice, method_name_, !3735 + v27 = get_local __ptr slice, __tmp_arg10 + mem_copy_val v27, v26 + v28 = get_local __ptr slice, __ret_val15 + v29 = call encode_208(v27, v28) + v30 = get_local __ptr slice, first_parameter, !3736 + mem_copy_val v30, v28 + v31 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args_, !3737 + v32 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, item_, !3738 + mem_copy_val v32, v31 + v33 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, item_, !3739 + v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 + v35 = call new_21(v34) + v36 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, self_, !3740 + mem_copy_val v36, v33 + v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3741 + mem_copy_val v37, v34 + v38 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, self_, !3742 + v39 = const u64 0 + v40 = get_elem_ptr v38, __ptr { u64, ( u64 | u64 | u64 ) }, v39, !3743 + v41 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3744 + v42 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_arg8 + mem_copy_val v42, v40 + v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 + mem_copy_val v43, v41 + v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 + v45 = call abi_encode_95(v42, v43, v44) + v46 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3745 + mem_copy_val v46, v44 + v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3746 + v48 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3747 + mem_copy_val v48, v47 + v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3748 + v50 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 + mem_copy_val v50, v49 + v51 = get_local __ptr slice, __ret_val8 + v52 = call as_raw_slice_22(v50, v51) + v53 = get_local __ptr slice, second_parameter, !3749 + mem_copy_val v53, v51 + v54 = get_local __ptr b256, contract_id_, !3750 + v55 = get_local __ptr slice, first_parameter, !3751 + v56 = get_local __ptr slice, self_0, !3752 + mem_copy_val v56, v55 + v57 = get_local __ptr slice, self_0, !3753 + v58 = get_local __ptr slice, slice_, !3754 + mem_copy_val v58, v57 + v59 = get_local __ptr slice, slice_, !3755 + v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { + } + v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 + mem_copy_val v61, v60 + v62 = get_local __ptr { ptr, u64 }, __anon_01, !3752 + mem_copy_val v62, v61 + v63 = const u64 0 + v64 = get_elem_ptr v62, __ptr ptr, v63, !3756 + v65 = load v64, !3752 + v66 = asm(a: v65) -> u64 a, !3757 { + } + v67 = get_local __ptr slice, second_parameter, !3758 + v68 = get_local __ptr slice, self_1, !3759 + mem_copy_val v68, v67 + v69 = get_local __ptr slice, self_1, !3760 + v70 = get_local __ptr slice, slice_0, !3761 + mem_copy_val v70, v69 + v71 = get_local __ptr slice, slice_0, !3762 + v72 = asm(ptr: v71) -> __ptr { ptr, u64 } ptr { + } + v73 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 + mem_copy_val v73, v72 + v74 = get_local __ptr { ptr, u64 }, __anon_02, !3759 + mem_copy_val v74, v73 + v75 = get_elem_ptr v74, __ptr ptr, v63, !3763 + v76 = load v75, !3759 + v77 = asm(a: v76) -> u64 a, !3764 { + } + v78 = get_local __ptr { b256, u64, u64 }, __anon_00, !3765 + v79 = const u64 0 + v80 = get_elem_ptr v78, __ptr b256, v79, !3766 + mem_copy_val v80, v54 + v81 = const u64 1 + v82 = get_elem_ptr v78, __ptr u64, v81, !3767 + store v66 to v82, !3768 + v83 = const u64 2 + v84 = get_elem_ptr v78, __ptr u64, v83, !3769 + store v77 to v84, !3770 + v85 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 + mem_copy_val v85, v78 + v86 = get_local __ptr slice, __ret_val16 + v87 = call encode_212(v85, v86) + v88 = get_local __ptr slice, params, !3771 + mem_copy_val v88, v86 + v89 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 + v90 = call new_21(v89) + v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg + mem_copy_val v91, v89 + v92 = get_local __ptr { { ptr, u64, u64 } }, __ret_val + v93 = const u64 100, !1772 + v94 = call abi_encode_20(v93, v91, v92) + v95 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3772 + mem_copy_val v95, v92 + v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3773 + v97 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 + mem_copy_val v97, v96 + v98 = get_local __ptr slice, __ret_val9 + v99 = call as_raw_slice_22(v97, v98) + v100 = get_local __ptr slice, __log_arg + mem_copy_val v100, v98 + v101 = const u64 1515152261580153489 + log __ptr slice v100, v101 + v102 = get_local __ptr slice, params, !3774 + v103 = get_local __ptr slice, self_2, !3775 + mem_copy_val v103, v102 + v104 = get_local __ptr slice, self_2, !3776 + v105 = get_local __ptr slice, slice_1, !3777 + mem_copy_val v105, v104 + v106 = get_local __ptr slice, slice_1, !3778 + v107 = asm(ptr: v106) -> __ptr { ptr, u64 } ptr { + } + v108 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 + mem_copy_val v108, v107 + v109 = get_local __ptr { ptr, u64 }, __anon_03, !3775 + mem_copy_val v109, v108 + v110 = get_elem_ptr v109, __ptr ptr, v63, !3779 + v111 = load v110, !3775 + v112 = get_local __ptr b256, asset_id_, !3780 + v113 = get_local __ptr b256, __anon_10, !3734 + mem_copy_val v113, v112 + v114 = get_local __ptr b256, __anon_10, !3734 + v115 = const u64 0 + v116 = const u64 18446744073709551615 + v117 = contract_call __ptr () v111, v115, v114, v116, !3781 + v118 = asm() -> ptr ret, !3782 { + } + v119 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 + v120 = call new_21(v119) + v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 + mem_copy_val v121, v119 + v122 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 + v123 = const u64 101, !1790 + v124 = call abi_encode_20(v123, v121, v122) + v125 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3783 + mem_copy_val v125, v122 + v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3784 + v127 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 + mem_copy_val v127, v126 + v128 = get_local __ptr slice, __ret_val10 + v129 = call as_raw_slice_22(v127, v128) + v130 = get_local __ptr slice, __log_arg0 + mem_copy_val v130, v128 + v131 = const u64 1515152261580153489 + log __ptr slice v130, v131 + v132 = get_local __ptr { ptr }, __anon_000, !3785 + v133 = const u64 0 + v134 = get_elem_ptr v132, __ptr ptr, v133, !3786 + store v118 to v134, !3787 + v135 = get_local __ptr { ptr }, buffer, !3788 + mem_copy_val v135, v132 + v136 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 + v137 = call new_21(v136) + v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 + mem_copy_val v138, v136 + v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 + v140 = const u64 102, !1801 + v141 = call abi_encode_20(v140, v138, v139) + v142 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3789 + mem_copy_val v142, v139 + v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3790 + v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 + mem_copy_val v144, v143 + v145 = get_local __ptr slice, __ret_val11 + v146 = call as_raw_slice_22(v144, v145) + v147 = get_local __ptr slice, __log_arg1 + mem_copy_val v147, v145 + v148 = const u64 1515152261580153489 + log __ptr slice v147, v148 + v149 = get_local __ptr { ptr }, buffer, !3791 + v150 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __ret_val13 + v151 = call abi_decode_92(v149, v150) + v152 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, r, !3792 + mem_copy_val v152, v150 + v153 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 + v154 = call new_21(v153) + v155 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 + mem_copy_val v155, v153 + v156 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 + v157 = const u64 103, !1814 + v158 = call abi_encode_20(v157, v155, v156) + v159 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3793 + mem_copy_val v159, v156 + v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3794 + v161 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 + mem_copy_val v161, v160 + v162 = get_local __ptr slice, __ret_val12 + v163 = call as_raw_slice_22(v161, v162) + v164 = get_local __ptr slice, __log_arg2 + mem_copy_val v164, v162 + v165 = const u64 1515152261580153489 + log __ptr slice v164, v165 + v166 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, r, !3795 + v167 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _, !3796 + mem_copy_val v167, v166 + v168 = const unit () + ret () v168 + } +} + +!0 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main..sw" +!1 = span !0 1 8828 +!2 = fn_name_span !0 8 15 +!3 = (!1 !2) +!4 = span !0 50 87 +!5 = fn_call_path_span !0 50 85 +!6 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/codec.sw" +!7 = span !6 1259 1300 +!8 = (!4 !5 !7) +!9 = span !6 1320 1359 +!10 = fn_call_path_span !6 1324 1327 +!11 = (!4 !5 !9 !10) +!12 = (!4 !5 !9 !10) +!13 = span !6 1379 1396 +!14 = fn_call_path_span !6 1383 1387 +!15 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_ptr.sw" +!16 = span !15 2650 2739 +!17 = (!4 !5 !13 !14 !16) +!18 = span !15 2688 2701 +!19 = span !6 1439 1497 +!20 = (!4 !5 !19) +!21 = span !6 1407 1508 +!22 = (!4 !5 !21) +!23 = (!4 !5) +!24 = (!4 !5 !21) +!25 = span !0 32 88 +!26 = span !0 120 147 +!27 = fn_call_path_span !0 120 138 +!28 = span !6 140299 140335 +!29 = fn_call_path_span !6 140299 140333 +!30 = span !6 882 923 +!31 = (!26 !27 !28 !29 !30) +!32 = span !6 943 981 +!33 = fn_call_path_span !6 947 950 +!34 = (!26 !27 !28 !29 !32 !33) +!35 = (!26 !27 !28 !29 !32 !33) +!36 = span !6 1001 1018 +!37 = fn_call_path_span !6 1005 1009 +!38 = (!26 !27 !28 !29 !36 !37 !16) +!39 = span !6 1061 1119 +!40 = (!26 !27 !28 !29 !39) +!41 = span !6 1029 1130 +!42 = (!26 !27 !28 !29 !41) +!43 = (!26 !27 !28 !29) +!44 = (!26 !27 !28 !29 !41) +!45 = span !6 140282 140336 +!46 = (!26 !27 !45) +!47 = span !6 140355 140361 +!48 = (!26 !27 !47) +!49 = span !6 140341 140362 +!50 = fn_call_path_span !6 140341 140354 +!51 = span !6 73247 73275 +!52 = fn_call_path_span !6 73254 73266 +!53 = span !6 625 637 +!54 = (!26 !27 !49 !50 !51 !52 !53) +!55 = (!26 !27 !49 !50 !51 !52) +!56 = span !6 2766 2847 +!57 = (!26 !27 !49 !50 !51 !52 !56) +!58 = span !6 2804 2817 +!59 = span !6 2857 2896 +!60 = (!26 !27 !49 !50 !51 !52 !59) +!61 = span !6 73285 73319 +!62 = (!26 !27 !49 !50 !61) +!63 = span !6 73336 73340 +!64 = (!26 !27 !49 !50 !63) +!65 = span !6 73336 73346 +!66 = fn_call_path_span !6 73341 73344 +!67 = (!26 !27 !49 !50 !65 !66) +!68 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_slice.sw" +!69 = span !68 2922 2926 +!70 = (!26 !27 !49 !50 !65 !66 !69) +!71 = span !68 2911 2927 +!72 = fn_call_path_span !68 2911 2921 +!73 = (!26 !27 !49 !50 !65 !66 !71 !72) +!74 = span !68 1633 1638 +!75 = (!26 !27 !49 !50 !65 !66 !71 !72 !74) +!76 = span !68 2928 2929 +!77 = (!26 !27 !49 !50 !65 !66 !76) +!78 = span !6 73335 73352 +!79 = (!26 !27 !49 !50 !78) +!80 = (!26 !27 !49 !50 !78) +!81 = (!26 !27 !49 !50 !78) +!82 = (!26 !27 !49 !50 !78) +!83 = span !0 101 148 +!84 = span !0 164 176 +!85 = span !0 180 192 +!86 = span !0 164 192 +!87 = span !0 219 226 +!88 = span !0 219 250 +!89 = fn_call_path_span !0 227 233 +!90 = span !6 3959 3978 +!91 = fn_call_path_span !6 3959 3972 +!92 = span !6 115441 115466 +!93 = (!88 !89 !90 !91 !92) +!94 = (!88 !89 !90 !91 !92) +!95 = span !0 195 251 +!96 = span !0 324 328 +!97 = span !0 329 330 +!98 = span !0 296 331 +!99 = fn_call_path_span !0 296 323 +!100 = (!98 !99) +!101 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw" +!102 = span !101 4062 4063 +!103 = (!98 !99 !102) +!104 = span !0 272 332 +!105 = span !0 377 384 +!106 = span !0 358 385 +!107 = fn_call_path_span !0 358 364 +!108 = (!106 !107) +!109 = span !6 70852 70856 +!110 = (!106 !107 !109) +!111 = span !6 70839 70883 +!112 = (!106 !107 !111) +!113 = span !6 70888 70894 +!114 = (!106 !107 !113) +!115 = span !0 333 386 +!116 = span !0 422 429 +!117 = span !0 422 435 +!118 = fn_call_path_span !0 430 433 +!119 = (!117 !118) +!120 = (!117 !118 !69) +!121 = (!117 !118 !71 !72) +!122 = (!117 !118 !71 !72 !74) +!123 = (!117 !118 !76) +!124 = span !0 437 444 +!125 = span !0 407 457 +!126 = span !0 464 476 +!127 = span !0 480 492 +!128 = span !0 464 492 +!129 = span !0 519 526 +!130 = span !0 519 550 +!131 = fn_call_path_span !0 527 533 +!132 = (!130 !131 !90 !91 !92) +!133 = (!130 !131 !90 !91 !92) +!134 = span !0 495 551 +!135 = span !0 624 628 +!136 = span !0 629 630 +!137 = span !0 596 631 +!138 = fn_call_path_span !0 596 623 +!139 = (!137 !138) +!140 = span !101 4156 4157 +!141 = (!137 !138 !140) +!142 = span !0 572 632 +!143 = span !0 677 684 +!144 = span !0 658 685 +!145 = fn_call_path_span !0 658 664 +!146 = (!144 !145) +!147 = (!144 !145 !109) +!148 = (!144 !145 !111) +!149 = (!144 !145 !113) +!150 = span !0 633 686 +!151 = span !0 722 729 +!152 = span !0 722 735 +!153 = fn_call_path_span !0 730 733 +!154 = (!152 !153) +!155 = (!152 !153 !69) +!156 = (!152 !153 !71 !72) +!157 = (!152 !153 !71 !72 !74) +!158 = (!152 !153 !76) +!159 = span !0 737 744 +!160 = span !0 707 757 +!161 = span !0 764 776 +!162 = span !0 780 793 +!163 = span !0 764 793 +!164 = span !0 821 828 +!165 = span !0 821 853 +!166 = fn_call_path_span !0 829 835 +!167 = (!165 !166 !90 !91 !92) +!168 = (!165 !166 !90 !91 !92) +!169 = span !0 796 854 +!170 = span !0 929 933 +!171 = span !0 934 935 +!172 = span !0 900 936 +!173 = fn_call_path_span !0 900 928 +!174 = (!172 !173) +!175 = span !101 4359 4360 +!176 = (!172 !173 !175) +!177 = span !0 875 937 +!178 = span !0 983 990 +!179 = span !0 963 991 +!180 = fn_call_path_span !0 963 969 +!181 = (!179 !180) +!182 = (!179 !180 !109) +!183 = (!179 !180 !111) +!184 = (!179 !180 !113) +!185 = span !0 938 992 +!186 = span !0 1028 1035 +!187 = span !0 1028 1041 +!188 = fn_call_path_span !0 1036 1039 +!189 = (!187 !188) +!190 = (!187 !188 !69) +!191 = (!187 !188 !71 !72) +!192 = (!187 !188 !71 !72 !74) +!193 = (!187 !188 !76) +!194 = span !0 1043 1050 +!195 = span !0 1013 1063 +!196 = span !0 1070 1082 +!197 = span !0 1086 1099 +!198 = span !0 1070 1099 +!199 = span !0 1127 1134 +!200 = span !0 1127 1159 +!201 = fn_call_path_span !0 1135 1141 +!202 = (!200 !201 !90 !91 !92) +!203 = (!200 !201 !90 !91 !92) +!204 = span !0 1102 1160 +!205 = span !0 1235 1239 +!206 = span !0 1240 1241 +!207 = span !0 1206 1242 +!208 = fn_call_path_span !0 1206 1234 +!209 = (!207 !208) +!210 = span !101 4458 4459 +!211 = (!207 !208 !210) +!212 = span !0 1181 1243 +!213 = span !0 1289 1296 +!214 = span !0 1269 1297 +!215 = fn_call_path_span !0 1269 1275 +!216 = (!214 !215) +!217 = (!214 !215 !109) +!218 = (!214 !215 !111) +!219 = (!214 !215 !113) +!220 = span !0 1244 1298 +!221 = span !0 1334 1341 +!222 = span !0 1334 1347 +!223 = fn_call_path_span !0 1342 1345 +!224 = (!222 !223) +!225 = (!222 !223 !69) +!226 = (!222 !223 !71 !72) +!227 = (!222 !223 !71 !72 !74) +!228 = (!222 !223 !76) +!229 = span !0 1349 1356 +!230 = span !0 1319 1369 +!231 = span !0 1376 1388 +!232 = span !0 1392 1405 +!233 = span !0 1376 1405 +!234 = span !0 1433 1440 +!235 = span !0 1433 1465 +!236 = fn_call_path_span !0 1441 1447 +!237 = (!235 !236 !90 !91 !92) +!238 = (!235 !236 !90 !91 !92) +!239 = span !0 1408 1466 +!240 = span !0 1541 1545 +!241 = span !0 1546 1547 +!242 = span !0 1512 1548 +!243 = fn_call_path_span !0 1512 1540 +!244 = (!242 !243) +!245 = span !101 4557 4558 +!246 = (!242 !243 !245) +!247 = span !0 1487 1549 +!248 = span !0 1595 1602 +!249 = span !0 1575 1603 +!250 = fn_call_path_span !0 1575 1581 +!251 = (!249 !250) +!252 = (!249 !250 !109) +!253 = (!249 !250 !111) +!254 = (!249 !250 !113) +!255 = span !0 1550 1604 +!256 = span !0 1640 1647 +!257 = span !0 1640 1653 +!258 = fn_call_path_span !0 1648 1651 +!259 = (!257 !258) +!260 = (!257 !258 !69) +!261 = (!257 !258 !71 !72) +!262 = (!257 !258 !71 !72 !74) +!263 = (!257 !258 !76) +!264 = span !0 1655 1662 +!265 = span !0 1625 1675 +!266 = span !0 1682 1694 +!267 = span !0 1698 1710 +!268 = span !0 1682 1710 +!269 = span !0 1737 1744 +!270 = span !0 1737 1768 +!271 = fn_call_path_span !0 1745 1751 +!272 = (!270 !271 !90 !91 !92) +!273 = (!270 !271 !90 !91 !92) +!274 = span !0 1713 1769 +!275 = span !0 1842 1846 +!276 = span !0 1847 1848 +!277 = span !0 1814 1849 +!278 = fn_call_path_span !0 1814 1841 +!279 = (!277 !278) +!280 = span !101 4257 4258 +!281 = (!277 !278 !280) +!282 = (!277 !278 !280) +!283 = (!277 !278 !280 !109) +!284 = (!277 !278 !280 !111) +!285 = (!277 !278 !280 !113) +!286 = span !101 4261 4262 +!287 = (!277 !278 !286) +!288 = span !0 1790 1850 +!289 = span !0 1895 1902 +!290 = span !0 1876 1903 +!291 = fn_call_path_span !0 1876 1882 +!292 = (!290 !291) +!293 = (!290 !291 !109) +!294 = (!290 !291 !111) +!295 = (!290 !291 !113) +!296 = span !0 1851 1904 +!297 = span !0 1940 1947 +!298 = span !0 1940 1953 +!299 = fn_call_path_span !0 1948 1951 +!300 = (!298 !299) +!301 = (!298 !299 !69) +!302 = (!298 !299 !71 !72) +!303 = (!298 !299 !71 !72 !74) +!304 = (!298 !299 !76) +!305 = span !0 1955 1962 +!306 = span !0 1925 1975 +!307 = span !0 1982 1994 +!308 = span !0 1998 2007 +!309 = span !0 1982 2007 +!310 = span !0 2030 2037 +!311 = span !0 2030 2057 +!312 = fn_call_path_span !0 2038 2044 +!313 = (!311 !312 !90 !91 !92) +!314 = (!311 !312 !90 !91 !92) +!315 = span !0 2010 2058 +!316 = span !0 2124 2128 +!317 = span !0 2129 2130 +!318 = span !0 2099 2131 +!319 = fn_call_path_span !0 2099 2123 +!320 = (!318 !319) +!321 = span !101 3540 3541 +!322 = (!318 !319 !321) +!323 = span !0 2079 2132 +!324 = span !0 2173 2180 +!325 = span !0 2158 2181 +!326 = fn_call_path_span !0 2158 2164 +!327 = (!325 !326) +!328 = (!325 !326 !109) +!329 = (!325 !326 !111) +!330 = (!325 !326 !113) +!331 = span !0 2133 2182 +!332 = span !0 2218 2225 +!333 = span !0 2218 2231 +!334 = fn_call_path_span !0 2226 2229 +!335 = (!333 !334) +!336 = (!333 !334 !69) +!337 = (!333 !334 !71 !72) +!338 = (!333 !334 !71 !72 !74) +!339 = (!333 !334 !76) +!340 = span !0 2233 2240 +!341 = span !0 2203 2253 +!342 = span !0 2260 2272 +!343 = span !0 2276 2285 +!344 = span !0 2260 2285 +!345 = span !0 2308 2315 +!346 = span !0 2308 2335 +!347 = fn_call_path_span !0 2316 2322 +!348 = span !6 115442 115463 +!349 = fn_call_path_span !6 115442 115455 +!350 = span !6 72847 72866 +!351 = fn_call_path_span !6 72854 72858 +!352 = (!346 !347 !90 !91 !348 !349 !350 !351) +!353 = span !6 72881 72882 +!354 = span !6 72881 72892 +!355 = fn_call_path_span !6 72881 72892 +!356 = (!346 !347 !90 !91 !348 !349 !354 !355) +!357 = span !6 72886 72891 +!358 = (!346 !347 !90 !91 !348 !349 !354) +!359 = span !6 72905 72906 +!360 = span !6 72905 72915 +!361 = fn_call_path_span !6 72905 72915 +!362 = (!346 !347 !90 !91 !348 !349 !360 !361) +!363 = span !6 72910 72914 +!364 = (!346 !347 !90 !91 !348 !349 !360) +!365 = span !6 72942 72943 +!366 = span !6 72933 72944 +!367 = (!346 !347 !90 !91 !348 !349 !366) +!368 = (!346 !347 !90 !91 !92) +!369 = (!346 !347 !90 !91 !92) +!370 = (!346 !347 !90 !91 !92) +!371 = span !0 2288 2336 +!372 = span !0 2402 2406 +!373 = span !0 2407 2408 +!374 = span !0 2436 2459 +!375 = fn_call_path_span !0 2436 2442 +!376 = (!374 !375 !111) +!377 = (!374 !375 !113) +!378 = span !0 2411 2460 +!379 = span !0 2496 2503 +!380 = span !0 2496 2509 +!381 = fn_call_path_span !0 2504 2507 +!382 = (!380 !381) +!383 = (!380 !381 !69) +!384 = (!380 !381 !71 !72) +!385 = (!380 !381 !71 !72 !74) +!386 = (!380 !381 !76) +!387 = span !0 2511 2518 +!388 = span !0 2481 2531 +!389 = span !0 2538 2550 +!390 = span !0 2554 2567 +!391 = span !0 2538 2567 +!392 = span !0 2593 2600 +!393 = span !0 2593 2623 +!394 = fn_call_path_span !0 2601 2607 +!395 = (!393 !394 !90 !91 !92) +!396 = (!393 !394 !90 !91 !92) +!397 = span !0 2570 2624 +!398 = span !0 2697 2701 +!399 = span !0 2702 2703 +!400 = span !0 2668 2704 +!401 = fn_call_path_span !0 2668 2696 +!402 = (!400 !401) +!403 = span !101 5528 5529 +!404 = (!400 !401 !403) +!405 = span !0 2645 2705 +!406 = span !0 2749 2756 +!407 = span !0 2731 2757 +!408 = fn_call_path_span !0 2731 2737 +!409 = (!407 !408) +!410 = (!407 !408 !109) +!411 = (!407 !408 !111) +!412 = (!407 !408 !113) +!413 = span !0 2706 2758 +!414 = span !0 2794 2801 +!415 = span !0 2794 2807 +!416 = fn_call_path_span !0 2802 2805 +!417 = (!415 !416) +!418 = (!415 !416 !69) +!419 = (!415 !416 !71 !72) +!420 = (!415 !416 !71 !72 !74) +!421 = (!415 !416 !76) +!422 = span !0 2809 2816 +!423 = span !0 2779 2829 +!424 = span !0 2836 2848 +!425 = span !0 2852 2869 +!426 = span !0 2836 2869 +!427 = span !0 2900 2907 +!428 = span !0 2900 2935 +!429 = fn_call_path_span !0 2908 2914 +!430 = (!428 !429 !90 !91 !92) +!431 = (!428 !429 !90 !91 !92) +!432 = span !0 2872 2936 +!433 = span !0 3018 3022 +!434 = span !0 3023 3024 +!435 = span !0 2985 3025 +!436 = fn_call_path_span !0 2985 3017 +!437 = (!435 !436) +!438 = span !101 5643 5644 +!439 = (!435 !436 !438) +!440 = span !0 2957 3026 +!441 = span !0 3075 3082 +!442 = span !0 3052 3083 +!443 = fn_call_path_span !0 3052 3058 +!444 = (!442 !443) +!445 = (!442 !443 !109) +!446 = (!442 !443 !111) +!447 = (!442 !443 !113) +!448 = span !0 3027 3084 +!449 = span !0 3120 3127 +!450 = span !0 3120 3133 +!451 = fn_call_path_span !0 3128 3131 +!452 = (!450 !451) +!453 = (!450 !451 !69) +!454 = (!450 !451 !71 !72) +!455 = (!450 !451 !71 !72 !74) +!456 = (!450 !451 !76) +!457 = span !0 3135 3142 +!458 = span !0 3105 3155 +!459 = span !0 3162 3174 +!460 = span !0 3178 3199 +!461 = span !0 3162 3199 +!462 = span !0 3235 3242 +!463 = span !0 3235 3275 +!464 = fn_call_path_span !0 3243 3249 +!465 = (!463 !464 !90 !91 !92) +!466 = (!463 !464 !90 !91 !92) +!467 = span !0 3202 3276 +!468 = span !0 3367 3371 +!469 = span !0 3372 3373 +!470 = span !0 3330 3374 +!471 = fn_call_path_span !0 3330 3366 +!472 = (!470 !471) +!473 = span !101 5780 5781 +!474 = (!470 !471 !473) +!475 = span !0 3297 3375 +!476 = span !0 3429 3436 +!477 = span !0 3401 3437 +!478 = fn_call_path_span !0 3401 3407 +!479 = (!477 !478) +!480 = (!477 !478 !109) +!481 = (!477 !478 !111) +!482 = (!477 !478 !113) +!483 = span !0 3376 3438 +!484 = span !0 3474 3481 +!485 = span !0 3474 3487 +!486 = fn_call_path_span !0 3482 3485 +!487 = (!485 !486) +!488 = (!485 !486 !69) +!489 = (!485 !486 !71 !72) +!490 = (!485 !486 !71 !72 !74) +!491 = (!485 !486 !76) +!492 = span !0 3489 3496 +!493 = span !0 3459 3509 +!494 = span !0 3516 3528 +!495 = span !0 3532 3542 +!496 = span !0 3516 3542 +!497 = span !0 3567 3574 +!498 = span !0 3567 3596 +!499 = fn_call_path_span !0 3575 3581 +!500 = span !6 73547 73579 +!501 = (!498 !499 !90 !91 !348 !349 !500) +!502 = span !6 73595 73599 +!503 = (!498 !499 !90 !91 !348 !349 !502) +!504 = span !6 73595 73605 +!505 = fn_call_path_span !6 73600 73603 +!506 = (!498 !499 !90 !91 !348 !349 !504 !505) +!507 = (!498 !499 !90 !91 !348 !349 !504 !505 !69) +!508 = (!498 !499 !90 !91 !348 !349 !504 !505 !71 !72) +!509 = (!498 !499 !90 !91 !348 !349 !504 !505 !71 !72 !74) +!510 = (!498 !499 !90 !91 !348 !349 !504 !505 !76) +!511 = (!498 !499 !90 !91 !92) +!512 = (!498 !499 !90 !91 !92) +!513 = span !0 3545 3597 +!514 = span !0 3666 3670 +!515 = span !0 3671 3672 +!516 = span !0 3640 3673 +!517 = fn_call_path_span !0 3640 3665 +!518 = (!516 !517) +!519 = span !101 3624 3625 +!520 = (!516 !517 !519) +!521 = span !0 3618 3674 +!522 = span !0 3717 3724 +!523 = span !0 3700 3725 +!524 = fn_call_path_span !0 3700 3706 +!525 = (!523 !524) +!526 = (!523 !524 !109) +!527 = (!523 !524 !111) +!528 = (!523 !524 !113) +!529 = span !0 3675 3726 +!530 = span !0 3762 3769 +!531 = span !0 3762 3775 +!532 = fn_call_path_span !0 3770 3773 +!533 = (!531 !532) +!534 = (!531 !532 !69) +!535 = (!531 !532 !71 !72) +!536 = (!531 !532 !71 !72 !74) +!537 = (!531 !532 !76) +!538 = span !0 3777 3784 +!539 = span !0 3747 3797 +!540 = span !0 3804 3816 +!541 = span !0 3820 3830 +!542 = span !0 3804 3830 +!543 = span !0 3855 3862 +!544 = span !0 3855 3884 +!545 = fn_call_path_span !0 3863 3869 +!546 = (!544 !545 !90 !91 !348 !349 !500) +!547 = (!544 !545 !90 !91 !348 !349 !502) +!548 = (!544 !545 !90 !91 !348 !349 !504 !505) +!549 = (!544 !545 !90 !91 !348 !349 !504 !505 !69) +!550 = (!544 !545 !90 !91 !348 !349 !504 !505 !71 !72) +!551 = (!544 !545 !90 !91 !348 !349 !504 !505 !71 !72 !74) +!552 = (!544 !545 !90 !91 !348 !349 !504 !505 !76) +!553 = (!544 !545 !90 !91 !92) +!554 = (!544 !545 !90 !91 !92) +!555 = span !0 3833 3885 +!556 = span !0 3954 3958 +!557 = span !0 3959 3960 +!558 = span !0 3928 3961 +!559 = fn_call_path_span !0 3928 3953 +!560 = (!558 !559) +!561 = span !101 3708 3709 +!562 = (!558 !559 !561) +!563 = span !0 3906 3962 +!564 = span !0 4005 4012 +!565 = span !0 3988 4013 +!566 = fn_call_path_span !0 3988 3994 +!567 = (!565 !566) +!568 = (!565 !566 !109) +!569 = (!565 !566 !111) +!570 = (!565 !566 !113) +!571 = span !0 3963 4014 +!572 = span !0 4050 4057 +!573 = span !0 4050 4063 +!574 = fn_call_path_span !0 4058 4061 +!575 = (!573 !574) +!576 = (!573 !574 !69) +!577 = (!573 !574 !71 !72) +!578 = (!573 !574 !71 !72 !74) +!579 = (!573 !574 !76) +!580 = span !0 4065 4072 +!581 = span !0 4035 4085 +!582 = span !0 4092 4104 +!583 = span !0 4108 4119 +!584 = span !0 4092 4119 +!585 = span !0 4145 4152 +!586 = span !0 4145 4175 +!587 = fn_call_path_span !0 4153 4159 +!588 = (!586 !587 !90 !91 !348 !349 !500) +!589 = (!586 !587 !90 !91 !348 !349 !502) +!590 = (!586 !587 !90 !91 !348 !349 !504 !505) +!591 = (!586 !587 !90 !91 !348 !349 !504 !505 !69) +!592 = (!586 !587 !90 !91 !348 !349 !504 !505 !71 !72) +!593 = (!586 !587 !90 !91 !348 !349 !504 !505 !71 !72 !74) +!594 = (!586 !587 !90 !91 !348 !349 !504 !505 !76) +!595 = (!586 !587 !90 !91 !92) +!596 = (!586 !587 !90 !91 !92) +!597 = span !0 4122 4176 +!598 = span !0 4247 4251 +!599 = span !0 4252 4253 +!600 = span !0 4220 4254 +!601 = fn_call_path_span !0 4220 4246 +!602 = (!600 !601) +!603 = span !101 3880 3881 +!604 = (!600 !601 !603) +!605 = span !0 4197 4255 +!606 = span !0 4299 4306 +!607 = span !0 4281 4307 +!608 = fn_call_path_span !0 4281 4287 +!609 = (!607 !608) +!610 = (!607 !608 !109) +!611 = (!607 !608 !111) +!612 = (!607 !608 !113) +!613 = span !0 4256 4308 +!614 = span !0 4344 4351 +!615 = span !0 4344 4357 +!616 = fn_call_path_span !0 4352 4355 +!617 = (!615 !616) +!618 = (!615 !616 !69) +!619 = (!615 !616 !71 !72) +!620 = (!615 !616 !71 !72 !74) +!621 = (!615 !616 !76) +!622 = span !0 4359 4366 +!623 = span !0 4329 4379 +!624 = span !0 4386 4398 +!625 = span !0 4402 4413 +!626 = span !0 4386 4413 +!627 = span !0 4439 4446 +!628 = span !0 4439 4469 +!629 = fn_call_path_span !0 4447 4453 +!630 = (!628 !629 !90 !91 !348 !349 !500) +!631 = (!628 !629 !90 !91 !348 !349 !502) +!632 = (!628 !629 !90 !91 !348 !349 !504 !505) +!633 = (!628 !629 !90 !91 !348 !349 !504 !505 !69) +!634 = (!628 !629 !90 !91 !348 !349 !504 !505 !71 !72) +!635 = (!628 !629 !90 !91 !348 !349 !504 !505 !71 !72 !74) +!636 = (!628 !629 !90 !91 !348 !349 !504 !505 !76) +!637 = (!628 !629 !90 !91 !92) +!638 = (!628 !629 !90 !91 !92) +!639 = span !0 4416 4470 +!640 = span !0 4541 4545 +!641 = span !0 4546 4547 +!642 = span !0 4514 4548 +!643 = fn_call_path_span !0 4514 4540 +!644 = (!642 !643) +!645 = span !101 3969 3970 +!646 = (!642 !643 !645) +!647 = span !0 4491 4549 +!648 = span !0 4593 4600 +!649 = span !0 4575 4601 +!650 = fn_call_path_span !0 4575 4581 +!651 = (!649 !650) +!652 = (!649 !650 !109) +!653 = (!649 !650 !111) +!654 = (!649 !650 !113) +!655 = span !0 4550 4602 +!656 = span !0 4638 4645 +!657 = span !0 4638 4651 +!658 = fn_call_path_span !0 4646 4649 +!659 = (!657 !658) +!660 = (!657 !658 !69) +!661 = (!657 !658 !71 !72) +!662 = (!657 !658 !71 !72 !74) +!663 = (!657 !658 !76) +!664 = span !0 4653 4660 +!665 = span !0 4623 4673 +!666 = span !0 4680 4692 +!667 = span !0 4696 4706 +!668 = span !0 4680 4706 +!669 = span !0 4731 4738 +!670 = span !0 4731 4760 +!671 = fn_call_path_span !0 4739 4745 +!672 = (!670 !671 !90 !91 !348 !349 !500) +!673 = (!670 !671 !90 !91 !348 !349 !502) +!674 = (!670 !671 !90 !91 !348 !349 !504 !505) +!675 = (!670 !671 !90 !91 !348 !349 !504 !505 !69) +!676 = (!670 !671 !90 !91 !348 !349 !504 !505 !71 !72) +!677 = (!670 !671 !90 !91 !348 !349 !504 !505 !71 !72 !74) +!678 = (!670 !671 !90 !91 !348 !349 !504 !505 !76) +!679 = (!670 !671 !90 !91 !92) +!680 = (!670 !671 !90 !91 !92) +!681 = span !0 4709 4761 +!682 = span !0 4830 4834 +!683 = span !0 4835 4836 +!684 = span !0 4804 4837 +!685 = fn_call_path_span !0 4804 4829 +!686 = (!684 !685) +!687 = span !101 3792 3793 +!688 = (!684 !685 !687) +!689 = span !0 4782 4838 +!690 = span !0 4881 4888 +!691 = span !0 4864 4889 +!692 = fn_call_path_span !0 4864 4870 +!693 = (!691 !692) +!694 = (!691 !692 !109) +!695 = (!691 !692 !111) +!696 = (!691 !692 !113) +!697 = span !0 4839 4890 +!698 = span !0 4926 4933 +!699 = span !0 4926 4939 +!700 = fn_call_path_span !0 4934 4937 +!701 = (!699 !700) +!702 = (!699 !700 !69) +!703 = (!699 !700 !71 !72) +!704 = (!699 !700 !71 !72 !74) +!705 = (!699 !700 !76) +!706 = span !0 4941 4948 +!707 = span !0 4911 4961 +!708 = span !0 4968 4980 +!709 = span !0 4984 4999 +!710 = span !0 4968 4999 +!711 = span !0 5025 5032 +!712 = span !0 5025 5055 +!713 = fn_call_path_span !0 5033 5039 +!714 = (!712 !713 !90 !91 !92) +!715 = (!712 !713 !90 !91 !92) +!716 = span !0 5002 5056 +!717 = span !0 5131 5135 +!718 = span !0 5136 5137 +!719 = span !0 5100 5138 +!720 = fn_call_path_span !0 5100 5130 +!721 = (!719 !720) +!722 = span !101 4730 4731 +!723 = (!719 !720 !722) +!724 = span !0 5077 5139 +!725 = span !0 5183 5190 +!726 = span !0 5165 5191 +!727 = fn_call_path_span !0 5165 5171 +!728 = (!726 !727) +!729 = (!726 !727 !109) +!730 = (!726 !727 !111) +!731 = (!726 !727 !113) +!732 = span !0 5140 5192 +!733 = span !0 5228 5235 +!734 = span !0 5228 5241 +!735 = fn_call_path_span !0 5236 5239 +!736 = (!734 !735) +!737 = (!734 !735 !69) +!738 = (!734 !735 !71 !72) +!739 = (!734 !735 !71 !72 !74) +!740 = (!734 !735 !76) +!741 = span !0 5243 5250 +!742 = span !0 5213 5263 +!743 = span !0 5270 5282 +!744 = span !0 5286 5305 +!745 = span !0 5270 5305 +!746 = span !0 5336 5343 +!747 = span !0 5336 5371 +!748 = fn_call_path_span !0 5344 5350 +!749 = (!747 !748 !90 !91 !92) +!750 = (!747 !748 !90 !91 !92) +!751 = span !0 5308 5372 +!752 = span !0 5456 5460 +!753 = span !0 5461 5462 +!754 = span !0 5421 5463 +!755 = fn_call_path_span !0 5421 5455 +!756 = (!754 !755) +!757 = span !101 5278 5279 +!758 = (!754 !755 !757) +!759 = span !0 5393 5464 +!760 = span !0 5513 5520 +!761 = span !0 5490 5521 +!762 = fn_call_path_span !0 5490 5496 +!763 = (!761 !762) +!764 = (!761 !762 !109) +!765 = (!761 !762 !111) +!766 = (!761 !762 !113) +!767 = span !0 5465 5522 +!768 = span !0 5558 5565 +!769 = span !0 5558 5571 +!770 = fn_call_path_span !0 5566 5569 +!771 = (!769 !770) +!772 = (!769 !770 !69) +!773 = (!769 !770 !71 !72) +!774 = (!769 !770 !71 !72 !74) +!775 = (!769 !770 !76) +!776 = span !0 5573 5580 +!777 = span !0 5543 5593 +!778 = span !0 5600 5612 +!779 = span !0 5616 5639 +!780 = span !0 5600 5639 +!781 = span !0 5675 5682 +!782 = span !0 5675 5715 +!783 = fn_call_path_span !0 5683 5689 +!784 = (!782 !783 !90 !91 !92) +!785 = (!782 !783 !90 !91 !92) +!786 = span !0 5642 5716 +!787 = span !0 5809 5813 +!788 = span !0 5814 5815 +!789 = span !0 5770 5816 +!790 = fn_call_path_span !0 5770 5808 +!791 = (!789 !790) +!792 = span !101 4936 4937 +!793 = (!789 !790 !792) +!794 = span !0 5737 5817 +!795 = span !0 5871 5878 +!796 = span !0 5843 5879 +!797 = fn_call_path_span !0 5843 5849 +!798 = (!796 !797) +!799 = (!796 !797 !109) +!800 = (!796 !797 !111) +!801 = (!796 !797 !113) +!802 = span !0 5818 5880 +!803 = span !0 5916 5923 +!804 = span !0 5916 5929 +!805 = fn_call_path_span !0 5924 5927 +!806 = (!804 !805) +!807 = (!804 !805 !69) +!808 = (!804 !805 !71 !72) +!809 = (!804 !805 !71 !72 !74) +!810 = (!804 !805 !76) +!811 = span !0 5931 5938 +!812 = span !0 5901 5951 +!813 = span !0 5958 5970 +!814 = span !0 5974 5986 +!815 = span !0 5958 5986 +!816 = span !0 6007 6032 +!817 = fn_call_path_span !0 6015 6021 +!818 = (!816 !817 !90 !91 !92) +!819 = (!816 !817 !90 !91 !92) +!820 = (!816 !817 !90 !91 !92) +!821 = span !0 5989 6033 +!822 = span !0 6124 6147 +!823 = span !0 6149 6150 +!824 = span !0 6109 6151 +!825 = span !0 6158 6170 +!826 = span !0 6174 6186 +!827 = span !0 6158 6186 +!828 = span !0 6211 6218 +!829 = span !0 6211 6240 +!830 = fn_call_path_span !0 6219 6225 +!831 = span !6 71904 71932 +!832 = fn_call_path_span !6 71911 71923 +!833 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832 !53) +!834 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832) +!835 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832 !56) +!836 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832 !59) +!837 = (!829 !830 !90 !91 !348 !349 !92) +!838 = (!829 !830 !90 !91 !348 !349 !92) +!839 = (!829 !830 !90 !91 !348 !349 !92) +!840 = (!829 !830 !90 !91 !92) +!841 = (!829 !830 !90 !91 !92) +!842 = span !0 6189 6241 +!843 = span !0 6312 6316 +!844 = span !0 6317 6318 +!845 = span !0 6284 6319 +!846 = fn_call_path_span !0 6284 6311 +!847 = (!845 !846) +!848 = (!845 !846 !722) +!849 = span !0 6262 6320 +!850 = span !0 6363 6370 +!851 = span !0 6346 6371 +!852 = fn_call_path_span !0 6346 6352 +!853 = (!851 !852) +!854 = (!851 !852 !109) +!855 = (!851 !852 !111) +!856 = (!851 !852 !113) +!857 = span !0 6321 6372 +!858 = span !0 6408 6415 +!859 = span !0 6408 6421 +!860 = fn_call_path_span !0 6416 6419 +!861 = (!859 !860) +!862 = (!859 !860 !69) +!863 = (!859 !860 !71 !72) +!864 = (!859 !860 !71 !72 !74) +!865 = (!859 !860 !76) +!866 = span !0 6423 6430 +!867 = span !0 6393 6443 +!868 = span !0 6450 6462 +!869 = span !0 6466 6478 +!870 = span !0 6450 6478 +!871 = span !0 6507 6514 +!872 = span !0 6507 6540 +!873 = fn_call_path_span !0 6515 6521 +!874 = (!872 !873 !90 !91 !92) +!875 = (!872 !873 !90 !91 !92) +!876 = span !0 6481 6541 +!877 = span !0 6616 6620 +!878 = span !0 6621 6622 +!879 = span !0 6588 6623 +!880 = fn_call_path_span !0 6588 6615 +!881 = (!879 !880) +!882 = (!879 !880 !757) +!883 = span !0 6562 6624 +!884 = span !0 6671 6678 +!885 = span !0 6650 6679 +!886 = fn_call_path_span !0 6650 6656 +!887 = (!885 !886) +!888 = (!885 !886 !109) +!889 = (!885 !886 !111) +!890 = (!885 !886 !113) +!891 = span !0 6625 6680 +!892 = span !0 6716 6723 +!893 = span !0 6716 6729 +!894 = fn_call_path_span !0 6724 6727 +!895 = (!893 !894) +!896 = (!893 !894 !69) +!897 = (!893 !894 !71 !72) +!898 = (!893 !894 !71 !72 !74) +!899 = (!893 !894 !76) +!900 = span !0 6731 6738 +!901 = span !0 6701 6751 +!902 = span !0 6758 6770 +!903 = span !0 6774 6786 +!904 = span !0 6758 6786 +!905 = span !0 6820 6827 +!906 = span !0 6820 6858 +!907 = fn_call_path_span !0 6828 6834 +!908 = (!906 !907 !90 !91 !92) +!909 = (!906 !907 !90 !91 !92) +!910 = span !0 6789 6859 +!911 = span !0 6939 6943 +!912 = span !0 6944 6945 +!913 = span !0 6911 6946 +!914 = fn_call_path_span !0 6911 6938 +!915 = (!913 !914) +!916 = (!913 !914 !792) +!917 = span !0 6880 6947 +!918 = span !0 6999 7006 +!919 = span !0 6973 7007 +!920 = fn_call_path_span !0 6973 6979 +!921 = (!919 !920) +!922 = (!919 !920 !109) +!923 = (!919 !920 !111) +!924 = (!919 !920 !113) +!925 = span !0 6948 7008 +!926 = span !0 7044 7051 +!927 = span !0 7044 7057 +!928 = fn_call_path_span !0 7052 7055 +!929 = (!927 !928) +!930 = (!927 !928 !69) +!931 = (!927 !928 !71 !72) +!932 = (!927 !928 !71 !72 !74) +!933 = (!927 !928 !76) +!934 = span !0 7059 7066 +!935 = span !0 7029 7079 +!936 = span !0 7086 7098 +!937 = span !0 7102 7114 +!938 = span !0 7086 7114 +!939 = span !0 7153 7160 +!940 = span !0 7153 7196 +!941 = fn_call_path_span !0 7161 7167 +!942 = (!940 !941 !90 !91 !92) +!943 = (!940 !941 !90 !91 !92) +!944 = span !0 7117 7197 +!945 = span !0 7282 7286 +!946 = span !0 7287 7288 +!947 = span !0 7254 7289 +!948 = fn_call_path_span !0 7254 7281 +!949 = (!947 !948) +!950 = span !101 5054 5055 +!951 = (!947 !948 !950) +!952 = span !0 7218 7290 +!953 = span !0 7347 7354 +!954 = span !0 7316 7355 +!955 = fn_call_path_span !0 7316 7322 +!956 = (!954 !955) +!957 = (!954 !955 !109) +!958 = (!954 !955 !111) +!959 = (!954 !955 !113) +!960 = span !0 7291 7356 +!961 = span !0 7392 7399 +!962 = span !0 7392 7405 +!963 = fn_call_path_span !0 7400 7403 +!964 = (!962 !963) +!965 = (!962 !963 !69) +!966 = (!962 !963 !71 !72) +!967 = (!962 !963 !71 !72 !74) +!968 = (!962 !963 !76) +!969 = span !0 7407 7414 +!970 = span !0 7377 7427 +!971 = span !0 7434 7446 +!972 = span !0 7450 7458 +!973 = span !0 7434 7458 +!974 = span !0 7480 7487 +!975 = span !0 7480 7506 +!976 = fn_call_path_span !0 7488 7494 +!977 = span !6 72535 72554 +!978 = fn_call_path_span !6 72542 72546 +!979 = (!975 !976 !90 !91 !348 !349 !977 !978) +!980 = span !6 72528 72555 +!981 = fn_call_path_span !6 72528 72534 +!982 = span !6 71980 72024 +!983 = (!975 !976 !90 !91 !348 !349 !980 !981 !982) +!984 = span !6 72580 72599 +!985 = fn_call_path_span !6 72587 72591 +!986 = (!975 !976 !90 !91 !348 !349 !984 !985) +!987 = span !6 72573 72600 +!988 = fn_call_path_span !6 72573 72579 +!989 = (!975 !976 !90 !91 !348 !349 !987 !988 !982) +!990 = span !6 72616 72617 +!991 = span !6 72611 72617 +!992 = fn_call_path_span !6 72613 72615 +!993 = (!975 !976 !90 !91 !348 !349 !991 !992) +!994 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/primitives.sw" +!995 = span !994 5415 5420 +!996 = (!975 !976 !90 !91 !348 !349 !991 !992) +!997 = span !6 72610 72622 +!998 = fn_call_path_span !6 72619 72620 +!999 = (!975 !976 !90 !91 !348 !349 !997 !998) +!1000 = (!975 !976 !90 !91 !92) +!1001 = (!975 !976 !90 !91 !92) +!1002 = (!975 !976 !90 !91 !92) +!1003 = span !0 7461 7507 +!1004 = span !0 7571 7575 +!1005 = span !0 7576 7577 +!1006 = span !0 7605 7627 +!1007 = fn_call_path_span !0 7605 7611 +!1008 = (!1006 !1007 !111) +!1009 = (!1006 !1007 !113) +!1010 = span !0 7580 7628 +!1011 = span !0 7664 7671 +!1012 = span !0 7664 7677 +!1013 = fn_call_path_span !0 7672 7675 +!1014 = (!1012 !1013) +!1015 = (!1012 !1013 !69) +!1016 = (!1012 !1013 !71 !72) +!1017 = (!1012 !1013 !71 !72 !74) +!1018 = (!1012 !1013 !76) +!1019 = span !0 7679 7686 +!1020 = span !0 7649 7699 +!1021 = span !0 7706 7718 +!1022 = span !0 7722 7731 +!1023 = span !0 7706 7731 +!1024 = span !0 7754 7761 +!1025 = span !0 7754 7781 +!1026 = fn_call_path_span !0 7762 7768 +!1027 = (!1025 !1026 !90 !91 !92) +!1028 = (!1025 !1026 !90 !91 !92) +!1029 = span !0 7734 7782 +!1030 = span !0 7848 7852 +!1031 = span !0 7853 7854 +!1032 = span !0 7823 7855 +!1033 = fn_call_path_span !0 7823 7847 +!1034 = (!1032 !1033) +!1035 = span !101 3461 3462 +!1036 = (!1032 !1033 !1035) +!1037 = span !0 7803 7856 +!1038 = span !0 7897 7904 +!1039 = span !0 7882 7905 +!1040 = fn_call_path_span !0 7882 7888 +!1041 = (!1039 !1040) +!1042 = (!1039 !1040 !109) +!1043 = (!1039 !1040 !111) +!1044 = (!1039 !1040 !113) +!1045 = span !0 7857 7906 +!1046 = span !0 7942 7949 +!1047 = span !0 7942 7955 +!1048 = fn_call_path_span !0 7950 7953 +!1049 = (!1047 !1048) +!1050 = (!1047 !1048 !69) +!1051 = (!1047 !1048 !71 !72) +!1052 = (!1047 !1048 !71 !72 !74) +!1053 = (!1047 !1048 !76) +!1054 = span !0 7957 7964 +!1055 = span !0 7927 7977 +!1056 = span !0 7984 7996 +!1057 = span !0 8000 8008 +!1058 = span !0 7984 8008 +!1059 = span !0 8030 8037 +!1060 = span !0 8030 8056 +!1061 = fn_call_path_span !0 8038 8044 +!1062 = (!1060 !1061 !90 !91 !348 !349) +!1063 = (!1060 !1061 !90 !91 !92) +!1064 = (!1060 !1061 !90 !91 !92) +!1065 = (!1060 !1061 !90 !91 !92) +!1066 = span !0 8011 8057 +!1067 = span !0 8121 8125 +!1068 = span !0 8126 8127 +!1069 = span !0 8155 8177 +!1070 = fn_call_path_span !0 8155 8161 +!1071 = (!1069 !1070 !111) +!1072 = (!1069 !1070 !113) +!1073 = span !0 8130 8178 +!1074 = span !0 8214 8221 +!1075 = span !0 8214 8227 +!1076 = fn_call_path_span !0 8222 8225 +!1077 = (!1075 !1076) +!1078 = (!1075 !1076 !69) +!1079 = (!1075 !1076 !71 !72) +!1080 = (!1075 !1076 !71 !72 !74) +!1081 = (!1075 !1076 !76) +!1082 = span !0 8229 8236 +!1083 = span !0 8199 8249 +!1084 = span !0 8256 8268 +!1085 = span !0 8272 8280 +!1086 = span !0 8256 8280 +!1087 = span !0 8302 8309 +!1088 = span !0 8302 8328 +!1089 = fn_call_path_span !0 8310 8316 +!1090 = (!1088 !1089 !90 !91 !348 !349 !831 !832 !53) +!1091 = (!1088 !1089 !90 !91 !348 !349 !831 !832) +!1092 = (!1088 !1089 !90 !91 !348 !349 !831 !832 !56) +!1093 = (!1088 !1089 !90 !91 !348 !349 !831 !832 !59) +!1094 = (!1088 !1089 !90 !91 !92) +!1095 = (!1088 !1089 !90 !91 !92) +!1096 = (!1088 !1089 !90 !91 !92) +!1097 = span !0 8283 8329 +!1098 = span !0 8393 8397 +!1099 = span !0 8398 8399 +!1100 = span !0 8427 8449 +!1101 = fn_call_path_span !0 8427 8433 +!1102 = (!1100 !1101 !111) +!1103 = (!1100 !1101 !113) +!1104 = span !0 8402 8450 +!1105 = span !0 8486 8493 +!1106 = span !0 8486 8499 +!1107 = fn_call_path_span !0 8494 8497 +!1108 = (!1106 !1107) +!1109 = (!1106 !1107 !69) +!1110 = (!1106 !1107 !71 !72) +!1111 = (!1106 !1107 !71 !72 !74) +!1112 = (!1106 !1107 !76) +!1113 = span !0 8501 8508 +!1114 = span !0 8471 8521 +!1115 = span !0 8528 8540 +!1116 = span !0 8544 8551 +!1117 = span !0 8528 8551 +!1118 = span !0 8572 8579 +!1119 = span !0 8572 8597 +!1120 = fn_call_path_span !0 8580 8586 +!1121 = span !6 72720 72739 +!1122 = fn_call_path_span !6 72727 72731 +!1123 = (!1119 !1120 !90 !91 !348 !349 !1121 !1122) +!1124 = (!1119 !1120 !90 !91 !92) +!1125 = (!1119 !1120 !90 !91 !92) +!1126 = (!1119 !1120 !90 !91 !92) +!1127 = span !0 8554 8598 +!1128 = span !0 8660 8664 +!1129 = span !0 8665 8666 +!1130 = span !0 8694 8715 +!1131 = fn_call_path_span !0 8694 8700 +!1132 = (!1130 !1131 !111) +!1133 = (!1130 !1131 !113) +!1134 = span !0 8669 8716 +!1135 = span !0 8752 8759 +!1136 = span !0 8752 8765 +!1137 = fn_call_path_span !0 8760 8763 +!1138 = (!1136 !1137) +!1139 = (!1136 !1137 !69) +!1140 = (!1136 !1137 !71 !72) +!1141 = (!1136 !1137 !71 !72 !74) +!1142 = (!1136 !1137 !76) +!1143 = span !0 8767 8774 +!1144 = span !0 8737 8787 +!1145 = span !0 8813 8816 +!1146 = span !0 8804 8817 +!1147 = span !6 3128 3132 +!1148 = span !6 3134 3139 +!1149 = span !6 3102 3321 +!1150 = fn_name_span !6 3109 3119 +!1151 = (!1149 !1150) +!1152 = span !6 3190 3207 +!1153 = span !6 3169 3248 +!1154 = span !6 3257 3300 +!1155 = span !6 3310 3315 +!1156 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/ops.sw" +!1157 = span !1156 35686 36058 +!1158 = fn_name_span !1156 35689 35691 +!1159 = (!1157 !1158) +!1160 = span !1156 35732 35736 +!1161 = span !1156 35746 35751 +!1162 = span !1156 35732 35757 +!1163 = fn_call_path_span !1156 35743 35745 +!1164 = span !1156 15555 15569 +!1165 = fn_call_path_span !1156 15560 15562 +!1166 = (!1162 !1163 !1164 !1165) +!1167 = span !1156 12573 12578 +!1168 = span !1156 15554 15576 +!1169 = fn_call_path_span !1156 15571 15574 +!1170 = (!1162 !1163 !1168 !1169) +!1171 = span !1156 35772 35777 +!1172 = span !1156 35822 35826 +!1173 = span !1156 35865 35870 +!1174 = span !1156 35901 35905 +!1175 = span !1156 35925 36042 +!1176 = span !1156 35987 36002 +!1177 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/str.sw" +!1178 = span !1177 281 403 +!1179 = fn_name_span !1177 288 291 +!1180 = (!1178 !1179) +!1181 = span !1177 337 341 +!1182 = span !1177 90 219 +!1183 = fn_name_span !1177 97 103 +!1184 = (!1182 !1183) +!1185 = span !1177 153 157 +!1186 = span !6 89760 89766 +!1187 = span !6 89738 90238 +!1188 = fn_name_span !6 89741 89751 +!1189 = inline "never" +!1190 = (!1187 !1188 !1189) +!1191 = span !6 89822 89842 +!1192 = span !6 89858 89864 +!1193 = (!1192 !111) +!1194 = (!1192 !113) +!1195 = span !6 89891 89904 +!1196 = span !6 89875 89905 +!1197 = span !6 89998 90003 +!1198 = span !6 90045 90046 +!1199 = (!1198 !111) +!1200 = (!1198 !113) +!1201 = span !6 90027 90028 +!1202 = span !6 90063 90068 +!1203 = fn_call_path_span !6 90065 90066 +!1204 = (!1202 !1203) +!1205 = span !6 90089 90090 +!1206 = (!1205 !111) +!1207 = (!1205 !113) +!1208 = span !6 90165 90185 +!1209 = fn_call_path_span !6 90172 90178 +!1210 = (!1208 !1209 !90 !91 !831 !832 !53) +!1211 = (!1208 !1209 !90 !91 !831 !832) +!1212 = (!1208 !1209 !90 !91 !831 !832 !56) +!1213 = (!1208 !1209 !90 !91 !831 !832 !59) +!1214 = span !6 90157 90185 +!1215 = span !6 90204 90205 +!1216 = span !6 90199 90205 +!1217 = fn_call_path_span !6 90201 90203 +!1218 = (!1216 !1217) +!1219 = span !6 4674 4678 +!1220 = span !6 4660 4805 +!1221 = fn_name_span !6 4663 4673 +!1222 = (!1220 !1221) +!1223 = span !6 4768 4774 +!1224 = span !6 87 114 +!1225 = span !6 4716 4799 +!1226 = span !6 160 260 +!1227 = fn_name_span !6 167 170 +!1228 = (!1226 !1227) +!1229 = span !6 191 254 +!1230 = span !6 499 591 +!1231 = fn_name_span !6 502 514 +!1232 = (!1230 !1231) +!1233 = span !6 573 577 +!1234 = span !6 20711 20939 +!1235 = fn_name_span !6 20714 20724 +!1236 = (!1234 !1235) +!1237 = span !6 20767 20791 +!1238 = span !6 20812 20813 +!1239 = span !6 20830 20835 +!1240 = fn_call_path_span !6 20832 20833 +!1241 = (!1239 !1240) +!1242 = span !6 20859 20863 +!1243 = span !6 20859 20866 +!1244 = span !6 20878 20884 +!1245 = span !6 20850 20885 +!1246 = span !6 20904 20905 +!1247 = span !6 20899 20905 +!1248 = fn_call_path_span !6 20901 20903 +!1249 = (!1247 !1248) +!1250 = span !6 20927 20933 +!1251 = span !68 3372 3452 +!1252 = fn_name_span !68 3379 3382 +!1253 = (!1251 !1252) +!1254 = span !68 3409 3425 +!1255 = fn_call_path_span !68 3409 3419 +!1256 = (!1254 !1255) +!1257 = (!1254 !1255 !74) +!1258 = (!1187 !1188 !1189) +!1259 = (!1192 !111) +!1260 = (!1192 !113) +!1261 = (!1198 !111) +!1262 = (!1198 !113) +!1263 = (!1202 !1203) +!1264 = (!1205 !111) +!1265 = (!1205 !113) +!1266 = (!1208 !1209 !90 !91 !831 !832 !53) +!1267 = (!1208 !1209 !90 !91 !831 !832) +!1268 = (!1208 !1209 !90 !91 !831 !832 !56) +!1269 = (!1208 !1209 !90 !91 !831 !832 !59) +!1270 = (!1216 !1217) +!1271 = (!1234 !1235) +!1272 = (!1239 !1240) +!1273 = (!1247 !1248) +!1274 = (!1187 !1188 !1189) +!1275 = (!1192 !111) +!1276 = (!1192 !113) +!1277 = (!1198 !111) +!1278 = (!1198 !113) +!1279 = (!1202 !1203) +!1280 = (!1205 !111) +!1281 = (!1205 !113) +!1282 = (!1208 !1209 !90 !91 !831 !832 !53) +!1283 = (!1208 !1209 !90 !91 !831 !832) +!1284 = (!1208 !1209 !90 !91 !831 !832 !56) +!1285 = (!1208 !1209 !90 !91 !831 !832 !59) +!1286 = (!1216 !1217) +!1287 = (!1234 !1235) +!1288 = (!1239 !1240) +!1289 = (!1247 !1248) +!1290 = (!1187 !1188 !1189) +!1291 = (!1192 !111) +!1292 = (!1192 !113) +!1293 = (!1198 !111) +!1294 = (!1198 !113) +!1295 = (!1202 !1203) +!1296 = (!1205 !111) +!1297 = (!1205 !113) +!1298 = (!1208 !1209 !90 !91 !831 !832 !53) +!1299 = (!1208 !1209 !90 !91 !831 !832) +!1300 = (!1208 !1209 !90 !91 !831 !832 !56) +!1301 = (!1208 !1209 !90 !91 !831 !832 !59) +!1302 = (!1216 !1217) +!1303 = (!1234 !1235) +!1304 = (!1239 !1240) +!1305 = (!1247 !1248) +!1306 = (!1187 !1188 !1189) +!1307 = (!1192 !111) +!1308 = (!1192 !113) +!1309 = (!1198 !111) +!1310 = (!1198 !113) +!1311 = (!1202 !1203) +!1312 = (!1205 !111) +!1313 = (!1205 !113) +!1314 = (!1208 !1209 !90 !91 !831 !832 !53) +!1315 = (!1208 !1209 !90 !91 !831 !832) +!1316 = (!1208 !1209 !90 !91 !831 !832 !56) +!1317 = (!1208 !1209 !90 !91 !831 !832 !59) +!1318 = (!1216 !1217) +!1319 = (!1234 !1235) +!1320 = (!1239 !1240) +!1321 = (!1247 !1248) +!1322 = (!1187 !1188 !1189) +!1323 = (!1192 !111) +!1324 = (!1192 !113) +!1325 = (!1198 !111) +!1326 = (!1198 !113) +!1327 = (!1202 !1203) +!1328 = (!1205 !111) +!1329 = (!1205 !113) +!1330 = (!1208 !1209 !90 !91 !831 !832 !53) +!1331 = (!1208 !1209 !90 !91 !831 !832) +!1332 = (!1208 !1209 !90 !91 !831 !832 !56) +!1333 = (!1208 !1209 !90 !91 !831 !832 !59) +!1334 = (!1216 !1217) +!1335 = (!1234 !1235) +!1336 = (!1239 !1240) +!1337 = (!1247 !1248) +!1338 = span !6 71602 71608 +!1339 = span !6 71580 71678 +!1340 = fn_name_span !6 71583 71593 +!1341 = (!1339 !1340) +!1342 = span !6 71642 71672 +!1343 = fn_call_path_span !6 71649 71662 +!1344 = (!1342 !1343 !53) +!1345 = (!1342 !1343) +!1346 = span !6 2972 3030 +!1347 = (!1342 !1343 !1346) +!1348 = span !6 3039 3079 +!1349 = (!1342 !1343 !1348) +!1350 = span !6 3089 3090 +!1351 = (!1342 !1343 !1350) +!1352 = span !6 4303 4448 +!1353 = fn_name_span !6 4306 4316 +!1354 = (!1352 !1353) +!1355 = span !6 4411 4417 +!1356 = span !6 4426 4430 +!1357 = span !6 4359 4442 +!1358 = span !6 3350 3354 +!1359 = span !6 3327 3871 +!1360 = fn_name_span !6 3334 3338 +!1361 = (!1359 !1360) +!1362 = span !6 3640 3733 +!1363 = span !6 3682 3695 +!1364 = span !6 3747 3786 +!1365 = span !6 4119 4123 +!1366 = span !6 4105 4250 +!1367 = fn_name_span !6 4108 4118 +!1368 = (!1366 !1367) +!1369 = span !6 4213 4219 +!1370 = span !6 4161 4244 +!1371 = span !0 174 180 +!1372 = span !0 152 359 +!1373 = fn_name_span !0 155 165 +!1374 = (!1372 !1373) +!1375 = span !0 245 267 +!1376 = fn_call_path_span !0 252 258 +!1377 = (!1375 !1376 !90 !91 !831 !832 !53) +!1378 = (!1375 !1376 !90 !91 !831 !832) +!1379 = (!1375 !1376 !90 !91 !831 !832 !56) +!1380 = (!1375 !1376 !90 !91 !831 !832 !59) +!1381 = span !0 285 286 +!1382 = span !0 285 318 +!1383 = fn_call_path_span !0 285 318 +!1384 = (!1382 !1383) +!1385 = span !101 274 293 +!1386 = span !0 296 316 +!1387 = fn_call_path_span !0 303 309 +!1388 = (!1386 !1387 !90 !91 !831 !832) +!1389 = (!1386 !1387 !90 !91 !831 !832 !56) +!1390 = (!1386 !1387 !90 !91 !831 !832 !59) +!1391 = span !0 335 336 +!1392 = span !0 326 337 +!1393 = span !0 152 492 +!1394 = (!1393 !1373) +!1395 = span !0 233 446 +!1396 = span !0 239 243 +!1397 = span !0 246 442 +!1398 = fn_call_path_span !0 246 442 +!1399 = (!1397 !1398) +!1400 = span !0 317 323 +!1401 = span !0 301 305 +!1402 = span !0 288 325 +!1403 = span !0 194 200 +!1404 = span !0 172 414 +!1405 = fn_name_span !0 175 185 +!1406 = (!1404 !1405) +!1407 = span !0 265 287 +!1408 = fn_call_path_span !0 272 278 +!1409 = (!1407 !1408 !90 !91 !831 !832 !53) +!1410 = (!1407 !1408 !90 !91 !831 !832) +!1411 = (!1407 !1408 !90 !91 !831 !832 !56) +!1412 = (!1407 !1408 !90 !91 !831 !832 !59) +!1413 = span !0 305 306 +!1414 = span !0 305 338 +!1415 = fn_call_path_span !0 305 338 +!1416 = (!1414 !1415) +!1417 = span !101 294 322 +!1418 = span !0 316 336 +!1419 = fn_call_path_span !0 323 329 +!1420 = (!1418 !1419 !90 !91 !831 !832) +!1421 = (!1418 !1419 !90 !91 !831 !832 !56) +!1422 = (!1418 !1419 !90 !91 !831 !832 !59) +!1423 = span !0 340 341 +!1424 = span !0 340 373 +!1425 = fn_call_path_span !0 340 373 +!1426 = (!1424 !1425) +!1427 = span !0 351 371 +!1428 = (!1427 !107 !90 !91 !831 !832) +!1429 = (!1427 !107 !90 !91 !831 !832 !56) +!1430 = (!1427 !107 !90 !91 !831 !832 !59) +!1431 = span !0 390 391 +!1432 = span !0 381 392 +!1433 = span !0 172 710 +!1434 = (!1433 !1405) +!1435 = span !0 253 664 +!1436 = span !0 259 263 +!1437 = span !0 266 462 +!1438 = fn_call_path_span !0 266 462 +!1439 = (!1437 !1438) +!1440 = span !0 337 343 +!1441 = span !0 321 325 +!1442 = span !0 308 345 +!1443 = span !0 464 660 +!1444 = fn_call_path_span !0 464 660 +!1445 = (!1443 !1444) +!1446 = span !0 535 541 +!1447 = span !0 519 523 +!1448 = span !0 506 543 +!1449 = span !0 214 220 +!1450 = span !0 192 469 +!1451 = fn_name_span !0 195 205 +!1452 = (!1450 !1451) +!1453 = span !0 285 307 +!1454 = fn_call_path_span !0 292 298 +!1455 = (!1453 !1454 !90 !91 !831 !832 !53) +!1456 = (!1453 !1454 !90 !91 !831 !832) +!1457 = (!1453 !1454 !90 !91 !831 !832 !56) +!1458 = (!1453 !1454 !90 !91 !831 !832 !59) +!1459 = span !0 325 326 +!1460 = span !0 325 358 +!1461 = fn_call_path_span !0 325 358 +!1462 = (!1460 !1461) +!1463 = span !101 323 360 +!1464 = span !0 336 356 +!1465 = fn_call_path_span !0 343 349 +!1466 = (!1464 !1465 !90 !91 !831 !832) +!1467 = (!1464 !1465 !90 !91 !831 !832 !56) +!1468 = (!1464 !1465 !90 !91 !831 !832 !59) +!1469 = span !0 360 361 +!1470 = span !0 360 393 +!1471 = fn_call_path_span !0 360 393 +!1472 = (!1470 !1471) +!1473 = span !0 371 391 +!1474 = fn_call_path_span !0 378 384 +!1475 = (!1473 !1474 !90 !91 !831 !832) +!1476 = (!1473 !1474 !90 !91 !831 !832 !56) +!1477 = (!1473 !1474 !90 !91 !831 !832 !59) +!1478 = span !0 395 396 +!1479 = span !0 395 428 +!1480 = fn_call_path_span !0 395 428 +!1481 = (!1479 !1480) +!1482 = span !0 406 426 +!1483 = fn_call_path_span !0 413 419 +!1484 = (!1482 !1483 !90 !91 !831 !832) +!1485 = (!1482 !1483 !90 !91 !831 !832 !56) +!1486 = (!1482 !1483 !90 !91 !831 !832 !59) +!1487 = span !0 445 446 +!1488 = span !0 436 447 +!1489 = span !0 192 928 +!1490 = (!1489 !1451) +!1491 = span !0 273 882 +!1492 = span !0 279 283 +!1493 = span !0 286 482 +!1494 = fn_call_path_span !0 286 482 +!1495 = (!1493 !1494) +!1496 = span !0 357 363 +!1497 = span !0 341 345 +!1498 = span !0 328 365 +!1499 = span !0 484 680 +!1500 = fn_call_path_span !0 484 680 +!1501 = (!1499 !1500) +!1502 = span !0 555 561 +!1503 = span !0 539 543 +!1504 = span !0 526 563 +!1505 = span !0 682 878 +!1506 = fn_call_path_span !0 682 878 +!1507 = (!1505 !1506) +!1508 = span !0 753 759 +!1509 = span !0 737 741 +!1510 = span !0 724 761 +!1511 = span !6 5645 5790 +!1512 = fn_name_span !6 5648 5658 +!1513 = (!1511 !1512) +!1514 = span !6 5753 5759 +!1515 = span !6 5768 5772 +!1516 = span !6 5701 5784 +!1517 = (!1511 !1512) +!1518 = (!1511 !1512) +!1519 = (!1511 !1512) +!1520 = (!1511 !1512) +!1521 = span !0 152 277 +!1522 = (!1521 !1373) +!1523 = span !0 236 256 +!1524 = fn_call_path_span !0 243 249 +!1525 = (!1523 !1524 !90 !91 !831 !832 !53) +!1526 = (!1523 !1524 !90 !91 !831 !832) +!1527 = (!1523 !1524 !90 !91 !831 !832 !56) +!1528 = (!1523 !1524 !90 !91 !831 !832 !59) +!1529 = span !0 226 259 +!1530 = span !0 152 305 +!1531 = (!1530 !1373) +!1532 = span !101 54 58 +!1533 = span !0 172 321 +!1534 = (!1533 !1405) +!1535 = span !0 256 276 +!1536 = fn_call_path_span !0 263 269 +!1537 = (!1535 !1536 !90 !91 !831 !832 !53) +!1538 = (!1535 !1536 !90 !91 !831 !832) +!1539 = (!1535 !1536 !90 !91 !831 !832 !56) +!1540 = (!1535 !1536 !90 !91 !831 !832 !59) +!1541 = span !0 280 300 +!1542 = fn_call_path_span !0 287 293 +!1543 = (!1541 !1542 !90 !91 !831 !832) +!1544 = (!1541 !1542 !90 !91 !831 !832 !56) +!1545 = (!1541 !1542 !90 !91 !831 !832 !59) +!1546 = span !0 246 303 +!1547 = span !0 192 425 +!1548 = (!1547 !1451) +!1549 = span !101 198 202 +!1550 = span !0 260 299 +!1551 = span !101 232 236 +!1552 = span !0 300 339 +!1553 = span !101 266 270 +!1554 = span !6 42917 43081 +!1555 = fn_name_span !6 42920 42930 +!1556 = (!1554 !1555) +!1557 = span !6 42991 42992 +!1558 = span !6 42973 43012 +!1559 = span !6 43039 43040 +!1560 = span !6 115798 115804 +!1561 = span !6 115776 115913 +!1562 = fn_name_span !6 115779 115789 +!1563 = (!1561 !1562) +!1564 = span !6 115839 115860 +!1565 = fn_call_path_span !6 115839 115852 +!1566 = (!1564 !1565 !831 !832 !53) +!1567 = (!1564 !1565 !831 !832) +!1568 = (!1564 !1565 !831 !832 !56) +!1569 = (!1564 !1565 !831 !832 !59) +!1570 = span !6 115862 115883 +!1571 = fn_call_path_span !6 115862 115875 +!1572 = (!1570 !1571 !831 !832) +!1573 = (!1570 !1571 !831 !832 !56) +!1574 = (!1570 !1571 !831 !832 !59) +!1575 = span !6 115885 115906 +!1576 = fn_call_path_span !6 115885 115898 +!1577 = (!1575 !1576 !831 !832) +!1578 = (!1575 !1576 !831 !832 !56) +!1579 = (!1575 !1576 !831 !832 !59) +!1580 = span !6 115838 115907 +!1581 = span !6 116066 116072 +!1582 = span !6 116044 116263 +!1583 = fn_name_span !6 116047 116057 +!1584 = (!1582 !1583) +!1585 = span !6 116120 116141 +!1586 = fn_call_path_span !6 116120 116133 +!1587 = (!1585 !1586 !831 !832 !53) +!1588 = (!1585 !1586 !831 !832) +!1589 = (!1585 !1586 !831 !832 !56) +!1590 = (!1585 !1586 !831 !832 !59) +!1591 = span !6 116155 116176 +!1592 = fn_call_path_span !6 116155 116168 +!1593 = (!1591 !1592 !831 !832) +!1594 = (!1591 !1592 !831 !832 !56) +!1595 = (!1591 !1592 !831 !832 !59) +!1596 = span !6 116190 116211 +!1597 = fn_call_path_span !6 116190 116203 +!1598 = (!1596 !1597 !831 !832) +!1599 = (!1596 !1597 !831 !832 !56) +!1600 = (!1596 !1597 !831 !832 !59) +!1601 = span !6 116225 116246 +!1602 = fn_call_path_span !6 116225 116238 +!1603 = (!1601 !1602 !831 !832) +!1604 = (!1601 !1602 !831 !832 !56) +!1605 = (!1601 !1602 !831 !832 !59) +!1606 = span !6 116106 116257 +!1607 = span !6 43531 43791 +!1608 = fn_name_span !6 43534 43544 +!1609 = (!1607 !1608) +!1610 = span !6 43605 43606 +!1611 = span !6 43587 43626 +!1612 = span !6 43653 43654 +!1613 = span !6 43635 43674 +!1614 = span !6 43701 43702 +!1615 = span !6 43683 43722 +!1616 = span !6 43749 43750 +!1617 = span !6 5030 5034 +!1618 = span !6 5016 5161 +!1619 = fn_name_span !6 5019 5029 +!1620 = (!1618 !1619) +!1621 = span !6 5124 5130 +!1622 = span !6 5072 5155 +!1623 = span !6 71734 71740 +!1624 = span !6 71712 71810 +!1625 = fn_name_span !6 71715 71725 +!1626 = (!1624 !1625) +!1627 = span !6 71774 71804 +!1628 = fn_call_path_span !6 71781 71794 +!1629 = (!1627 !1628 !53) +!1630 = (!1627 !1628) +!1631 = (!1627 !1628 !1346) +!1632 = (!1627 !1628 !1348) +!1633 = (!1627 !1628 !1350) +!1634 = span !6 4482 4627 +!1635 = fn_name_span !6 4485 4495 +!1636 = (!1634 !1635) +!1637 = span !6 4590 4596 +!1638 = span !6 4605 4609 +!1639 = span !6 4538 4621 +!1640 = span !6 72165 72171 +!1641 = span !6 72143 72426 +!1642 = fn_name_span !6 72146 72156 +!1643 = (!1641 !1642) +!1644 = span !6 72219 72238 +!1645 = fn_call_path_span !6 72226 72230 +!1646 = (!1644 !1645) +!1647 = span !6 72212 72239 +!1648 = fn_call_path_span !6 72212 72218 +!1649 = (!1647 !1648 !982) +!1650 = span !6 72264 72283 +!1651 = fn_call_path_span !6 72271 72275 +!1652 = (!1650 !1651) +!1653 = span !6 72257 72284 +!1654 = fn_call_path_span !6 72257 72263 +!1655 = (!1653 !1654 !982) +!1656 = span !6 72309 72328 +!1657 = fn_call_path_span !6 72316 72320 +!1658 = (!1656 !1657) +!1659 = span !6 72302 72329 +!1660 = fn_call_path_span !6 72302 72308 +!1661 = (!1659 !1660 !982) +!1662 = span !6 72354 72373 +!1663 = fn_call_path_span !6 72361 72365 +!1664 = (!1662 !1663) +!1665 = span !6 72347 72374 +!1666 = fn_call_path_span !6 72347 72353 +!1667 = (!1665 !1666 !982) +!1668 = span !6 72390 72392 +!1669 = span !6 72385 72392 +!1670 = fn_call_path_span !6 72387 72389 +!1671 = (!1669 !1670) +!1672 = span !994 3962 3972 +!1673 = span !6 72402 72404 +!1674 = span !6 72397 72404 +!1675 = fn_call_path_span !6 72399 72401 +!1676 = (!1674 !1675) +!1677 = span !6 72384 72405 +!1678 = fn_call_path_span !6 72394 72395 +!1679 = (!1677 !1678) +!1680 = span !6 72414 72415 +!1681 = span !6 72409 72415 +!1682 = fn_call_path_span !6 72411 72413 +!1683 = (!1681 !1682) +!1684 = span !6 72384 72416 +!1685 = fn_call_path_span !6 72406 72407 +!1686 = (!1684 !1685) +!1687 = span !6 72384 72420 +!1688 = fn_call_path_span !6 72417 72418 +!1689 = (!1687 !1688) +!1690 = span !6 4852 4856 +!1691 = span !6 4838 4983 +!1692 = fn_name_span !6 4841 4851 +!1693 = (!1691 !1692) +!1694 = span !6 4946 4952 +!1695 = span !6 4894 4977 +!1696 = span !6 5207 5211 +!1697 = span !6 5193 5338 +!1698 = fn_name_span !6 5196 5206 +!1699 = (!1697 !1698) +!1700 = span !6 5301 5307 +!1701 = span !6 5249 5332 +!1702 = span !101 5843 5924 +!1703 = fn_name_span !101 5846 5861 +!1704 = decl_index 43420 +!1705 = (!1702 !1703 !1704) +!1706 = span !101 5894 5905 +!1707 = span !101 407 414 +!1708 = span !101 5915 5920 +!1709 = span !101 5878 5921 +!1710 = span !6 139161 139172 +!1711 = (!1709 !1710) +!1712 = span !6 139132 139174 +!1713 = (!1709 !1712) +!1714 = span !6 139209 139213 +!1715 = (!1709 !1714) +!1716 = span !6 139202 139214 +!1717 = fn_call_path_span !6 139202 139208 +!1718 = (!1709 !1716 !1717) +!1719 = (!1709 !1716 !1717 !109) +!1720 = span !6 70852 70882 +!1721 = fn_call_path_span !6 70857 70867 +!1722 = (!1709 !1716 !1717 !1720 !1721) +!1723 = (!1709 !1716 !1717 !1720 !1721) +!1724 = span !6 42787 42791 +!1725 = (!1709 !1716 !1717 !1720 !1721 !1724) +!1726 = span !6 42792 42793 +!1727 = (!1709 !1716 !1717 !1720 !1721 !1726) +!1728 = (!1709 !1716 !1717 !1720 !1721) +!1729 = span !6 42805 42811 +!1730 = (!1709 !1716 !1717 !1720 !1721 !1729) +!1731 = span !6 42774 42813 +!1732 = (!1709 !1716 !1717 !1720 !1721 !1731) +!1733 = span !6 42822 42828 +!1734 = (!1709 !1716 !1717 !1720 !1721 !1733) +!1735 = (!1709 !1716 !1717 !111) +!1736 = (!1709 !1716 !1717 !113) +!1737 = span !6 139179 139215 +!1738 = (!1709 !1737) +!1739 = span !6 139250 139261 +!1740 = (!1709 !1739) +!1741 = span !6 139278 139293 +!1742 = (!1709 !1741) +!1743 = span !6 139278 139299 +!1744 = fn_call_path_span !6 139294 139297 +!1745 = (!1709 !1743 !1744) +!1746 = (!1709 !1743 !1744 !69) +!1747 = (!1709 !1743 !1744 !71 !72) +!1748 = (!1709 !1743 !1744 !71 !72 !74) +!1749 = (!1709 !1743 !1744 !76) +!1750 = span !6 139271 139331 +!1751 = (!1709 !1750) +!1752 = span !6 139348 139364 +!1753 = (!1709 !1752) +!1754 = span !6 139348 139370 +!1755 = fn_call_path_span !6 139365 139368 +!1756 = (!1709 !1754 !1755) +!1757 = (!1709 !1754 !1755 !69) +!1758 = (!1709 !1754 !1755 !71 !72) +!1759 = (!1709 !1754 !1755 !71 !72 !74) +!1760 = (!1709 !1754 !1755 !76) +!1761 = span !6 139341 139402 +!1762 = (!1709 !1761) +!1763 = span !6 139240 139409 +!1764 = (!1709 !1763) +!1765 = (!1709 !1763) +!1766 = (!1709 !1763) +!1767 = (!1709 !1763) +!1768 = (!1709 !1763) +!1769 = (!1709 !1763) +!1770 = span !6 139220 139411 +!1771 = (!1709 !1770) +!1772 = span !6 139423 139426 +!1773 = (!1709 !1772 !111) +!1774 = (!1709 !1772 !113) +!1775 = span !6 139449 139455 +!1776 = (!1709 !1775) +!1777 = span !6 139449 139461 +!1778 = fn_call_path_span !6 139456 139459 +!1779 = (!1709 !1777 !1778) +!1780 = (!1709 !1777 !1778 !69) +!1781 = (!1709 !1777 !1778 !71 !72) +!1782 = (!1709 !1777 !1778 !71 !72 !74) +!1783 = (!1709 !1777 !1778 !76) +!1784 = span !6 139470 139478 +!1785 = (!1709 !1784) +!1786 = span !6 139433 139484 +!1787 = (!1709 !1786) +!1788 = span !6 139500 139534 +!1789 = (!1709 !1788) +!1790 = span !6 139594 139597 +!1791 = (!1709 !1790 !111) +!1792 = (!1709 !1790 !113) +!1793 = span !6 139621 139655 +!1794 = fn_call_path_span !6 139621 139645 +!1795 = span !6 735 755 +!1796 = (!1709 !1793 !1794 !1795) +!1797 = (!1709 !1793 !1794) +!1798 = (!1709 !1793 !1794 !1795) +!1799 = span !6 139604 139656 +!1800 = (!1709 !1799) +!1801 = span !6 139667 139670 +!1802 = (!1709 !1801 !111) +!1803 = (!1709 !1801 !113) +!1804 = span !6 139699 139705 +!1805 = (!1709 !1804) +!1806 = span !6 139685 139706 +!1807 = fn_call_path_span !6 139685 139698 +!1808 = (!1709 !1806 !1807 !350 !351) +!1809 = (!1709 !1806 !1807 !354 !355) +!1810 = (!1709 !1806 !1807 !354) +!1811 = (!1709 !1806 !1807 !360 !361) +!1812 = (!1709 !1806 !1807 !360) +!1813 = (!1709 !1806 !1807 !366) +!1814 = span !6 139718 139721 +!1815 = (!1709 !1814 !111) +!1816 = (!1709 !1814 !113) +!1817 = span !6 70770 70911 +!1818 = fn_name_span !6 70777 70783 +!1819 = (!1817 !1818) +!1820 = (!1720 !1721) +!1821 = span !6 5515 5521 +!1822 = (!1720 !1721 !1821) +!1823 = (!1720 !1721 !1224) +!1824 = span !6 5530 5534 +!1825 = (!1720 !1721 !1824) +!1826 = span !6 5463 5546 +!1827 = (!1720 !1721 !1826) +!1828 = (!1817 !1818) +!1829 = (!1720 !1721) +!1830 = span !6 43262 43263 +!1831 = (!1720 !1721 !1830) +!1832 = span !6 43244 43283 +!1833 = (!1720 !1721 !1832) +!1834 = span !6 43310 43311 +!1835 = (!1720 !1721 !1834) +!1836 = span !6 43292 43331 +!1837 = (!1720 !1721 !1836) +!1838 = span !6 43358 43359 +!1839 = (!1720 !1721 !1838) +!1840 = span !6 43340 43379 +!1841 = (!1720 !1721 !1840) +!1842 = span !101 5964 6037 +!1843 = fn_name_span !101 5967 5980 +!1844 = decl_index 43590 +!1845 = (!1842 !1843 !1844) +!1846 = span !101 6013 6024 +!1847 = span !101 479 484 +!1848 = span !101 6032 6033 +!1849 = span !101 5997 6034 +!1850 = (!1849 !1710) +!1851 = (!1849 !1712) +!1852 = (!1849 !1714) +!1853 = (!1849 !1716 !1717) +!1854 = (!1849 !1716 !1717 !109) +!1855 = (!1849 !1716 !1717 !1720 !1721) +!1856 = (!1849 !1716 !1717 !1720 !1721) +!1857 = (!1849 !1716 !1717 !1720 !1721 !1724) +!1858 = (!1849 !1716 !1717 !1720 !1721 !1726) +!1859 = (!1849 !1716 !1717 !1720 !1721) +!1860 = (!1849 !1716 !1717 !1720 !1721 !1729) +!1861 = (!1849 !1716 !1717 !1720 !1721 !1731) +!1862 = (!1849 !1716 !1717 !1720 !1721 !1733) +!1863 = (!1849 !1716 !1717 !111) +!1864 = (!1849 !1716 !1717 !113) +!1865 = (!1849 !1737) +!1866 = (!1849 !1739) +!1867 = (!1849 !1741) +!1868 = (!1849 !1743 !1744) +!1869 = (!1849 !1743 !1744 !69) +!1870 = (!1849 !1743 !1744 !71 !72) +!1871 = (!1849 !1743 !1744 !71 !72 !74) +!1872 = (!1849 !1743 !1744 !76) +!1873 = (!1849 !1750) +!1874 = (!1849 !1752) +!1875 = (!1849 !1754 !1755) +!1876 = (!1849 !1754 !1755 !69) +!1877 = (!1849 !1754 !1755 !71 !72) +!1878 = (!1849 !1754 !1755 !71 !72 !74) +!1879 = (!1849 !1754 !1755 !76) +!1880 = (!1849 !1761) +!1881 = (!1849 !1763) +!1882 = (!1849 !1763) +!1883 = (!1849 !1763) +!1884 = (!1849 !1763) +!1885 = (!1849 !1763) +!1886 = (!1849 !1763) +!1887 = (!1849 !1770) +!1888 = (!1849 !1772 !111) +!1889 = (!1849 !1772 !113) +!1890 = (!1849 !1775) +!1891 = (!1849 !1777 !1778) +!1892 = (!1849 !1777 !1778 !69) +!1893 = (!1849 !1777 !1778 !71 !72) +!1894 = (!1849 !1777 !1778 !71 !72 !74) +!1895 = (!1849 !1777 !1778 !76) +!1896 = (!1849 !1784) +!1897 = (!1849 !1786) +!1898 = (!1849 !1788) +!1899 = (!1849 !1790 !111) +!1900 = (!1849 !1790 !113) +!1901 = (!1849 !1793 !1794 !1795) +!1902 = (!1849 !1793 !1794) +!1903 = (!1849 !1793 !1794 !1795) +!1904 = (!1849 !1799) +!1905 = (!1849 !1801 !111) +!1906 = (!1849 !1801 !113) +!1907 = (!1849 !1804) +!1908 = (!1849 !1806 !1807 !1121 !1122) +!1909 = (!1849 !1814 !111) +!1910 = (!1849 !1814 !113) +!1911 = span !101 6076 6151 +!1912 = fn_name_span !101 6079 6093 +!1913 = decl_index 43768 +!1914 = (!1911 !1912 !1913) +!1915 = span !101 6126 6137 +!1916 = span !101 544 550 +!1917 = span !101 6146 6147 +!1918 = span !101 6110 6148 +!1919 = (!1918 !1710) +!1920 = (!1918 !1712) +!1921 = (!1918 !1714) +!1922 = (!1918 !1716 !1717) +!1923 = (!1918 !1716 !1717 !109) +!1924 = (!1918 !1716 !1717 !1720 !1721) +!1925 = (!1918 !1716 !1717 !1720 !1721) +!1926 = (!1918 !1716 !1717 !1720 !1721 !1724) +!1927 = (!1918 !1716 !1717 !1720 !1721 !1726) +!1928 = (!1918 !1716 !1717 !1720 !1721) +!1929 = (!1918 !1716 !1717 !1720 !1721 !1729) +!1930 = (!1918 !1716 !1717 !1720 !1721 !1731) +!1931 = (!1918 !1716 !1717 !1720 !1721 !1733) +!1932 = (!1918 !1716 !1717 !111) +!1933 = (!1918 !1716 !1717 !113) +!1934 = (!1918 !1737) +!1935 = (!1918 !1739) +!1936 = (!1918 !1741) +!1937 = (!1918 !1743 !1744) +!1938 = (!1918 !1743 !1744 !69) +!1939 = (!1918 !1743 !1744 !71 !72) +!1940 = (!1918 !1743 !1744 !71 !72 !74) +!1941 = (!1918 !1743 !1744 !76) +!1942 = (!1918 !1750) +!1943 = (!1918 !1752) +!1944 = (!1918 !1754 !1755) +!1945 = (!1918 !1754 !1755 !69) +!1946 = (!1918 !1754 !1755 !71 !72) +!1947 = (!1918 !1754 !1755 !71 !72 !74) +!1948 = (!1918 !1754 !1755 !76) +!1949 = (!1918 !1761) +!1950 = (!1918 !1763) +!1951 = (!1918 !1763) +!1952 = (!1918 !1763) +!1953 = (!1918 !1763) +!1954 = (!1918 !1763) +!1955 = (!1918 !1763) +!1956 = (!1918 !1770) +!1957 = (!1918 !1772 !111) +!1958 = (!1918 !1772 !113) +!1959 = (!1918 !1775) +!1960 = (!1918 !1777 !1778) +!1961 = (!1918 !1777 !1778 !69) +!1962 = (!1918 !1777 !1778 !71 !72) +!1963 = (!1918 !1777 !1778 !71 !72 !74) +!1964 = (!1918 !1777 !1778 !76) +!1965 = (!1918 !1784) +!1966 = (!1918 !1786) +!1967 = (!1918 !1788) +!1968 = (!1918 !1790 !111) +!1969 = (!1918 !1790 !113) +!1970 = (!1918 !1793 !1794 !1795) +!1971 = (!1918 !1793 !1794) +!1972 = (!1918 !1793 !1794 !1795) +!1973 = (!1918 !1799) +!1974 = (!1918 !1801 !111) +!1975 = (!1918 !1801 !113) +!1976 = (!1918 !1804) +!1977 = (!1918 !1806 !1807 !977 !978) +!1978 = (!1918 !1806 !1807 !984 !985) +!1979 = (!1918 !1814 !111) +!1980 = (!1918 !1814 !113) +!1981 = span !101 6191 6266 +!1982 = fn_name_span !101 6194 6208 +!1983 = decl_index 43960 +!1984 = (!1981 !1982 !1983) +!1985 = span !101 6241 6252 +!1986 = span !101 613 619 +!1987 = span !101 6261 6262 +!1988 = span !101 6225 6263 +!1989 = (!1988 !1710) +!1990 = (!1988 !1712) +!1991 = (!1988 !1714) +!1992 = (!1988 !1716 !1717) +!1993 = (!1988 !1716 !1717 !109) +!1994 = (!1988 !1716 !1717 !1720 !1721) +!1995 = (!1988 !1716 !1717 !1720 !1721) +!1996 = (!1988 !1716 !1717 !1720 !1721 !1724) +!1997 = (!1988 !1716 !1717 !1720 !1721 !1726) +!1998 = (!1988 !1716 !1717 !1720 !1721) +!1999 = (!1988 !1716 !1717 !1720 !1721 !1729) +!2000 = (!1988 !1716 !1717 !1720 !1721 !1731) +!2001 = (!1988 !1716 !1717 !1720 !1721 !1733) +!2002 = (!1988 !1716 !1717 !111) +!2003 = (!1988 !1716 !1717 !113) +!2004 = (!1988 !1737) +!2005 = (!1988 !1739) +!2006 = (!1988 !1741) +!2007 = (!1988 !1743 !1744) +!2008 = (!1988 !1743 !1744 !69) +!2009 = (!1988 !1743 !1744 !71 !72) +!2010 = (!1988 !1743 !1744 !71 !72 !74) +!2011 = (!1988 !1743 !1744 !76) +!2012 = (!1988 !1750) +!2013 = (!1988 !1752) +!2014 = (!1988 !1754 !1755) +!2015 = (!1988 !1754 !1755 !69) +!2016 = (!1988 !1754 !1755 !71 !72) +!2017 = (!1988 !1754 !1755 !71 !72 !74) +!2018 = (!1988 !1754 !1755 !76) +!2019 = (!1988 !1761) +!2020 = (!1988 !1763) +!2021 = (!1988 !1763) +!2022 = (!1988 !1763) +!2023 = (!1988 !1763) +!2024 = (!1988 !1763) +!2025 = (!1988 !1763) +!2026 = (!1988 !1770) +!2027 = (!1988 !1772 !111) +!2028 = (!1988 !1772 !113) +!2029 = (!1988 !1775) +!2030 = (!1988 !1777 !1778) +!2031 = (!1988 !1777 !1778 !69) +!2032 = (!1988 !1777 !1778 !71 !72) +!2033 = (!1988 !1777 !1778 !71 !72 !74) +!2034 = (!1988 !1777 !1778 !76) +!2035 = (!1988 !1784) +!2036 = (!1988 !1786) +!2037 = (!1988 !1788) +!2038 = (!1988 !1790 !111) +!2039 = (!1988 !1790 !113) +!2040 = (!1988 !1793 !1794 !1795) +!2041 = (!1988 !1793 !1794) +!2042 = (!1988 !1793 !1794 !1795) +!2043 = (!1988 !1799) +!2044 = (!1988 !1801 !111) +!2045 = (!1988 !1801 !113) +!2046 = (!1988 !1804) +!2047 = (!1988 !1806 !1807) +!2048 = (!1988 !1814 !111) +!2049 = (!1988 !1814 !113) +!2050 = span !101 6306 6381 +!2051 = fn_name_span !101 6309 6323 +!2052 = decl_index 44128 +!2053 = (!2050 !2051 !2052) +!2054 = span !101 6356 6367 +!2055 = span !101 682 688 +!2056 = span !101 6376 6377 +!2057 = span !101 6340 6378 +!2058 = (!2057 !1710) +!2059 = (!2057 !1712) +!2060 = (!2057 !1714) +!2061 = (!2057 !1716 !1717) +!2062 = (!2057 !1716 !1717 !109) +!2063 = (!2057 !1716 !1717 !111) +!2064 = (!2057 !1716 !1717 !113) +!2065 = (!2057 !1737) +!2066 = (!2057 !1739) +!2067 = (!2057 !1741) +!2068 = (!2057 !1743 !1744) +!2069 = (!2057 !1743 !1744 !69) +!2070 = (!2057 !1743 !1744 !71 !72) +!2071 = (!2057 !1743 !1744 !71 !72 !74) +!2072 = (!2057 !1743 !1744 !76) +!2073 = (!2057 !1750) +!2074 = (!2057 !1752) +!2075 = (!2057 !1754 !1755) +!2076 = (!2057 !1754 !1755 !69) +!2077 = (!2057 !1754 !1755 !71 !72) +!2078 = (!2057 !1754 !1755 !71 !72 !74) +!2079 = (!2057 !1754 !1755 !76) +!2080 = (!2057 !1761) +!2081 = (!2057 !1763) +!2082 = (!2057 !1763) +!2083 = (!2057 !1763) +!2084 = (!2057 !1763) +!2085 = (!2057 !1763) +!2086 = (!2057 !1763) +!2087 = (!2057 !1770) +!2088 = (!2057 !1772 !111) +!2089 = (!2057 !1772 !113) +!2090 = (!2057 !1775) +!2091 = (!2057 !1777 !1778) +!2092 = (!2057 !1777 !1778 !69) +!2093 = (!2057 !1777 !1778 !71 !72) +!2094 = (!2057 !1777 !1778 !71 !72 !74) +!2095 = (!2057 !1777 !1778 !76) +!2096 = (!2057 !1784) +!2097 = (!2057 !1786) +!2098 = (!2057 !1788) +!2099 = (!2057 !1790 !111) +!2100 = (!2057 !1790 !113) +!2101 = (!2057 !1793 !1794 !1795) +!2102 = (!2057 !1793 !1794) +!2103 = (!2057 !1793 !1794 !1795) +!2104 = (!2057 !1799) +!2105 = (!2057 !1801 !111) +!2106 = (!2057 !1801 !113) +!2107 = (!2057 !1804) +!2108 = (!2057 !1806 !1807 !831 !832 !53) +!2109 = (!2057 !1806 !1807 !831 !832) +!2110 = (!2057 !1806 !1807 !831 !832 !56) +!2111 = (!2057 !1806 !1807 !831 !832 !59) +!2112 = (!2057 !1814 !111) +!2113 = (!2057 !1814 !113) +!2114 = span !101 6422 6568 +!2115 = fn_name_span !101 6425 6440 +!2116 = decl_index 44296 +!2117 = (!2114 !2115 !2116) +!2118 = span !101 6473 6484 +!2119 = span !101 752 759 +!2120 = span !101 6457 6565 +!2121 = (!2120 !1710) +!2122 = (!2120 !1712) +!2123 = (!2120 !1714) +!2124 = (!2120 !1716 !1717) +!2125 = (!2120 !1716 !1717 !109) +!2126 = (!2120 !1716 !1717 !1720 !1721) +!2127 = (!2120 !1716 !1717 !1720 !1721) +!2128 = (!2120 !1716 !1717 !1720 !1721 !1724) +!2129 = (!2120 !1716 !1717 !1720 !1721 !1726) +!2130 = (!2120 !1716 !1717 !1720 !1721 !1729) +!2131 = (!2120 !1716 !1717 !1720 !1721 !1731) +!2132 = (!2120 !1716 !1717 !1720 !1721 !1733) +!2133 = (!2120 !1716 !1717 !111) +!2134 = (!2120 !1716 !1717 !113) +!2135 = (!2120 !1737) +!2136 = (!2120 !1739) +!2137 = (!2120 !1741) +!2138 = (!2120 !1743 !1744) +!2139 = (!2120 !1743 !1744 !69) +!2140 = (!2120 !1743 !1744 !71 !72) +!2141 = (!2120 !1743 !1744 !71 !72 !74) +!2142 = (!2120 !1743 !1744 !76) +!2143 = (!2120 !1750) +!2144 = (!2120 !1752) +!2145 = (!2120 !1754 !1755) +!2146 = (!2120 !1754 !1755 !69) +!2147 = (!2120 !1754 !1755 !71 !72) +!2148 = (!2120 !1754 !1755 !71 !72 !74) +!2149 = (!2120 !1754 !1755 !76) +!2150 = (!2120 !1761) +!2151 = (!2120 !1763) +!2152 = (!2120 !1763) +!2153 = (!2120 !1763) +!2154 = (!2120 !1763) +!2155 = (!2120 !1763) +!2156 = (!2120 !1763) +!2157 = (!2120 !1770) +!2158 = (!2120 !1772 !111) +!2159 = (!2120 !1772 !113) +!2160 = (!2120 !1775) +!2161 = (!2120 !1777 !1778) +!2162 = (!2120 !1777 !1778 !69) +!2163 = (!2120 !1777 !1778 !71 !72) +!2164 = (!2120 !1777 !1778 !71 !72 !74) +!2165 = (!2120 !1777 !1778 !76) +!2166 = (!2120 !1784) +!2167 = (!2120 !1786) +!2168 = (!2120 !1788) +!2169 = (!2120 !1790 !111) +!2170 = (!2120 !1790 !113) +!2171 = (!2120 !1793 !1794 !1795) +!2172 = (!2120 !1793 !1794) +!2173 = (!2120 !1793 !1794 !1795) +!2174 = (!2120 !1799) +!2175 = (!2120 !1801 !111) +!2176 = (!2120 !1801 !113) +!2177 = (!2120 !1804) +!2178 = span !6 139677 139707 +!2179 = (!2120 !2178) +!2180 = (!2120 !1814 !111) +!2181 = (!2120 !1814 !113) +!2182 = span !6 139728 139729 +!2183 = (!2120 !2182) +!2184 = span !101 6449 6566 +!2185 = span !101 6610 6752 +!2186 = fn_name_span !101 6613 6628 +!2187 = decl_index 44464 +!2188 = (!2185 !2186 !2187) +!2189 = span !101 6661 6672 +!2190 = span !101 826 833 +!2191 = span !101 6645 6749 +!2192 = (!2191 !1710) +!2193 = (!2191 !1712) +!2194 = (!2191 !1714) +!2195 = (!2191 !1716 !1717) +!2196 = (!2191 !1716 !1717 !109) +!2197 = (!2191 !1716 !1717 !1720 !1721) +!2198 = (!2191 !1716 !1717 !1720 !1721) +!2199 = (!2191 !1716 !1717 !1720 !1721 !1724) +!2200 = (!2191 !1716 !1717 !1720 !1721 !1726) +!2201 = (!2191 !1716 !1717 !1720 !1721 !1729) +!2202 = (!2191 !1716 !1717 !1720 !1721 !1731) +!2203 = (!2191 !1716 !1717 !1720 !1721 !1733) +!2204 = (!2191 !1716 !1717 !111) +!2205 = (!2191 !1716 !1717 !113) +!2206 = (!2191 !1737) +!2207 = (!2191 !1739) +!2208 = (!2191 !1741) +!2209 = (!2191 !1743 !1744) +!2210 = (!2191 !1743 !1744 !69) +!2211 = (!2191 !1743 !1744 !71 !72) +!2212 = (!2191 !1743 !1744 !71 !72 !74) +!2213 = (!2191 !1743 !1744 !76) +!2214 = (!2191 !1750) +!2215 = (!2191 !1752) +!2216 = (!2191 !1754 !1755) +!2217 = (!2191 !1754 !1755 !69) +!2218 = (!2191 !1754 !1755 !71 !72) +!2219 = (!2191 !1754 !1755 !71 !72 !74) +!2220 = (!2191 !1754 !1755 !76) +!2221 = (!2191 !1761) +!2222 = (!2191 !1763) +!2223 = (!2191 !1763) +!2224 = (!2191 !1763) +!2225 = (!2191 !1763) +!2226 = (!2191 !1763) +!2227 = (!2191 !1763) +!2228 = (!2191 !1770) +!2229 = (!2191 !1772 !111) +!2230 = (!2191 !1772 !113) +!2231 = (!2191 !1775) +!2232 = (!2191 !1777 !1778) +!2233 = (!2191 !1777 !1778 !69) +!2234 = (!2191 !1777 !1778 !71 !72) +!2235 = (!2191 !1777 !1778 !71 !72 !74) +!2236 = (!2191 !1777 !1778 !76) +!2237 = (!2191 !1784) +!2238 = (!2191 !1786) +!2239 = (!2191 !1788) +!2240 = (!2191 !1790 !111) +!2241 = (!2191 !1790 !113) +!2242 = (!2191 !1793 !1794 !1795) +!2243 = (!2191 !1793 !1794) +!2244 = (!2191 !1793 !1794 !1795) +!2245 = (!2191 !1799) +!2246 = (!2191 !1801 !111) +!2247 = (!2191 !1801 !113) +!2248 = (!2191 !1804) +!2249 = (!2191 !2178) +!2250 = (!2191 !1814 !111) +!2251 = (!2191 !1814 !113) +!2252 = (!2191 !2182) +!2253 = span !101 6637 6750 +!2254 = span !101 6794 6890 +!2255 = fn_name_span !101 6797 6813 +!2256 = decl_index 44638 +!2257 = (!2254 !2255 !2256) +!2258 = span !101 6846 6857 +!2259 = span !101 900 908 +!2260 = span !101 6830 6887 +!2261 = (!2260 !1710) +!2262 = (!2260 !1712) +!2263 = (!2260 !1714) +!2264 = (!2260 !1716 !1717) +!2265 = (!2260 !1716 !1717 !109) +!2266 = (!2260 !1716 !1717 !1720 !1721) +!2267 = (!2260 !1716 !1717 !1720 !1721) +!2268 = (!2260 !1716 !1717 !1720 !1721 !1724) +!2269 = (!2260 !1716 !1717 !1720 !1721 !1726) +!2270 = (!2260 !1716 !1717 !1720 !1721 !1729) +!2271 = (!2260 !1716 !1717 !1720 !1721 !1731) +!2272 = (!2260 !1716 !1717 !1720 !1721 !1733) +!2273 = (!2260 !1716 !1717 !111) +!2274 = (!2260 !1716 !1717 !113) +!2275 = (!2260 !1737) +!2276 = (!2260 !1739) +!2277 = (!2260 !1741) +!2278 = (!2260 !1743 !1744) +!2279 = (!2260 !1743 !1744 !69) +!2280 = (!2260 !1743 !1744 !71 !72) +!2281 = (!2260 !1743 !1744 !71 !72 !74) +!2282 = (!2260 !1743 !1744 !76) +!2283 = (!2260 !1750) +!2284 = (!2260 !1752) +!2285 = (!2260 !1754 !1755) +!2286 = (!2260 !1754 !1755 !69) +!2287 = (!2260 !1754 !1755 !71 !72) +!2288 = (!2260 !1754 !1755 !71 !72 !74) +!2289 = (!2260 !1754 !1755 !76) +!2290 = (!2260 !1761) +!2291 = (!2260 !1763) +!2292 = (!2260 !1763) +!2293 = (!2260 !1763) +!2294 = (!2260 !1763) +!2295 = (!2260 !1763) +!2296 = (!2260 !1763) +!2297 = (!2260 !1770) +!2298 = (!2260 !1772 !111) +!2299 = (!2260 !1772 !113) +!2300 = (!2260 !1775) +!2301 = (!2260 !1777 !1778) +!2302 = (!2260 !1777 !1778 !69) +!2303 = (!2260 !1777 !1778 !71 !72) +!2304 = (!2260 !1777 !1778 !71 !72 !74) +!2305 = (!2260 !1777 !1778 !76) +!2306 = (!2260 !1784) +!2307 = (!2260 !1786) +!2308 = (!2260 !1788) +!2309 = (!2260 !1790 !111) +!2310 = (!2260 !1790 !113) +!2311 = (!2260 !1793 !1794 !1795) +!2312 = (!2260 !1793 !1794) +!2313 = (!2260 !1793 !1794 !1795) +!2314 = (!2260 !1799) +!2315 = (!2260 !1801 !111) +!2316 = (!2260 !1801 !113) +!2317 = (!2260 !1804) +!2318 = (!2260 !1806 !1807 !500) +!2319 = (!2260 !1806 !1807 !502) +!2320 = (!2260 !1806 !1807 !504 !505) +!2321 = (!2260 !1806 !1807 !504 !505 !69) +!2322 = (!2260 !1806 !1807 !504 !505 !71 !72) +!2323 = (!2260 !1806 !1807 !504 !505 !71 !72 !74) +!2324 = (!2260 !1806 !1807 !504 !505 !76) +!2325 = (!2260 !2178) +!2326 = (!2260 !1814 !111) +!2327 = (!2260 !1814 !113) +!2328 = (!2260 !2182) +!2329 = span !101 6822 6888 +!2330 = span !101 6932 7029 +!2331 = fn_name_span !101 6935 6951 +!2332 = decl_index 44812 +!2333 = (!2330 !2331 !2332) +!2334 = span !101 6984 6995 +!2335 = span !101 979 987 +!2336 = span !101 6968 7026 +!2337 = (!2336 !1710) +!2338 = (!2336 !1712) +!2339 = (!2336 !1714) +!2340 = (!2336 !1716 !1717) +!2341 = (!2336 !1716 !1717 !109) +!2342 = (!2336 !1716 !1717 !1720 !1721) +!2343 = (!2336 !1716 !1717 !1720 !1721) +!2344 = (!2336 !1716 !1717 !1720 !1721 !1724) +!2345 = (!2336 !1716 !1717 !1720 !1721 !1726) +!2346 = (!2336 !1716 !1717 !1720 !1721 !1729) +!2347 = (!2336 !1716 !1717 !1720 !1721 !1731) +!2348 = (!2336 !1716 !1717 !1720 !1721 !1733) +!2349 = (!2336 !1716 !1717 !111) +!2350 = (!2336 !1716 !1717 !113) +!2351 = (!2336 !1737) +!2352 = (!2336 !1739) +!2353 = (!2336 !1741) +!2354 = (!2336 !1743 !1744) +!2355 = (!2336 !1743 !1744 !69) +!2356 = (!2336 !1743 !1744 !71 !72) +!2357 = (!2336 !1743 !1744 !71 !72 !74) +!2358 = (!2336 !1743 !1744 !76) +!2359 = (!2336 !1750) +!2360 = (!2336 !1752) +!2361 = (!2336 !1754 !1755) +!2362 = (!2336 !1754 !1755 !69) +!2363 = (!2336 !1754 !1755 !71 !72) +!2364 = (!2336 !1754 !1755 !71 !72 !74) +!2365 = (!2336 !1754 !1755 !76) +!2366 = (!2336 !1761) +!2367 = (!2336 !1763) +!2368 = (!2336 !1763) +!2369 = (!2336 !1763) +!2370 = (!2336 !1763) +!2371 = (!2336 !1763) +!2372 = (!2336 !1763) +!2373 = (!2336 !1770) +!2374 = (!2336 !1772 !111) +!2375 = (!2336 !1772 !113) +!2376 = (!2336 !1775) +!2377 = (!2336 !1777 !1778) +!2378 = (!2336 !1777 !1778 !69) +!2379 = (!2336 !1777 !1778 !71 !72) +!2380 = (!2336 !1777 !1778 !71 !72 !74) +!2381 = (!2336 !1777 !1778 !76) +!2382 = (!2336 !1784) +!2383 = (!2336 !1786) +!2384 = (!2336 !1788) +!2385 = (!2336 !1790 !111) +!2386 = (!2336 !1790 !113) +!2387 = (!2336 !1793 !1794 !1795) +!2388 = (!2336 !1793 !1794) +!2389 = (!2336 !1793 !1794 !1795) +!2390 = (!2336 !1799) +!2391 = (!2336 !1801 !111) +!2392 = (!2336 !1801 !113) +!2393 = (!2336 !1804) +!2394 = (!2336 !1806 !1807 !500) +!2395 = (!2336 !1806 !1807 !502) +!2396 = (!2336 !1806 !1807 !504 !505) +!2397 = (!2336 !1806 !1807 !504 !505 !69) +!2398 = (!2336 !1806 !1807 !504 !505 !71 !72) +!2399 = (!2336 !1806 !1807 !504 !505 !71 !72 !74) +!2400 = (!2336 !1806 !1807 !504 !505 !76) +!2401 = (!2336 !2178) +!2402 = (!2336 !1814 !111) +!2403 = (!2336 !1814 !113) +!2404 = (!2336 !2182) +!2405 = span !101 6960 7027 +!2406 = span !101 7071 7175 +!2407 = fn_name_span !101 7074 7090 +!2408 = decl_index 44986 +!2409 = (!2406 !2407 !2408) +!2410 = span !101 7123 7134 +!2411 = span !101 1058 1066 +!2412 = span !101 7107 7172 +!2413 = (!2412 !1710) +!2414 = (!2412 !1712) +!2415 = (!2412 !1714) +!2416 = (!2412 !1716 !1717) +!2417 = (!2412 !1716 !1717 !109) +!2418 = (!2412 !1716 !1717 !1720 !1721) +!2419 = (!2412 !1716 !1717 !1720 !1721) +!2420 = (!2412 !1716 !1717 !1720 !1721 !1724) +!2421 = (!2412 !1716 !1717 !1720 !1721 !1726) +!2422 = (!2412 !1716 !1717 !1720 !1721 !1729) +!2423 = (!2412 !1716 !1717 !1720 !1721 !1731) +!2424 = (!2412 !1716 !1717 !1720 !1721 !1733) +!2425 = (!2412 !1716 !1717 !111) +!2426 = (!2412 !1716 !1717 !113) +!2427 = (!2412 !1737) +!2428 = (!2412 !1739) +!2429 = (!2412 !1741) +!2430 = (!2412 !1743 !1744) +!2431 = (!2412 !1743 !1744 !69) +!2432 = (!2412 !1743 !1744 !71 !72) +!2433 = (!2412 !1743 !1744 !71 !72 !74) +!2434 = (!2412 !1743 !1744 !76) +!2435 = (!2412 !1750) +!2436 = (!2412 !1752) +!2437 = (!2412 !1754 !1755) +!2438 = (!2412 !1754 !1755 !69) +!2439 = (!2412 !1754 !1755 !71 !72) +!2440 = (!2412 !1754 !1755 !71 !72 !74) +!2441 = (!2412 !1754 !1755 !76) +!2442 = (!2412 !1761) +!2443 = (!2412 !1763) +!2444 = (!2412 !1763) +!2445 = (!2412 !1763) +!2446 = (!2412 !1763) +!2447 = (!2412 !1763) +!2448 = (!2412 !1763) +!2449 = (!2412 !1770) +!2450 = (!2412 !1772 !111) +!2451 = (!2412 !1772 !113) +!2452 = (!2412 !1775) +!2453 = (!2412 !1777 !1778) +!2454 = (!2412 !1777 !1778 !69) +!2455 = (!2412 !1777 !1778 !71 !72) +!2456 = (!2412 !1777 !1778 !71 !72 !74) +!2457 = (!2412 !1777 !1778 !76) +!2458 = (!2412 !1784) +!2459 = (!2412 !1786) +!2460 = (!2412 !1788) +!2461 = (!2412 !1790 !111) +!2462 = (!2412 !1790 !113) +!2463 = (!2412 !1793 !1794 !1795) +!2464 = (!2412 !1793 !1794) +!2465 = (!2412 !1793 !1794 !1795) +!2466 = (!2412 !1799) +!2467 = (!2412 !1801 !111) +!2468 = (!2412 !1801 !113) +!2469 = (!2412 !1804) +!2470 = (!2412 !1806 !1807 !500) +!2471 = (!2412 !1806 !1807 !502) +!2472 = (!2412 !1806 !1807 !504 !505) +!2473 = (!2412 !1806 !1807 !504 !505 !69) +!2474 = (!2412 !1806 !1807 !504 !505 !71 !72) +!2475 = (!2412 !1806 !1807 !504 !505 !71 !72 !74) +!2476 = (!2412 !1806 !1807 !504 !505 !76) +!2477 = (!2412 !2178) +!2478 = (!2412 !1814 !111) +!2479 = (!2412 !1814 !113) +!2480 = (!2412 !2182) +!2481 = span !101 7099 7173 +!2482 = span !101 7218 7332 +!2483 = fn_name_span !101 7221 7238 +!2484 = decl_index 45160 +!2485 = (!2482 !2483 !2484) +!2486 = span !101 7271 7282 +!2487 = span !101 1138 1147 +!2488 = span !101 7255 7329 +!2489 = (!2488 !1710) +!2490 = (!2488 !1712) +!2491 = (!2488 !1714) +!2492 = (!2488 !1716 !1717) +!2493 = (!2488 !1716 !1717 !109) +!2494 = (!2488 !1716 !1717 !1720 !1721) +!2495 = (!2488 !1716 !1717 !1720 !1721) +!2496 = (!2488 !1716 !1717 !1720 !1721 !1724) +!2497 = (!2488 !1716 !1717 !1720 !1721 !1726) +!2498 = (!2488 !1716 !1717 !1720 !1721 !1729) +!2499 = (!2488 !1716 !1717 !1720 !1721 !1731) +!2500 = (!2488 !1716 !1717 !1720 !1721 !1733) +!2501 = (!2488 !1716 !1717 !111) +!2502 = (!2488 !1716 !1717 !113) +!2503 = (!2488 !1737) +!2504 = (!2488 !1739) +!2505 = (!2488 !1741) +!2506 = (!2488 !1743 !1744) +!2507 = (!2488 !1743 !1744 !69) +!2508 = (!2488 !1743 !1744 !71 !72) +!2509 = (!2488 !1743 !1744 !71 !72 !74) +!2510 = (!2488 !1743 !1744 !76) +!2511 = (!2488 !1750) +!2512 = (!2488 !1752) +!2513 = (!2488 !1754 !1755) +!2514 = (!2488 !1754 !1755 !69) +!2515 = (!2488 !1754 !1755 !71 !72) +!2516 = (!2488 !1754 !1755 !71 !72 !74) +!2517 = (!2488 !1754 !1755 !76) +!2518 = (!2488 !1761) +!2519 = (!2488 !1763) +!2520 = (!2488 !1763) +!2521 = (!2488 !1763) +!2522 = (!2488 !1763) +!2523 = (!2488 !1763) +!2524 = (!2488 !1763) +!2525 = (!2488 !1770) +!2526 = (!2488 !1772 !111) +!2527 = (!2488 !1772 !113) +!2528 = (!2488 !1775) +!2529 = (!2488 !1777 !1778) +!2530 = (!2488 !1777 !1778 !69) +!2531 = (!2488 !1777 !1778 !71 !72) +!2532 = (!2488 !1777 !1778 !71 !72 !74) +!2533 = (!2488 !1777 !1778 !76) +!2534 = (!2488 !1784) +!2535 = (!2488 !1786) +!2536 = (!2488 !1788) +!2537 = (!2488 !1790 !111) +!2538 = (!2488 !1790 !113) +!2539 = (!2488 !1793 !1794 !1795) +!2540 = (!2488 !1793 !1794) +!2541 = (!2488 !1793 !1794 !1795) +!2542 = (!2488 !1799) +!2543 = (!2488 !1801 !111) +!2544 = (!2488 !1801 !113) +!2545 = (!2488 !1804) +!2546 = (!2488 !1806 !1807 !500) +!2547 = (!2488 !1806 !1807 !502) +!2548 = (!2488 !1806 !1807 !504 !505) +!2549 = (!2488 !1806 !1807 !504 !505 !69) +!2550 = (!2488 !1806 !1807 !504 !505 !71 !72) +!2551 = (!2488 !1806 !1807 !504 !505 !71 !72 !74) +!2552 = (!2488 !1806 !1807 !504 !505 !76) +!2553 = (!2488 !2178) +!2554 = (!2488 !1814 !111) +!2555 = (!2488 !1814 !113) +!2556 = (!2488 !2182) +!2557 = span !101 7247 7330 +!2558 = span !101 7376 7506 +!2559 = fn_name_span !101 7379 7396 +!2560 = decl_index 45334 +!2561 = (!2558 !2559 !2560) +!2562 = span !101 7429 7440 +!2563 = span !101 1222 1231 +!2564 = span !101 7413 7503 +!2565 = (!2564 !1710) +!2566 = (!2564 !1712) +!2567 = (!2564 !1714) +!2568 = (!2564 !1716 !1717) +!2569 = (!2564 !1716 !1717 !109) +!2570 = (!2564 !1716 !1717 !1720 !1721) +!2571 = (!2564 !1716 !1717 !1720 !1721) +!2572 = (!2564 !1716 !1717 !1720 !1721 !1724) +!2573 = (!2564 !1716 !1717 !1720 !1721 !1726) +!2574 = (!2564 !1716 !1717 !1720 !1721 !1729) +!2575 = (!2564 !1716 !1717 !1720 !1721 !1731) +!2576 = (!2564 !1716 !1717 !1720 !1721 !1733) +!2577 = (!2564 !1716 !1717 !111) +!2578 = (!2564 !1716 !1717 !113) +!2579 = (!2564 !1737) +!2580 = (!2564 !1739) +!2581 = (!2564 !1741) +!2582 = (!2564 !1743 !1744) +!2583 = (!2564 !1743 !1744 !69) +!2584 = (!2564 !1743 !1744 !71 !72) +!2585 = (!2564 !1743 !1744 !71 !72 !74) +!2586 = (!2564 !1743 !1744 !76) +!2587 = (!2564 !1750) +!2588 = (!2564 !1752) +!2589 = (!2564 !1754 !1755) +!2590 = (!2564 !1754 !1755 !69) +!2591 = (!2564 !1754 !1755 !71 !72) +!2592 = (!2564 !1754 !1755 !71 !72 !74) +!2593 = (!2564 !1754 !1755 !76) +!2594 = (!2564 !1761) +!2595 = (!2564 !1763) +!2596 = (!2564 !1763) +!2597 = (!2564 !1763) +!2598 = (!2564 !1763) +!2599 = (!2564 !1763) +!2600 = (!2564 !1763) +!2601 = (!2564 !1770) +!2602 = (!2564 !1772 !111) +!2603 = (!2564 !1772 !113) +!2604 = (!2564 !1775) +!2605 = (!2564 !1777 !1778) +!2606 = (!2564 !1777 !1778 !69) +!2607 = (!2564 !1777 !1778 !71 !72) +!2608 = (!2564 !1777 !1778 !71 !72 !74) +!2609 = (!2564 !1777 !1778 !76) +!2610 = (!2564 !1784) +!2611 = (!2564 !1786) +!2612 = (!2564 !1788) +!2613 = (!2564 !1790 !111) +!2614 = (!2564 !1790 !113) +!2615 = (!2564 !1793 !1794 !1795) +!2616 = (!2564 !1793 !1794) +!2617 = (!2564 !1793 !1794 !1795) +!2618 = (!2564 !1799) +!2619 = (!2564 !1801 !111) +!2620 = (!2564 !1801 !113) +!2621 = (!2564 !1804) +!2622 = (!2564 !1806 !1807 !500) +!2623 = (!2564 !1806 !1807 !502) +!2624 = (!2564 !1806 !1807 !504 !505) +!2625 = (!2564 !1806 !1807 !504 !505 !69) +!2626 = (!2564 !1806 !1807 !504 !505 !71 !72) +!2627 = (!2564 !1806 !1807 !504 !505 !71 !72 !74) +!2628 = (!2564 !1806 !1807 !504 !505 !76) +!2629 = (!2564 !2178) +!2630 = (!2564 !1814 !111) +!2631 = (!2564 !1814 !113) +!2632 = (!2564 !2182) +!2633 = span !101 7405 7504 +!2634 = span !101 7551 7635 +!2635 = fn_name_span !101 7554 7572 +!2636 = decl_index 45574 +!2637 = (!2634 !2635 !2636) +!2638 = span !101 7605 7616 +!2639 = span !101 1307 1317 +!2640 = span !101 7629 7631 +!2641 = span !101 7589 7632 +!2642 = (!2641 !1710) +!2643 = (!2641 !1712) +!2644 = (!2641 !1714) +!2645 = (!2641 !1716 !1717) +!2646 = (!2641 !1716 !1717 !109) +!2647 = (!2641 !1716 !1717 !1720 !1721) +!2648 = (!2641 !1716 !1717 !1720 !1721) +!2649 = (!2641 !1716 !1717 !1720 !1721 !1724) +!2650 = (!2641 !1716 !1717 !1720 !1721 !1726) +!2651 = (!2641 !1716 !1717 !1720 !1721 !1729) +!2652 = (!2641 !1716 !1717 !1720 !1721 !1731) +!2653 = (!2641 !1716 !1717 !1720 !1721 !1733) +!2654 = (!2641 !1716 !1717 !111) +!2655 = (!2641 !1716 !1717 !113) +!2656 = (!2641 !1737) +!2657 = (!2641 !1739) +!2658 = (!2641 !1741) +!2659 = (!2641 !1743 !1744) +!2660 = (!2641 !1743 !1744 !69) +!2661 = (!2641 !1743 !1744 !71 !72) +!2662 = (!2641 !1743 !1744 !71 !72 !74) +!2663 = (!2641 !1743 !1744 !76) +!2664 = (!2641 !1750) +!2665 = (!2641 !1752) +!2666 = (!2641 !1754 !1755) +!2667 = (!2641 !1754 !1755 !69) +!2668 = (!2641 !1754 !1755 !71 !72) +!2669 = (!2641 !1754 !1755 !71 !72 !74) +!2670 = (!2641 !1754 !1755 !76) +!2671 = (!2641 !1761) +!2672 = (!2641 !1763) +!2673 = (!2641 !1763) +!2674 = (!2641 !1763) +!2675 = (!2641 !1763) +!2676 = (!2641 !1763) +!2677 = (!2641 !1763) +!2678 = (!2641 !1770) +!2679 = (!2641 !1772 !111) +!2680 = (!2641 !1772 !113) +!2681 = (!2641 !1775) +!2682 = (!2641 !1777 !1778) +!2683 = (!2641 !1777 !1778 !69) +!2684 = (!2641 !1777 !1778 !71 !72) +!2685 = (!2641 !1777 !1778 !71 !72 !74) +!2686 = (!2641 !1777 !1778 !76) +!2687 = (!2641 !1784) +!2688 = (!2641 !1786) +!2689 = (!2641 !1788) +!2690 = (!2641 !1790 !111) +!2691 = (!2641 !1790 !113) +!2692 = (!2641 !1793 !1794 !1795) +!2693 = (!2641 !1793 !1794) +!2694 = (!2641 !1793 !1794 !1795) +!2695 = (!2641 !1799) +!2696 = (!2641 !1801 !111) +!2697 = (!2641 !1801 !113) +!2698 = (!2641 !1804) +!2699 = (!2641 !2178) +!2700 = (!2641 !1814 !111) +!2701 = (!2641 !1814 !113) +!2702 = (!2641 !2182) +!2703 = span !101 7581 7633 +!2704 = span !101 7681 7766 +!2705 = fn_name_span !101 7684 7702 +!2706 = decl_index 45814 +!2707 = (!2704 !2705 !2706) +!2708 = span !101 7735 7746 +!2709 = span !101 1396 1406 +!2710 = span !101 7759 7762 +!2711 = span !101 7760 7761 +!2712 = span !101 7719 7763 +!2713 = (!2712 !1710) +!2714 = (!2712 !1712) +!2715 = (!2712 !1714) +!2716 = (!2712 !1716 !1717) +!2717 = (!2712 !1716 !1717 !109) +!2718 = (!2712 !1716 !1717 !1720 !1721) +!2719 = (!2712 !1716 !1717 !1720 !1721) +!2720 = (!2712 !1716 !1717 !1720 !1721 !1724) +!2721 = (!2712 !1716 !1717 !1720 !1721 !1726) +!2722 = (!2712 !1716 !1717 !1720 !1721 !1729) +!2723 = (!2712 !1716 !1717 !1720 !1721 !1731) +!2724 = (!2712 !1716 !1717 !1720 !1721 !1733) +!2725 = (!2712 !1716 !1717 !111) +!2726 = (!2712 !1716 !1717 !113) +!2727 = (!2712 !1737) +!2728 = (!2712 !1739) +!2729 = (!2712 !1741) +!2730 = (!2712 !1743 !1744) +!2731 = (!2712 !1743 !1744 !69) +!2732 = (!2712 !1743 !1744 !71 !72) +!2733 = (!2712 !1743 !1744 !71 !72 !74) +!2734 = (!2712 !1743 !1744 !76) +!2735 = (!2712 !1750) +!2736 = (!2712 !1752) +!2737 = (!2712 !1754 !1755) +!2738 = (!2712 !1754 !1755 !69) +!2739 = (!2712 !1754 !1755 !71 !72) +!2740 = (!2712 !1754 !1755 !71 !72 !74) +!2741 = (!2712 !1754 !1755 !76) +!2742 = (!2712 !1761) +!2743 = (!2712 !1763) +!2744 = (!2712 !1763) +!2745 = (!2712 !1763) +!2746 = (!2712 !1763) +!2747 = (!2712 !1763) +!2748 = (!2712 !1763) +!2749 = (!2712 !1770) +!2750 = (!2712 !1772 !111) +!2751 = (!2712 !1772 !113) +!2752 = (!2712 !1775) +!2753 = (!2712 !1777 !1778) +!2754 = (!2712 !1777 !1778 !69) +!2755 = (!2712 !1777 !1778 !71 !72) +!2756 = (!2712 !1777 !1778 !71 !72 !74) +!2757 = (!2712 !1777 !1778 !76) +!2758 = (!2712 !1784) +!2759 = (!2712 !1786) +!2760 = (!2712 !1788) +!2761 = (!2712 !1790 !111) +!2762 = (!2712 !1790 !113) +!2763 = (!2712 !1793 !1794 !1795) +!2764 = (!2712 !1793 !1794) +!2765 = (!2712 !1793 !1794 !1795) +!2766 = (!2712 !1799) +!2767 = (!2712 !1801 !111) +!2768 = (!2712 !1801 !113) +!2769 = (!2712 !1804) +!2770 = (!2712 !2178) +!2771 = (!2712 !1814 !111) +!2772 = (!2712 !1814 !113) +!2773 = (!2712 !2182) +!2774 = span !101 7711 7764 +!2775 = span !101 7812 7918 +!2776 = fn_name_span !101 7815 7833 +!2777 = decl_index 46054 +!2778 = (!2775 !2776 !2777) +!2779 = span !101 7866 7877 +!2780 = span !101 1485 1495 +!2781 = span !101 7890 7914 +!2782 = span !101 7891 7892 +!2783 = span !101 7850 7915 +!2784 = (!2783 !1710) +!2785 = (!2783 !1712) +!2786 = (!2783 !1714) +!2787 = (!2783 !1716 !1717) +!2788 = (!2783 !1716 !1717 !109) +!2789 = (!2783 !1716 !1717 !1720 !1721) +!2790 = (!2783 !1716 !1717 !1720 !1721) +!2791 = (!2783 !1716 !1717 !1720 !1721 !1724) +!2792 = (!2783 !1716 !1717 !1720 !1721 !1726) +!2793 = (!2783 !1716 !1717 !1720 !1721 !1729) +!2794 = (!2783 !1716 !1717 !1720 !1721 !1731) +!2795 = (!2783 !1716 !1717 !1720 !1721 !1733) +!2796 = (!2783 !1716 !1717 !111) +!2797 = (!2783 !1716 !1717 !113) +!2798 = (!2783 !1737) +!2799 = (!2783 !1739) +!2800 = (!2783 !1741) +!2801 = (!2783 !1743 !1744) +!2802 = (!2783 !1743 !1744 !69) +!2803 = (!2783 !1743 !1744 !71 !72) +!2804 = (!2783 !1743 !1744 !71 !72 !74) +!2805 = (!2783 !1743 !1744 !76) +!2806 = (!2783 !1750) +!2807 = (!2783 !1752) +!2808 = (!2783 !1754 !1755) +!2809 = (!2783 !1754 !1755 !69) +!2810 = (!2783 !1754 !1755 !71 !72) +!2811 = (!2783 !1754 !1755 !71 !72 !74) +!2812 = (!2783 !1754 !1755 !76) +!2813 = (!2783 !1761) +!2814 = (!2783 !1763) +!2815 = (!2783 !1763) +!2816 = (!2783 !1763) +!2817 = (!2783 !1763) +!2818 = (!2783 !1763) +!2819 = (!2783 !1763) +!2820 = (!2783 !1770) +!2821 = (!2783 !1772 !111) +!2822 = (!2783 !1772 !113) +!2823 = (!2783 !1775) +!2824 = (!2783 !1777 !1778) +!2825 = (!2783 !1777 !1778 !69) +!2826 = (!2783 !1777 !1778 !71 !72) +!2827 = (!2783 !1777 !1778 !71 !72 !74) +!2828 = (!2783 !1777 !1778 !76) +!2829 = (!2783 !1784) +!2830 = (!2783 !1786) +!2831 = (!2783 !1788) +!2832 = (!2783 !1790 !111) +!2833 = (!2783 !1790 !113) +!2834 = (!2783 !1793 !1794 !1795) +!2835 = (!2783 !1793 !1794) +!2836 = (!2783 !1793 !1794 !1795) +!2837 = (!2783 !1799) +!2838 = (!2783 !1801 !111) +!2839 = (!2783 !1801 !113) +!2840 = (!2783 !1804) +!2841 = (!2783 !2178) +!2842 = (!2783 !1814 !111) +!2843 = (!2783 !1814 !113) +!2844 = (!2783 !2182) +!2845 = span !101 7842 7916 +!2846 = span !101 7965 8097 +!2847 = fn_name_span !101 7968 7987 +!2848 = decl_index 46294 +!2849 = (!2846 !2847 !2848) +!2850 = span !101 8020 8031 +!2851 = span !101 1575 1586 +!2852 = span !101 8045 8093 +!2853 = span !101 8046 8047 +!2854 = span !101 8004 8094 +!2855 = (!2854 !1710) +!2856 = (!2854 !1712) +!2857 = (!2854 !1714) +!2858 = (!2854 !1716 !1717) +!2859 = (!2854 !1716 !1717 !109) +!2860 = (!2854 !1716 !1717 !1720 !1721) +!2861 = (!2854 !1716 !1717 !1720 !1721) +!2862 = (!2854 !1716 !1717 !1720 !1721 !1724) +!2863 = (!2854 !1716 !1717 !1720 !1721 !1726) +!2864 = (!2854 !1716 !1717 !1720 !1721 !1729) +!2865 = (!2854 !1716 !1717 !1720 !1721 !1731) +!2866 = (!2854 !1716 !1717 !1720 !1721 !1733) +!2867 = (!2854 !1716 !1717 !111) +!2868 = (!2854 !1716 !1717 !113) +!2869 = (!2854 !1737) +!2870 = (!2854 !1739) +!2871 = (!2854 !1741) +!2872 = (!2854 !1743 !1744) +!2873 = (!2854 !1743 !1744 !69) +!2874 = (!2854 !1743 !1744 !71 !72) +!2875 = (!2854 !1743 !1744 !71 !72 !74) +!2876 = (!2854 !1743 !1744 !76) +!2877 = (!2854 !1750) +!2878 = (!2854 !1752) +!2879 = (!2854 !1754 !1755) +!2880 = (!2854 !1754 !1755 !69) +!2881 = (!2854 !1754 !1755 !71 !72) +!2882 = (!2854 !1754 !1755 !71 !72 !74) +!2883 = (!2854 !1754 !1755 !76) +!2884 = (!2854 !1761) +!2885 = (!2854 !1763) +!2886 = (!2854 !1763) +!2887 = (!2854 !1763) +!2888 = (!2854 !1763) +!2889 = (!2854 !1763) +!2890 = (!2854 !1763) +!2891 = (!2854 !1770) +!2892 = (!2854 !1772 !111) +!2893 = (!2854 !1772 !113) +!2894 = (!2854 !1775) +!2895 = (!2854 !1777 !1778) +!2896 = (!2854 !1777 !1778 !69) +!2897 = (!2854 !1777 !1778 !71 !72) +!2898 = (!2854 !1777 !1778 !71 !72 !74) +!2899 = (!2854 !1777 !1778 !76) +!2900 = (!2854 !1784) +!2901 = (!2854 !1786) +!2902 = (!2854 !1788) +!2903 = (!2854 !1790 !111) +!2904 = (!2854 !1790 !113) +!2905 = (!2854 !1793 !1794 !1795) +!2906 = (!2854 !1793 !1794) +!2907 = (!2854 !1793 !1794 !1795) +!2908 = (!2854 !1799) +!2909 = (!2854 !1801 !111) +!2910 = (!2854 !1801 !113) +!2911 = (!2854 !1804) +!2912 = (!2854 !2178) +!2913 = (!2854 !1814 !111) +!2914 = (!2854 !1814 !113) +!2915 = (!2854 !2182) +!2916 = span !101 7996 8095 +!2917 = span !101 8145 8325 +!2918 = fn_name_span !101 8148 8167 +!2919 = decl_index 46534 +!2920 = (!2917 !2918 !2919) +!2921 = span !101 8200 8211 +!2922 = span !101 1669 1680 +!2923 = span !101 8225 8321 +!2924 = span !101 8226 8227 +!2925 = span !101 8184 8322 +!2926 = (!2925 !1710) +!2927 = (!2925 !1712) +!2928 = (!2925 !1714) +!2929 = (!2925 !1716 !1717) +!2930 = (!2925 !1716 !1717 !109) +!2931 = (!2925 !1716 !1717 !1720 !1721) +!2932 = (!2925 !1716 !1717 !1720 !1721) +!2933 = (!2925 !1716 !1717 !1720 !1721 !1724) +!2934 = (!2925 !1716 !1717 !1720 !1721 !1726) +!2935 = (!2925 !1716 !1717 !1720 !1721 !1729) +!2936 = (!2925 !1716 !1717 !1720 !1721 !1731) +!2937 = (!2925 !1716 !1717 !1720 !1721 !1733) +!2938 = (!2925 !1716 !1717 !111) +!2939 = (!2925 !1716 !1717 !113) +!2940 = (!2925 !1737) +!2941 = (!2925 !1739) +!2942 = (!2925 !1741) +!2943 = (!2925 !1743 !1744) +!2944 = (!2925 !1743 !1744 !69) +!2945 = (!2925 !1743 !1744 !71 !72) +!2946 = (!2925 !1743 !1744 !71 !72 !74) +!2947 = (!2925 !1743 !1744 !76) +!2948 = (!2925 !1750) +!2949 = (!2925 !1752) +!2950 = (!2925 !1754 !1755) +!2951 = (!2925 !1754 !1755 !69) +!2952 = (!2925 !1754 !1755 !71 !72) +!2953 = (!2925 !1754 !1755 !71 !72 !74) +!2954 = (!2925 !1754 !1755 !76) +!2955 = (!2925 !1761) +!2956 = (!2925 !1763) +!2957 = (!2925 !1763) +!2958 = (!2925 !1763) +!2959 = (!2925 !1763) +!2960 = (!2925 !1763) +!2961 = (!2925 !1763) +!2962 = (!2925 !1770) +!2963 = (!2925 !1772 !111) +!2964 = (!2925 !1772 !113) +!2965 = (!2925 !1775) +!2966 = (!2925 !1777 !1778) +!2967 = (!2925 !1777 !1778 !69) +!2968 = (!2925 !1777 !1778 !71 !72) +!2969 = (!2925 !1777 !1778 !71 !72 !74) +!2970 = (!2925 !1777 !1778 !76) +!2971 = (!2925 !1784) +!2972 = (!2925 !1786) +!2973 = (!2925 !1788) +!2974 = (!2925 !1790 !111) +!2975 = (!2925 !1790 !113) +!2976 = (!2925 !1793 !1794 !1795) +!2977 = (!2925 !1793 !1794) +!2978 = (!2925 !1793 !1794 !1795) +!2979 = (!2925 !1799) +!2980 = (!2925 !1801 !111) +!2981 = (!2925 !1801 !113) +!2982 = (!2925 !1804) +!2983 = (!2925 !2178) +!2984 = (!2925 !1814 !111) +!2985 = (!2925 !1814 !113) +!2986 = (!2925 !2182) +!2987 = span !101 8176 8323 +!2988 = span !101 8373 8649 +!2989 = fn_name_span !101 8376 8395 +!2990 = decl_index 46774 +!2991 = (!2988 !2989 !2990) +!2992 = span !101 8428 8439 +!2993 = span !101 1763 1774 +!2994 = span !101 8453 8645 +!2995 = span !101 8454 8455 +!2996 = span !101 8412 8646 +!2997 = (!2996 !1710) +!2998 = (!2996 !1712) +!2999 = (!2996 !1714) +!3000 = (!2996 !1716 !1717) +!3001 = (!2996 !1716 !1717 !109) +!3002 = (!2996 !1716 !1717 !1720 !1721) +!3003 = (!2996 !1716 !1717 !1720 !1721) +!3004 = (!2996 !1716 !1717 !1720 !1721 !1724) +!3005 = (!2996 !1716 !1717 !1720 !1721 !1726) +!3006 = (!2996 !1716 !1717 !1720 !1721 !1729) +!3007 = (!2996 !1716 !1717 !1720 !1721 !1731) +!3008 = (!2996 !1716 !1717 !1720 !1721 !1733) +!3009 = (!2996 !1716 !1717 !111) +!3010 = (!2996 !1716 !1717 !113) +!3011 = (!2996 !1737) +!3012 = (!2996 !1739) +!3013 = (!2996 !1741) +!3014 = (!2996 !1743 !1744) +!3015 = (!2996 !1743 !1744 !69) +!3016 = (!2996 !1743 !1744 !71 !72) +!3017 = (!2996 !1743 !1744 !71 !72 !74) +!3018 = (!2996 !1743 !1744 !76) +!3019 = (!2996 !1750) +!3020 = (!2996 !1752) +!3021 = (!2996 !1754 !1755) +!3022 = (!2996 !1754 !1755 !69) +!3023 = (!2996 !1754 !1755 !71 !72) +!3024 = (!2996 !1754 !1755 !71 !72 !74) +!3025 = (!2996 !1754 !1755 !76) +!3026 = (!2996 !1761) +!3027 = (!2996 !1763) +!3028 = (!2996 !1763) +!3029 = (!2996 !1763) +!3030 = (!2996 !1763) +!3031 = (!2996 !1763) +!3032 = (!2996 !1763) +!3033 = (!2996 !1770) +!3034 = (!2996 !1772 !111) +!3035 = (!2996 !1772 !113) +!3036 = (!2996 !1775) +!3037 = (!2996 !1777 !1778) +!3038 = (!2996 !1777 !1778 !69) +!3039 = (!2996 !1777 !1778 !71 !72) +!3040 = (!2996 !1777 !1778 !71 !72 !74) +!3041 = (!2996 !1777 !1778 !76) +!3042 = (!2996 !1784) +!3043 = (!2996 !1786) +!3044 = (!2996 !1788) +!3045 = (!2996 !1790 !111) +!3046 = (!2996 !1790 !113) +!3047 = (!2996 !1793 !1794 !1795) +!3048 = (!2996 !1793 !1794) +!3049 = (!2996 !1793 !1794 !1795) +!3050 = (!2996 !1799) +!3051 = (!2996 !1801 !111) +!3052 = (!2996 !1801 !113) +!3053 = (!2996 !1804) +!3054 = (!2996 !2178) +!3055 = (!2996 !1814 !111) +!3056 = (!2996 !1814 !113) +!3057 = (!2996 !2182) +!3058 = span !101 8404 8647 +!3059 = span !101 8696 8780 +!3060 = fn_name_span !101 8699 8717 +!3061 = decl_index 46941 +!3062 = (!3059 !3060 !3061) +!3063 = span !101 8750 8761 +!3064 = span !101 1856 1866 +!3065 = span !101 8774 8776 +!3066 = span !101 8734 8777 +!3067 = (!3066 !1710) +!3068 = (!3066 !1712) +!3069 = (!3066 !1714) +!3070 = (!3066 !1716 !1717) +!3071 = (!3066 !1716 !1717 !109) +!3072 = (!3066 !1716 !1717 !1720 !1721) +!3073 = (!3066 !1716 !1717 !1720 !1721) +!3074 = (!3066 !1716 !1717 !1720 !1721 !1729) +!3075 = span !6 42787 42812 +!3076 = fn_call_path_span !6 42794 42804 +!3077 = (!3066 !1716 !1717 !1720 !1721 !3075 !3076) +!3078 = span !6 42621 42627 +!3079 = (!3066 !1716 !1717 !1720 !1721 !3075 !3076 !3078) +!3080 = (!3066 !1716 !1717 !1720 !1721 !1731) +!3081 = (!3066 !1716 !1717 !1720 !1721 !1733) +!3082 = (!3066 !1716 !1717 !111) +!3083 = (!3066 !1716 !1717 !113) +!3084 = (!3066 !1737) +!3085 = (!3066 !1739) +!3086 = (!3066 !1741) +!3087 = (!3066 !1743 !1744) +!3088 = (!3066 !1743 !1744 !69) +!3089 = (!3066 !1743 !1744 !71 !72) +!3090 = (!3066 !1743 !1744 !71 !72 !74) +!3091 = (!3066 !1743 !1744 !76) +!3092 = (!3066 !1750) +!3093 = (!3066 !1752) +!3094 = (!3066 !1754 !1755) +!3095 = (!3066 !1754 !1755 !69) +!3096 = (!3066 !1754 !1755 !71 !72) +!3097 = (!3066 !1754 !1755 !71 !72 !74) +!3098 = (!3066 !1754 !1755 !76) +!3099 = (!3066 !1761) +!3100 = (!3066 !1763) +!3101 = (!3066 !1763) +!3102 = (!3066 !1763) +!3103 = (!3066 !1763) +!3104 = (!3066 !1763) +!3105 = (!3066 !1763) +!3106 = (!3066 !1770) +!3107 = (!3066 !1772 !111) +!3108 = (!3066 !1772 !113) +!3109 = (!3066 !1775) +!3110 = (!3066 !1777 !1778) +!3111 = (!3066 !1777 !1778 !69) +!3112 = (!3066 !1777 !1778 !71 !72) +!3113 = (!3066 !1777 !1778 !71 !72 !74) +!3114 = (!3066 !1777 !1778 !76) +!3115 = (!3066 !1784) +!3116 = (!3066 !1786) +!3117 = (!3066 !1788) +!3118 = (!3066 !1790 !111) +!3119 = (!3066 !1790 !113) +!3120 = (!3066 !1793 !1794 !1795) +!3121 = (!3066 !1793 !1794) +!3122 = (!3066 !1793 !1794 !1795) +!3123 = (!3066 !1799) +!3124 = (!3066 !1801 !111) +!3125 = (!3066 !1801 !113) +!3126 = (!3066 !1814 !111) +!3127 = (!3066 !1814 !113) +!3128 = span !101 8826 8912 +!3129 = fn_name_span !101 8829 8847 +!3130 = decl_index 47117 +!3131 = (!3128 !3129 !3130) +!3132 = span !101 8880 8891 +!3133 = span !101 1933 1943 +!3134 = span !101 8904 8908 +!3135 = span !101 8905 8906 +!3136 = span !101 8864 8909 +!3137 = (!3136 !1710) +!3138 = (!3136 !1712) +!3139 = (!3136 !1714) +!3140 = (!3136 !1737) +!3141 = (!3136 !1739) +!3142 = (!3136 !1741) +!3143 = (!3136 !1743 !1744) +!3144 = (!3136 !1743 !1744 !69) +!3145 = (!3136 !1743 !1744 !71 !72) +!3146 = (!3136 !1743 !1744 !71 !72 !74) +!3147 = (!3136 !1743 !1744 !76) +!3148 = (!3136 !1750) +!3149 = (!3136 !1752) +!3150 = (!3136 !1754 !1755) +!3151 = (!3136 !1754 !1755 !69) +!3152 = (!3136 !1754 !1755 !71 !72) +!3153 = (!3136 !1754 !1755 !71 !72 !74) +!3154 = (!3136 !1754 !1755 !76) +!3155 = (!3136 !1761) +!3156 = (!3136 !1763) +!3157 = (!3136 !1763) +!3158 = (!3136 !1763) +!3159 = (!3136 !1763) +!3160 = (!3136 !1763) +!3161 = (!3136 !1763) +!3162 = (!3136 !1770) +!3163 = (!3136 !1772 !111) +!3164 = (!3136 !1772 !113) +!3165 = (!3136 !1775) +!3166 = (!3136 !1777 !1778) +!3167 = (!3136 !1777 !1778 !69) +!3168 = (!3136 !1777 !1778 !71 !72) +!3169 = (!3136 !1777 !1778 !71 !72 !74) +!3170 = (!3136 !1777 !1778 !76) +!3171 = (!3136 !1784) +!3172 = (!3136 !1786) +!3173 = (!3136 !1788) +!3174 = (!3136 !1790 !111) +!3175 = (!3136 !1790 !113) +!3176 = (!3136 !1793 !1794 !1795) +!3177 = (!3136 !1793 !1794) +!3178 = (!3136 !1793 !1794 !1795) +!3179 = (!3136 !1799) +!3180 = (!3136 !1801 !111) +!3181 = (!3136 !1801 !113) +!3182 = (!3136 !1804) +!3183 = (!3136 !1806 !1807 !348 !349 !831 !832 !53) +!3184 = (!3136 !1806 !1807 !348 !349 !831 !832) +!3185 = (!3136 !1806 !1807 !348 !349 !831 !832 !56) +!3186 = (!3136 !1806 !1807 !348 !349 !831 !832 !59) +!3187 = (!3136 !1806 !1807 !92) +!3188 = (!3136 !1806 !1807 !92) +!3189 = (!3136 !1806 !1807 !92) +!3190 = (!3136 !2178) +!3191 = (!3136 !1814 !111) +!3192 = (!3136 !1814 !113) +!3193 = (!3136 !2182) +!3194 = span !101 8856 8910 +!3195 = span !101 8958 9045 +!3196 = fn_name_span !101 8961 8979 +!3197 = decl_index 47302 +!3198 = (!3195 !3196 !3197) +!3199 = span !101 9012 9023 +!3200 = span !101 2018 2028 +!3201 = span !101 9036 9041 +!3202 = span !101 9037 9038 +!3203 = span !101 9039 9040 +!3204 = span !101 8996 9042 +!3205 = (!3204 !1710) +!3206 = (!3204 !1712) +!3207 = (!3204 !1714) +!3208 = (!3204 !1737) +!3209 = (!3204 !1739) +!3210 = (!3204 !1741) +!3211 = (!3204 !1743 !1744) +!3212 = (!3204 !1743 !1744 !69) +!3213 = (!3204 !1743 !1744 !71 !72) +!3214 = (!3204 !1743 !1744 !71 !72 !74) +!3215 = (!3204 !1743 !1744 !76) +!3216 = (!3204 !1750) +!3217 = (!3204 !1752) +!3218 = (!3204 !1754 !1755) +!3219 = (!3204 !1754 !1755 !69) +!3220 = (!3204 !1754 !1755 !71 !72) +!3221 = (!3204 !1754 !1755 !71 !72 !74) +!3222 = (!3204 !1754 !1755 !76) +!3223 = (!3204 !1761) +!3224 = (!3204 !1763) +!3225 = (!3204 !1763) +!3226 = (!3204 !1763) +!3227 = (!3204 !1763) +!3228 = (!3204 !1763) +!3229 = (!3204 !1763) +!3230 = (!3204 !1770) +!3231 = (!3204 !1772 !111) +!3232 = (!3204 !1772 !113) +!3233 = (!3204 !1775) +!3234 = (!3204 !1777 !1778) +!3235 = (!3204 !1777 !1778 !69) +!3236 = (!3204 !1777 !1778 !71 !72) +!3237 = (!3204 !1777 !1778 !71 !72 !74) +!3238 = (!3204 !1777 !1778 !76) +!3239 = (!3204 !1784) +!3240 = (!3204 !1786) +!3241 = (!3204 !1788) +!3242 = (!3204 !1790 !111) +!3243 = (!3204 !1790 !113) +!3244 = (!3204 !1793 !1794 !1795) +!3245 = (!3204 !1793 !1794) +!3246 = (!3204 !1793 !1794 !1795) +!3247 = (!3204 !1799) +!3248 = (!3204 !1801 !111) +!3249 = (!3204 !1801 !113) +!3250 = (!3204 !1804) +!3251 = (!3204 !2178) +!3252 = (!3204 !1814 !111) +!3253 = (!3204 !1814 !113) +!3254 = (!3204 !2182) +!3255 = span !101 8988 9043 +!3256 = span !101 9091 9180 +!3257 = fn_name_span !101 9094 9112 +!3258 = decl_index 47496 +!3259 = (!3256 !3257 !3258) +!3260 = span !101 9145 9156 +!3261 = span !101 2111 2121 +!3262 = span !101 9169 9176 +!3263 = span !101 9170 9171 +!3264 = span !101 9172 9173 +!3265 = span !101 9174 9175 +!3266 = span !101 9129 9177 +!3267 = (!3266 !1710) +!3268 = (!3266 !1712) +!3269 = (!3266 !1714) +!3270 = (!3266 !1737) +!3271 = (!3266 !1739) +!3272 = (!3266 !1741) +!3273 = (!3266 !1743 !1744) +!3274 = (!3266 !1743 !1744 !69) +!3275 = (!3266 !1743 !1744 !71 !72) +!3276 = (!3266 !1743 !1744 !71 !72 !74) +!3277 = (!3266 !1743 !1744 !76) +!3278 = (!3266 !1750) +!3279 = (!3266 !1752) +!3280 = (!3266 !1754 !1755) +!3281 = (!3266 !1754 !1755 !69) +!3282 = (!3266 !1754 !1755 !71 !72) +!3283 = (!3266 !1754 !1755 !71 !72 !74) +!3284 = (!3266 !1754 !1755 !76) +!3285 = (!3266 !1761) +!3286 = (!3266 !1763) +!3287 = (!3266 !1763) +!3288 = (!3266 !1763) +!3289 = (!3266 !1763) +!3290 = (!3266 !1763) +!3291 = (!3266 !1763) +!3292 = (!3266 !1770) +!3293 = (!3266 !1772 !111) +!3294 = (!3266 !1772 !113) +!3295 = (!3266 !1775) +!3296 = (!3266 !1777 !1778) +!3297 = (!3266 !1777 !1778 !69) +!3298 = (!3266 !1777 !1778 !71 !72) +!3299 = (!3266 !1777 !1778 !71 !72 !74) +!3300 = (!3266 !1777 !1778 !76) +!3301 = (!3266 !1784) +!3302 = (!3266 !1786) +!3303 = (!3266 !1788) +!3304 = (!3266 !1790 !111) +!3305 = (!3266 !1790 !113) +!3306 = (!3266 !1793 !1794 !1795) +!3307 = (!3266 !1793 !1794) +!3308 = (!3266 !1793 !1794 !1795) +!3309 = (!3266 !1799) +!3310 = (!3266 !1801 !111) +!3311 = (!3266 !1801 !113) +!3312 = (!3266 !1804) +!3313 = (!3266 !2178) +!3314 = (!3266 !1814 !111) +!3315 = (!3266 !1814 !113) +!3316 = (!3266 !2182) +!3317 = span !101 9121 9178 +!3318 = span !101 9226 9317 +!3319 = fn_name_span !101 9229 9247 +!3320 = decl_index 47699 +!3321 = (!3318 !3319 !3320) +!3322 = span !101 9280 9291 +!3323 = span !101 2214 2224 +!3324 = span !101 9304 9313 +!3325 = span !101 9305 9306 +!3326 = span !101 9307 9308 +!3327 = span !101 9309 9310 +!3328 = span !101 9311 9312 +!3329 = span !101 9264 9314 +!3330 = (!3329 !1710) +!3331 = (!3329 !1712) +!3332 = (!3329 !1714) +!3333 = (!3329 !1716 !1717) +!3334 = (!3329 !1716 !1717 !109) +!3335 = (!3329 !1716 !1717 !1720 !1721) +!3336 = (!3329 !1716 !1717 !1720 !1721) +!3337 = (!3329 !1716 !1717 !1720 !1721 !1724) +!3338 = (!3329 !1716 !1717 !1720 !1721 !1726) +!3339 = (!3329 !1716 !1717 !1720 !1721 !1729) +!3340 = (!3329 !1716 !1717 !1720 !1721 !1731) +!3341 = (!3329 !1716 !1717 !1720 !1721 !1733) +!3342 = (!3329 !1716 !1717 !111) +!3343 = (!3329 !1716 !1717 !113) +!3344 = (!3329 !1737) +!3345 = (!3329 !1739) +!3346 = (!3329 !1741) +!3347 = (!3329 !1743 !1744) +!3348 = (!3329 !1743 !1744 !69) +!3349 = (!3329 !1743 !1744 !71 !72) +!3350 = (!3329 !1743 !1744 !71 !72 !74) +!3351 = (!3329 !1743 !1744 !76) +!3352 = (!3329 !1750) +!3353 = (!3329 !1752) +!3354 = (!3329 !1754 !1755) +!3355 = (!3329 !1754 !1755 !69) +!3356 = (!3329 !1754 !1755 !71 !72) +!3357 = (!3329 !1754 !1755 !71 !72 !74) +!3358 = (!3329 !1754 !1755 !76) +!3359 = (!3329 !1761) +!3360 = (!3329 !1763) +!3361 = (!3329 !1763) +!3362 = (!3329 !1763) +!3363 = (!3329 !1763) +!3364 = (!3329 !1763) +!3365 = (!3329 !1763) +!3366 = (!3329 !1770) +!3367 = (!3329 !1772 !111) +!3368 = (!3329 !1772 !113) +!3369 = (!3329 !1775) +!3370 = (!3329 !1777 !1778) +!3371 = (!3329 !1777 !1778 !69) +!3372 = (!3329 !1777 !1778 !71 !72) +!3373 = (!3329 !1777 !1778 !71 !72 !74) +!3374 = (!3329 !1777 !1778 !76) +!3375 = (!3329 !1784) +!3376 = (!3329 !1786) +!3377 = (!3329 !1788) +!3378 = (!3329 !1790 !111) +!3379 = (!3329 !1790 !113) +!3380 = (!3329 !1793 !1794 !1795) +!3381 = (!3329 !1793 !1794) +!3382 = (!3329 !1793 !1794 !1795) +!3383 = (!3329 !1799) +!3384 = (!3329 !1801 !111) +!3385 = (!3329 !1801 !113) +!3386 = (!3329 !1804) +!3387 = (!3329 !2178) +!3388 = (!3329 !1814 !111) +!3389 = (!3329 !1814 !113) +!3390 = (!3329 !2182) +!3391 = span !101 9256 9315 +!3392 = span !101 9367 9458 +!3393 = fn_name_span !101 9370 9383 +!3394 = decl_index 47901 +!3395 = (!3392 !3393 !3394) +!3396 = span !101 9416 9427 +!3397 = span !101 2331 2344 +!3398 = span !101 9443 9454 +!3399 = span !101 9451 9452 +!3400 = span !101 9400 9455 +!3401 = (!3400 !1710) +!3402 = (!3400 !1712) +!3403 = (!3400 !1714) +!3404 = (!3400 !1737) +!3405 = (!3400 !1739) +!3406 = (!3400 !1741) +!3407 = (!3400 !1743 !1744) +!3408 = (!3400 !1743 !1744 !69) +!3409 = (!3400 !1743 !1744 !71 !72) +!3410 = (!3400 !1743 !1744 !71 !72 !74) +!3411 = (!3400 !1743 !1744 !76) +!3412 = (!3400 !1750) +!3413 = (!3400 !1752) +!3414 = (!3400 !1754 !1755) +!3415 = (!3400 !1754 !1755 !69) +!3416 = (!3400 !1754 !1755 !71 !72) +!3417 = (!3400 !1754 !1755 !71 !72 !74) +!3418 = (!3400 !1754 !1755 !76) +!3419 = (!3400 !1761) +!3420 = (!3400 !1763) +!3421 = (!3400 !1763) +!3422 = (!3400 !1763) +!3423 = (!3400 !1763) +!3424 = (!3400 !1763) +!3425 = (!3400 !1763) +!3426 = (!3400 !1770) +!3427 = (!3400 !1772 !111) +!3428 = (!3400 !1772 !113) +!3429 = (!3400 !1775) +!3430 = (!3400 !1777 !1778) +!3431 = (!3400 !1777 !1778 !69) +!3432 = (!3400 !1777 !1778 !71 !72) +!3433 = (!3400 !1777 !1778 !71 !72 !74) +!3434 = (!3400 !1777 !1778 !76) +!3435 = (!3400 !1784) +!3436 = (!3400 !1786) +!3437 = (!3400 !1788) +!3438 = (!3400 !1790 !111) +!3439 = (!3400 !1790 !113) +!3440 = (!3400 !1793 !1794 !1795) +!3441 = (!3400 !1793 !1794) +!3442 = (!3400 !1793 !1794 !1795) +!3443 = (!3400 !1799) +!3444 = (!3400 !1801 !111) +!3445 = (!3400 !1801 !113) +!3446 = (!3400 !1804) +!3447 = (!3400 !2178) +!3448 = (!3400 !1814 !111) +!3449 = (!3400 !1814 !113) +!3450 = (!3400 !2182) +!3451 = span !101 9392 9456 +!3452 = (!1817 !1818) +!3453 = (!1720 !1721) +!3454 = (!1720 !1721 !1726) +!3455 = (!1720 !1721 !1731) +!3456 = span !101 9516 9621 +!3457 = fn_name_span !101 9519 9536 +!3458 = decl_index 48127 +!3459 = (!3456 !3457 !3458) +!3460 = span !101 9569 9580 +!3461 = span !101 2437 2454 +!3462 = span !101 9600 9617 +!3463 = span !101 9608 9609 +!3464 = span !101 9614 9615 +!3465 = span !101 9553 9618 +!3466 = (!3465 !1710) +!3467 = (!3465 !1712) +!3468 = (!3465 !1714) +!3469 = (!3465 !1737) +!3470 = (!3465 !1739) +!3471 = (!3465 !1741) +!3472 = (!3465 !1743 !1744) +!3473 = (!3465 !1743 !1744 !69) +!3474 = (!3465 !1743 !1744 !71 !72) +!3475 = (!3465 !1743 !1744 !71 !72 !74) +!3476 = (!3465 !1743 !1744 !76) +!3477 = (!3465 !1750) +!3478 = (!3465 !1752) +!3479 = (!3465 !1754 !1755) +!3480 = (!3465 !1754 !1755 !69) +!3481 = (!3465 !1754 !1755 !71 !72) +!3482 = (!3465 !1754 !1755 !71 !72 !74) +!3483 = (!3465 !1754 !1755 !76) +!3484 = (!3465 !1761) +!3485 = (!3465 !1763) +!3486 = (!3465 !1763) +!3487 = (!3465 !1763) +!3488 = (!3465 !1763) +!3489 = (!3465 !1763) +!3490 = (!3465 !1763) +!3491 = (!3465 !1770) +!3492 = (!3465 !1772 !111) +!3493 = (!3465 !1772 !113) +!3494 = (!3465 !1775) +!3495 = (!3465 !1777 !1778) +!3496 = (!3465 !1777 !1778 !69) +!3497 = (!3465 !1777 !1778 !71 !72) +!3498 = (!3465 !1777 !1778 !71 !72 !74) +!3499 = (!3465 !1777 !1778 !76) +!3500 = (!3465 !1784) +!3501 = (!3465 !1786) +!3502 = (!3465 !1788) +!3503 = (!3465 !1790 !111) +!3504 = (!3465 !1790 !113) +!3505 = (!3465 !1793 !1794 !1795) +!3506 = (!3465 !1793 !1794) +!3507 = (!3465 !1793 !1794 !1795) +!3508 = (!3465 !1799) +!3509 = (!3465 !1801 !111) +!3510 = (!3465 !1801 !113) +!3511 = (!3465 !1804) +!3512 = (!3465 !2178) +!3513 = (!3465 !1814 !111) +!3514 = (!3465 !1814 !113) +!3515 = (!3465 !2182) +!3516 = span !101 9545 9619 +!3517 = (!1817 !1818) +!3518 = (!1720 !1721) +!3519 = (!1720 !1721 !1726) +!3520 = (!1720 !1721 !1731) +!3521 = span !101 9687 9806 +!3522 = fn_name_span !101 9690 9711 +!3523 = decl_index 48377 +!3524 = (!3521 !3522 !3523) +!3525 = span !101 9744 9755 +!3526 = span !101 2561 2582 +!3527 = span !101 9779 9802 +!3528 = span !101 9787 9788 +!3529 = span !101 9793 9794 +!3530 = span !101 9799 9800 +!3531 = span !101 9728 9803 +!3532 = (!3531 !1710) +!3533 = (!3531 !1712) +!3534 = (!3531 !1714) +!3535 = (!3531 !1737) +!3536 = (!3531 !1739) +!3537 = (!3531 !1741) +!3538 = (!3531 !1743 !1744) +!3539 = (!3531 !1743 !1744 !69) +!3540 = (!3531 !1743 !1744 !71 !72) +!3541 = (!3531 !1743 !1744 !71 !72 !74) +!3542 = (!3531 !1743 !1744 !76) +!3543 = (!3531 !1750) +!3544 = (!3531 !1752) +!3545 = (!3531 !1754 !1755) +!3546 = (!3531 !1754 !1755 !69) +!3547 = (!3531 !1754 !1755 !71 !72) +!3548 = (!3531 !1754 !1755 !71 !72 !74) +!3549 = (!3531 !1754 !1755 !76) +!3550 = (!3531 !1761) +!3551 = (!3531 !1763) +!3552 = (!3531 !1763) +!3553 = (!3531 !1763) +!3554 = (!3531 !1763) +!3555 = (!3531 !1763) +!3556 = (!3531 !1763) +!3557 = (!3531 !1770) +!3558 = (!3531 !1772 !111) +!3559 = (!3531 !1772 !113) +!3560 = (!3531 !1775) +!3561 = (!3531 !1777 !1778) +!3562 = (!3531 !1777 !1778 !69) +!3563 = (!3531 !1777 !1778 !71 !72) +!3564 = (!3531 !1777 !1778 !71 !72 !74) +!3565 = (!3531 !1777 !1778 !76) +!3566 = (!3531 !1784) +!3567 = (!3531 !1786) +!3568 = (!3531 !1788) +!3569 = (!3531 !1790 !111) +!3570 = (!3531 !1790 !113) +!3571 = (!3531 !1793 !1794 !1795) +!3572 = (!3531 !1793 !1794) +!3573 = (!3531 !1793 !1794 !1795) +!3574 = (!3531 !1799) +!3575 = (!3531 !1801 !111) +!3576 = (!3531 !1801 !113) +!3577 = (!3531 !1804) +!3578 = (!3531 !2178) +!3579 = (!3531 !1814 !111) +!3580 = (!3531 !1814 !113) +!3581 = (!3531 !2182) +!3582 = span !101 9720 9804 +!3583 = (!1817 !1818) +!3584 = (!1720 !1721) +!3585 = (!1720 !1721 !1726) +!3586 = (!1720 !1721 !1731) +!3587 = span !101 9866 9950 +!3588 = fn_name_span !101 9869 9880 +!3589 = decl_index 48599 +!3590 = (!3587 !3588 !3589) +!3591 = span !101 9913 9924 +!3592 = span !101 2693 2704 +!3593 = span !101 9944 9945 +!3594 = span !101 9897 9947 +!3595 = (!3594 !1710) +!3596 = (!3594 !1712) +!3597 = (!3594 !1714) +!3598 = (!3594 !1716 !1717) +!3599 = (!3594 !1716 !1717 !109) +!3600 = (!3594 !1716 !1717 !1720 !1721) +!3601 = (!3594 !1716 !1717 !1720 !1721) +!3602 = (!3594 !1716 !1717 !1720 !1721 !1724) +!3603 = (!3594 !1716 !1717 !1720 !1721 !1726) +!3604 = (!3594 !1716 !1717 !1720 !1721 !1729) +!3605 = (!3594 !1716 !1717 !1720 !1721 !1731) +!3606 = (!3594 !1716 !1717 !1720 !1721 !1733) +!3607 = (!3594 !1716 !1717 !111) +!3608 = (!3594 !1716 !1717 !113) +!3609 = (!3594 !1737) +!3610 = (!3594 !1739) +!3611 = (!3594 !1741) +!3612 = (!3594 !1743 !1744) +!3613 = (!3594 !1743 !1744 !69) +!3614 = (!3594 !1743 !1744 !71 !72) +!3615 = (!3594 !1743 !1744 !71 !72 !74) +!3616 = (!3594 !1743 !1744 !76) +!3617 = (!3594 !1750) +!3618 = (!3594 !1752) +!3619 = (!3594 !1754 !1755) +!3620 = (!3594 !1754 !1755 !69) +!3621 = (!3594 !1754 !1755 !71 !72) +!3622 = (!3594 !1754 !1755 !71 !72 !74) +!3623 = (!3594 !1754 !1755 !76) +!3624 = (!3594 !1761) +!3625 = (!3594 !1763) +!3626 = (!3594 !1763) +!3627 = (!3594 !1763) +!3628 = (!3594 !1763) +!3629 = (!3594 !1763) +!3630 = (!3594 !1763) +!3631 = (!3594 !1770) +!3632 = (!3594 !1772 !111) +!3633 = (!3594 !1772 !113) +!3634 = (!3594 !1775) +!3635 = (!3594 !1777 !1778) +!3636 = (!3594 !1777 !1778 !69) +!3637 = (!3594 !1777 !1778 !71 !72) +!3638 = (!3594 !1777 !1778 !71 !72 !74) +!3639 = (!3594 !1777 !1778 !76) +!3640 = (!3594 !1784) +!3641 = (!3594 !1786) +!3642 = (!3594 !1788) +!3643 = (!3594 !1790 !111) +!3644 = (!3594 !1790 !113) +!3645 = (!3594 !1793 !1794 !1795) +!3646 = (!3594 !1793 !1794) +!3647 = (!3594 !1793 !1794 !1795) +!3648 = (!3594 !1799) +!3649 = (!3594 !1801 !111) +!3650 = (!3594 !1801 !113) +!3651 = (!3594 !1804) +!3652 = (!3594 !2178) +!3653 = (!3594 !1814 !111) +!3654 = (!3594 !1814 !113) +!3655 = (!3594 !2182) +!3656 = span !101 9889 9948 +!3657 = span !101 10004 10096 +!3658 = fn_name_span !101 10007 10022 +!3659 = decl_index 48855 +!3660 = (!3657 !3658 !3659) +!3661 = span !101 10055 10066 +!3662 = span !101 2789 2804 +!3663 = span !101 10090 10091 +!3664 = span !101 10039 10093 +!3665 = (!3664 !1710) +!3666 = (!3664 !1712) +!3667 = (!3664 !1714) +!3668 = (!3664 !1716 !1717) +!3669 = (!3664 !1716 !1717 !109) +!3670 = (!3664 !1716 !1717 !1720 !1721) +!3671 = (!3664 !1716 !1717 !1720 !1721) +!3672 = (!3664 !1716 !1717 !1720 !1721 !1724) +!3673 = (!3664 !1716 !1717 !1720 !1721 !1726) +!3674 = (!3664 !1716 !1717 !1720 !1721 !1729) +!3675 = (!3664 !1716 !1717 !1720 !1721 !1731) +!3676 = (!3664 !1716 !1717 !1720 !1721 !1733) +!3677 = (!3664 !1716 !1717 !111) +!3678 = (!3664 !1716 !1717 !113) +!3679 = (!3664 !1737) +!3680 = (!3664 !1739) +!3681 = (!3664 !1741) +!3682 = (!3664 !1743 !1744) +!3683 = (!3664 !1743 !1744 !69) +!3684 = (!3664 !1743 !1744 !71 !72) +!3685 = (!3664 !1743 !1744 !71 !72 !74) +!3686 = (!3664 !1743 !1744 !76) +!3687 = (!3664 !1750) +!3688 = (!3664 !1752) +!3689 = (!3664 !1754 !1755) +!3690 = (!3664 !1754 !1755 !69) +!3691 = (!3664 !1754 !1755 !71 !72) +!3692 = (!3664 !1754 !1755 !71 !72 !74) +!3693 = (!3664 !1754 !1755 !76) +!3694 = (!3664 !1761) +!3695 = (!3664 !1763) +!3696 = (!3664 !1763) +!3697 = (!3664 !1763) +!3698 = (!3664 !1763) +!3699 = (!3664 !1763) +!3700 = (!3664 !1763) +!3701 = (!3664 !1770) +!3702 = (!3664 !1772 !111) +!3703 = (!3664 !1772 !113) +!3704 = (!3664 !1775) +!3705 = (!3664 !1777 !1778) +!3706 = (!3664 !1777 !1778 !69) +!3707 = (!3664 !1777 !1778 !71 !72) +!3708 = (!3664 !1777 !1778 !71 !72 !74) +!3709 = (!3664 !1777 !1778 !76) +!3710 = (!3664 !1784) +!3711 = (!3664 !1786) +!3712 = (!3664 !1788) +!3713 = (!3664 !1790 !111) +!3714 = (!3664 !1790 !113) +!3715 = (!3664 !1793 !1794 !1795) +!3716 = (!3664 !1793 !1794) +!3717 = (!3664 !1793 !1794 !1795) +!3718 = (!3664 !1799) +!3719 = (!3664 !1801 !111) +!3720 = (!3664 !1801 !113) +!3721 = (!3664 !1804) +!3722 = (!3664 !2178) +!3723 = (!3664 !1814 !111) +!3724 = (!3664 !1814 !113) +!3725 = (!3664 !2182) +!3726 = span !101 10031 10094 +!3727 = span !101 10158 10258 +!3728 = fn_name_span !101 10161 10180 +!3729 = decl_index 49145 +!3730 = (!3727 !3728 !3729) +!3731 = span !101 10213 10224 +!3732 = span !101 2907 2926 +!3733 = span !101 10252 10253 +!3734 = span !101 10197 10255 +!3735 = (!3734 !1710) +!3736 = (!3734 !1712) +!3737 = (!3734 !1714) +!3738 = (!3734 !1716 !1717) +!3739 = (!3734 !1716 !1717 !109) +!3740 = (!3734 !1716 !1717 !1720 !1721) +!3741 = (!3734 !1716 !1717 !1720 !1721) +!3742 = (!3734 !1716 !1717 !1720 !1721 !1724) +!3743 = (!3734 !1716 !1717 !1720 !1721 !1726) +!3744 = (!3734 !1716 !1717 !1720 !1721 !1729) +!3745 = (!3734 !1716 !1717 !1720 !1721 !1731) +!3746 = (!3734 !1716 !1717 !1720 !1721 !1733) +!3747 = (!3734 !1716 !1717 !111) +!3748 = (!3734 !1716 !1717 !113) +!3749 = (!3734 !1737) +!3750 = (!3734 !1739) +!3751 = (!3734 !1741) +!3752 = (!3734 !1743 !1744) +!3753 = (!3734 !1743 !1744 !69) +!3754 = (!3734 !1743 !1744 !71 !72) +!3755 = (!3734 !1743 !1744 !71 !72 !74) +!3756 = (!3734 !1743 !1744 !76) +!3757 = (!3734 !1750) +!3758 = (!3734 !1752) +!3759 = (!3734 !1754 !1755) +!3760 = (!3734 !1754 !1755 !69) +!3761 = (!3734 !1754 !1755 !71 !72) +!3762 = (!3734 !1754 !1755 !71 !72 !74) +!3763 = (!3734 !1754 !1755 !76) +!3764 = (!3734 !1761) +!3765 = (!3734 !1763) +!3766 = (!3734 !1763) +!3767 = (!3734 !1763) +!3768 = (!3734 !1763) +!3769 = (!3734 !1763) +!3770 = (!3734 !1763) +!3771 = (!3734 !1770) +!3772 = (!3734 !1772 !111) +!3773 = (!3734 !1772 !113) +!3774 = (!3734 !1775) +!3775 = (!3734 !1777 !1778) +!3776 = (!3734 !1777 !1778 !69) +!3777 = (!3734 !1777 !1778 !71 !72) +!3778 = (!3734 !1777 !1778 !71 !72 !74) +!3779 = (!3734 !1777 !1778 !76) +!3780 = (!3734 !1784) +!3781 = (!3734 !1786) +!3782 = (!3734 !1788) +!3783 = (!3734 !1790 !111) +!3784 = (!3734 !1790 !113) +!3785 = (!3734 !1793 !1794 !1795) +!3786 = (!3734 !1793 !1794) +!3787 = (!3734 !1793 !1794 !1795) +!3788 = (!3734 !1799) +!3789 = (!3734 !1801 !111) +!3790 = (!3734 !1801 !113) +!3791 = (!3734 !1804) +!3792 = (!3734 !2178) +!3793 = (!3734 !1814 !111) +!3794 = (!3734 !1814 !113) +!3795 = (!3734 !2182) +!3796 = span !101 10189 10256 + + Finished release [optimized + fuel] target(s) [55.368 KB] in ??? +>>>>>>> 58e204d50 (better tests to measure cost of contract calls) +======= +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [40.528 KB] in ??? +>>>>>>> dbd26f625 (bring whole snapshot test back) +>>>>>>> 8cc595443 (bring whole snapshot test back) + Running 29 tests, filtered 0 tests + +tested -- const_of_contract_call + +<<<<<<< HEAD +<<<<<<< HEAD + test cost_of_in_bool ... ok (???, 14600 gas) + test cost_of_in_u8 ... ok (???, 18427 gas) + test cost_of_in_u16 ... ok (???, 17781 gas) + test cost_of_in_u32 ... ok (???, 18557 gas) + test cost_of_in_u64 ... ok (???, 18536 gas) + test cost_of_in_u256 ... ok (???, 18265 gas) + test cost_of_in_b256 ... ok (???, 14378 gas) + test cost_of_in_str_0 ... ok (???, 15302 gas) + test cost_of_in_str_1 ... ok (???, 15805 gas) + test cost_of_in_str_8 ... ok (???, 16528 gas) + test cost_of_in_str_16 ... ok (???, 15865 gas) + test cost_of_in_str_32 ... ok (???, 16205 gas) + test cost_of_in_array_0 ... FAILED (???, 12886 gas) + test cost_of_in_array_1 ... ok (???, 13775 gas) + test cost_of_in_array_8 ... ok (???, 18788 gas) + test cost_of_in_array_16 ... ok (???, 19141 gas) + test cost_of_in_array_32 ... ok (???, 25119 gas) + test cost_of_in_array_64 ... ok (???, 36762 gas) + test cost_of_in_tuple_0 ... ok (???, 16648 gas) + test cost_of_in_tuple_1 ... ok (???, 17622 gas) + test cost_of_in_tuple_2 ... ok (???, 18257 gas) + test cost_of_in_tuple_3 ... ok (???, 18849 gas) + test cost_of_in_tuple_4 ... ok (???, 19471 gas) + test in_struct_u64 ... ok (???, 16337 gas) + test in_struct_u64_u64 ... ok (???, 16791 gas) + test in_struct_u64_u64_u64 ... ok (???, 17241 gas) + test in_enum_u64 ... ok (???, 15575 gas) + test in_enum_u64_u64 ... ok (???, 15362 gas) + test in_enum_u64_u64_u64 ... ok (???, 15551 gas) +======= +======= +>>>>>>> 8cc595443 (bring whole snapshot test back) +<<<<<<< HEAD + test cost_of_in_bool ... ok (???, 2082 gas) + test cost_of_in_u8 ... ok (???, 4331 gas) + test cost_of_in_u16 ... ok (???, 3948 gas) + test cost_of_in_u32 ... ok (???, 4389 gas) + test cost_of_in_u64 ... ok (???, 4397 gas) + test cost_of_in_u256 ... ok (???, 4240 gas) + test cost_of_in_b256 ... ok (???, 1954 gas) + test cost_of_in_str_0 ... ok (???, 2505 gas) + test cost_of_in_str_1 ... ok (???, 2806 gas) + test cost_of_in_str_8 ... ok (???, 3229 gas) + test cost_of_in_str_16 ... ok (???, 2837 gas) + test cost_of_in_str_32 ... ok (???, 3035 gas) + test cost_of_in_array_0 ... FAILED (???, 1095 gas) + test cost_of_in_array_1 ... ok (???, 1589 gas) + test cost_of_in_array_8 ... ok (???, 4192 gas) + test cost_of_in_array_16 ... ok (???, 4563 gas) + test cost_of_in_array_32 ... ok (???, 7889 gas) + test cost_of_in_array_64 ... ok (???, 14352 gas) + test cost_of_in_tuple_0 ... ok (???, 3289 gas) + test cost_of_in_tuple_1 ... ok (???, 3860 gas) + test cost_of_in_tuple_2 ... ok (???, 4228 gas) + test cost_of_in_tuple_3 ... ok (???, 4571 gas) + test cost_of_in_tuple_4 ... ok (???, 4935 gas) + test in_struct_u64 ... ok (???, 3103 gas) + test in_struct_u64_u64 ... ok (???, 3364 gas) + test in_struct_u64_u64_u64 ... ok (???, 3623 gas) + test in_enum_u64 ... ok (???, 2653 gas) + test in_enum_u64_u64 ... ok (???, 2528 gas) + test in_enum_u64_u64_u64 ... ok (???, 2640 gas) +>>>>>>> ce8248b66 (better tests to measure cost of contract calls) + + failures: + test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 + revert code: 0 + + + +test result: FAILED. 28 passed; 1 failed; finished in ??? + + Finished in ??? +error: Some tests failed. + +> Block: ARRAY0 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 101 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.768 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_array_0 ... FAILED (???, 10911 gas) + + failures: + test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 + revert code: 0 + + + +test result: FAILED. 0 passed; 1 failed; finished in ??? + + Finished in ??? +error: Some tests failed. + +> Block: ARRAY1 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.944 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_array_1 ... ok (???, 11355 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY16 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.968 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_array_16 ... ok (???, 15174 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY32 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.968 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_array_32 ... ok (???, 19221 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.008 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_array_64 ... ok (???, 27369 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY8 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.104 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_array_8 ... ok (???, 14558 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: B256 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.808 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_b256 ... ok (???, 11220 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: BOOL +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.696 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_bool ... ok (???, 11100 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ENUM_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.008 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_enum_u64 ... ok (???, 11617 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ENUM_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.16 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_enum_u64_u64 ... ok (???, 11654 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ENUM_U64_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.344 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_enum_u64_u64_u64 ... ok (???, 11675 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR0 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.728 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_str_0 ... ok (???, 11250 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR1 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.928 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_str_1 ... ok (???, 11411 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR16 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.976 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_str_16 ... ok (???, 11425 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR32 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.992 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_str_32 ... ok (???, 11431 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR8 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.944 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_str_8 ... ok (???, 11421 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STRUCT_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.824 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_struct_u64 ... ok (???, 11211 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STRUCT_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.96 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_struct_u64_u64 ... ok (???, 11561 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STRUCT_U64_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.032 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_struct_u64_u64_u64 ... ok (???, 11829 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE0 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.12 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_tuple_0 ... ok (???, 10630 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE1 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.768 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_tuple_1 ... ok (???, 11172 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE2 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.944 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_tuple_2 ... ok (???, 11560 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE3 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.016 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_tuple_3 ... ok (???, 11829 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE4 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.08 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_tuple_4 ... ok (???, 12097 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U16 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.72 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_u16 ... ok (???, 11232 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U256 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.808 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_u256 ... ok (???, 11220 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U32 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.832 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_u32 ... ok (???, 11475 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.624 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_u64 ... ok (???, 11059 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U8 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [1.664 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test isolated_cost_of_in_u8 ... ok (???, 11085 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? +======= + test cost_of_in_bool ... ok (???, 3371 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 +102, log rb: 1515152261580153489 +103, log rb: 1515152261580153489 + test cost_of_in_u8 ... ok (???, 5610 gas) + decoded log values: +100, log rb: 1515152261580153489 +101, log rb: 1515152261580153489 102, log rb: 1515152261580153489 103, log rb: 1515152261580153489 test cost_of_in_u16 ... ok (???, 5227 gas) @@ -919,777 +28404,565 @@ test result: OK. 1 passed; 0 failed; finished in ??? 101, log rb: 1515152261580153489 102, log rb: 1515152261580153489 103, log rb: 1515152261580153489 +======= + test cost_of_in_bool ... ok (???, 2590 gas) + test cost_of_in_u8 ... ok (???, 4829 gas) + test cost_of_in_u16 ... ok (???, 4446 gas) + test cost_of_in_u32 ... ok (???, 4879 gas) + test cost_of_in_u64 ... ok (???, 4888 gas) + test cost_of_in_u256 ... ok (???, 4730 gas) + test cost_of_in_b256 ... ok (???, 2460 gas) + test cost_of_in_str_0 ... ok (???, 2997 gas) + test cost_of_in_str_1 ... ok (???, 3299 gas) + test cost_of_in_str_8 ... ok (???, 3720 gas) + test cost_of_in_str_16 ... ok (???, 3330 gas) + test cost_of_in_str_32 ... ok (???, 3526 gas) + test cost_of_in_array_0 ... ok (???, 1976 gas) + test cost_of_in_array_1 ... ok (???, 3164 gas) + test cost_of_in_array_8 ... ok (???, 10767 gas) + test cost_of_in_array_16 ... ok (???, 16726 gas) + test cost_of_in_array_32 ... ok (???, 31337 gas) + test cost_of_in_array_64 ... ok (???, 60382 gas) + test cost_of_in_tuple_0 ... ok (???, 3777 gas) + test cost_of_in_tuple_1 ... ok (???, 4346 gas) + test cost_of_in_tuple_2 ... ok (???, 4711 gas) + test cost_of_in_tuple_3 ... ok (???, 5058 gas) + test cost_of_in_tuple_4 ... ok (???, 5422 gas) + test in_struct_u64 ... ok (???, 3589 gas) + test in_struct_u64_u64 ... ok (???, 3847 gas) + test in_struct_u64_u64_u64 ... ok (???, 4110 gas) + test in_enum_u64 ... ok (???, 3149 gas) + test in_enum_u64_u64 ... ok (???, 3020 gas) + test in_enum_u64_u64_u64 ... ok (???, 3130 gas) +>>>>>>> dbd26f625 (bring whole snapshot test back) + +test result: OK. 29 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY0 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_array_0 ... ok (???, 1664 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY1 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.968 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_array_1 ... ok (???, 2630 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY16 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.992 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_array_16 ... ok (???, 15867 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY32 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.992 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_array_32 ... ok (???, 29967 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [3.192 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_array_64 ... ok (???, 58218 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ARRAY8 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [3.12 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_array_8 ... ok (???, 9566 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: B256 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.504 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_b256 ... ok (???, 1462 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: BOOL +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.504 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_bool ... ok (???, 1358 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ENUM_U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.632 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_enum_u64 ... ok (???, 1644 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ENUM_U64_U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_enum_u64_u64 ... ok (???, 1658 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: ENUM_U64_U64_U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.96 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_enum_u64_u64_u64 ... ok (???, 1661 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR0 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.536 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_str_0 ... ok (???, 1451 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR1 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.736 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_str_1 ... ok (???, 1547 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR16 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.776 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_str_16 ... ok (???, 1552 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR32 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.792 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_str_32 ... ok (???, 1553 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STR8 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.752 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_str_8 ... ok (???, 1551 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STRUCT_U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.496 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call - failures: - test cost_of_in_array_16, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":368 - revert code: 0 - decoded log values: -100, log rb: 1515152261580153489 -16, log rb: 1515152261580153489 -16, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 - raw logs: -[ - { - "LogData": { - "data": "0000000000000064", - "digest": "5fcba2633bef1c29420e0eed7b037ced8b00466b0e8f1c5ce1cad2e97e117aad", - "id": "0000000000000000000000000000000000000000000000000000000000000000", - "is": 10368, - "len": 8, - "pc": 41476, - "ptr": 67104768, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000010", - "digest": "998e907bfbb34f71c66b6dc6c40fe98ca6d2d5a29755bc5a04824c36082a61d1", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86656, - "ptr": 67103744, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000010", - "digest": "998e907bfbb34f71c66b6dc6c40fe98ca6d2d5a29755bc5a04824c36082a61d1", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86788, - "ptr": 67102720, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67101696, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67100672, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67099648, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67098624, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67097600, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67096576, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67095552, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67094528, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67093504, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67092480, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67091456, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 69320, - "len": 8, - "pc": 86928, - "ptr": 67090432, - "ra": 0, - "rb": 1515152261580153489 - } - } -] - - - test cost_of_in_array_32, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":375 - revert code: 0 - decoded log values: -100, log rb: 1515152261580153489 -32, log rb: 1515152261580153489 -32, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 - raw logs: -[ - { - "LogData": { - "data": "0000000000000064", - "digest": "5fcba2633bef1c29420e0eed7b037ced8b00466b0e8f1c5ce1cad2e97e117aad", - "id": "0000000000000000000000000000000000000000000000000000000000000000", - "is": 10368, - "len": 8, - "pc": 42520, - "ptr": 67104768, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000020", - "digest": "707d56f1f282aee234577e650bea2e7b18bb6131a499582be18876aba99d4b60", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88292, - "ptr": 67103744, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000020", - "digest": "707d56f1f282aee234577e650bea2e7b18bb6131a499582be18876aba99d4b60", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88424, - "ptr": 67102720, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67101696, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67100672, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67099648, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67098624, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67097600, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67096576, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67095552, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67094528, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67093504, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67092480, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67091456, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67090432, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67089408, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 70472, - "len": 8, - "pc": 88564, - "ptr": 67088384, - "ra": 0, - "rb": 1515152261580153489 - } - } -] - - - test cost_of_in_array_64, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":382 - revert code: 0 - decoded log values: -100, log rb: 1515152261580153489 -64, log rb: 1515152261580153489 -64, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 - raw logs: -[ - { - "LogData": { - "data": "0000000000000064", - "digest": "5fcba2633bef1c29420e0eed7b037ced8b00466b0e8f1c5ce1cad2e97e117aad", - "id": "0000000000000000000000000000000000000000000000000000000000000000", - "is": 10368, - "len": 8, - "pc": 43656, - "ptr": 67104768, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000040", - "digest": "3f710ac088db33363087de2b9a657541fe5447821debaa9fe5cbd538eb1a5f29", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91080, - "ptr": 67103744, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000040", - "digest": "3f710ac088db33363087de2b9a657541fe5447821debaa9fe5cbd538eb1a5f29", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91212, - "ptr": 67102720, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67101696, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67100672, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67099648, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67098624, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67097600, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67096576, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67095552, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67094528, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67093504, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67092480, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67091456, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67090432, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67089408, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67088384, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67087360, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67086336, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67085312, - "ra": 0, - "rb": 1515152261580153489 - } - }, - { - "LogData": { - "data": "0000000000000002", - "digest": "cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70", - "id": "e0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422", - "is": 72776, - "len": 8, - "pc": 91352, - "ptr": 67084288, - "ra": 0, - "rb": 1515152261580153489 - } - } -] - - - -test result: FAILED. 26 passed; 3 failed; finished in ??? + test in_struct_u64 ... ok (???, 1435 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STRUCT_U64_U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.576 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_struct_u64_u64 ... ok (???, 1615 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: STRUCT_U64_U64_U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test in_struct_u64_u64_u64 ... ok (???, 1766 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE0 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.024 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_tuple_0 ... ok (???, 1131 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE1 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.44 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_tuple_1 ... ok (???, 1412 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE2 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.568 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_tuple_2 ... ok (???, 1615 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE3 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.64 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_tuple_3 ... ok (???, 1766 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: TUPLE4 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.704 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_tuple_4 ... ok (???, 1916 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U16 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.528 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_u16 ... ok (???, 1428 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U256 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.616 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_u256 ... ok (???, 1431 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U32 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.64 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_u32 ... ok (???, 1554 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U64 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.256 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_u64 ... ok (???, 1336 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? + + Finished in ??? + +> Block: U8 +> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) + Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) + Finished release [optimized + fuel] target(s) [2.472 KB] in ??? + Running 1 test, filtered 0 tests + +tested -- const_of_contract_call + + test cost_of_in_u8 ... ok (???, 1352 gas) + +test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? +<<<<<<< HEAD error: Some tests failed. >>>>>>> 58e204d50 (better tests to measure cost of contract calls) +======= +>>>>>>> dbd26f625 (bring whole snapshot test back) diff --git a/test/src/snapshot/mod.rs b/test/src/snapshot/mod.rs index f026d0d60e5..3e112a0e0cb 100644 --- a/test/src/snapshot/mod.rs +++ b/test/src/snapshot/mod.rs @@ -3,14 +3,10 @@ use libtest_mimic::{Arguments, Trial}; use normalize_path::NormalizePath; use regex::{Captures, Regex}; use std::{ -<<<<<<< HEAD collections::{BTreeSet, HashMap, VecDeque}, path::{Path, PathBuf}, str::FromStr, sync::Once, -======= - collections::{BTreeSet, HashMap, HashSet, VecDeque}, ffi::OsStr, path::{Path, PathBuf}, str::FromStr, sync::Once ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) }; use sway_core::Engines; use sway_features::ExperimentalFeatures; @@ -44,12 +40,8 @@ struct UndoFiles { impl Drop for UndoFiles { fn drop(&mut self) { -<<<<<<< HEAD #[allow(clippy::iter_over_hash_type)] for (path, contents) in self.contents.drain() { -======= - for (path, contents) in self.contents.iter() { ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) let _ = std::fs::write(path, contents); } } @@ -82,13 +74,8 @@ pub(super) async fn run(filter_regex: Option<®ex::Regex>) -> Result<()> { Trial::test(name.clone(), move || { let snapshot_toml = std::fs::read_to_string(format!("{}/snapshot.toml", dir.display()))?; -<<<<<<< HEAD let snapshot_toml = if snapshot_toml.trim().is_empty() { "cmds = [ \"forc build --path {root}\" ]".to_string() -======= - let snapshot_toml = if snapshot_toml.is_empty() { - "cmds = [ \"forc build --path {root}\"]".to_string() ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else { snapshot_toml }; @@ -96,22 +83,11 @@ pub(super) async fn run(filter_regex: Option<®ex::Regex>) -> Result<()> { let snapshot_toml = toml::from_str::(&snapshot_toml)?; let root = dir.strip_prefix(&repo_root).unwrap().display().to_string(); -<<<<<<< HEAD let cmds = snapshot_toml.get("cmds").unwrap().as_array().unwrap(); let mut snapshot = String::new(); let _ = run_cmds(&name, &repo_root, &root, cmds, &mut snapshot); -======= - let cmds = snapshot_toml - .get("cmds") - .unwrap() - .as_array() - .unwrap(); - - let mut snapshot = String::new(); - run_cmds(&name, &repo_root, &root, cmds, &mut snapshot); ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) fn stdout(root: &str, snapshot: &str) { let root = PathBuf::from_str(root).unwrap(); @@ -142,22 +118,13 @@ fn run_cmds( cmds: &Vec, snapshot: &mut String, ) -> std::result::Result<(), libtest_mimic::Failed> { -<<<<<<< HEAD -======= - // file contents to be set again after all cmds - let mut undo = UndoFiles::default(); - ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) use std::fmt::Write; let name = PathBuf::from_str(test_name).unwrap(); let name = name.file_stem().unwrap(); -<<<<<<< HEAD let find_blocks_regex = Regex::new(r#"START ([0-9a-zA-Z_]*)"#).unwrap(); -======= ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) for cmd in cmds { match cmd { toml::Value::String(cmd) => { @@ -179,20 +146,12 @@ fn run_cmds( FORC_DOC_COMPILATION.call_once(|| { compile_forc_doc(); }); -<<<<<<< HEAD format!("target/release/forc-doc {cmd} 1>&2") -======= - format!("target/debug/forc-doc {cmd} 1>&2") ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else if let Some(cmd) = cmd.strip_prefix("forc ") { FORC_COMPILATION.call_once(|| { compile_forc(); }); -<<<<<<< HEAD format!("target/release/forc {cmd} 1>&2") -======= - format!("target/debug/forc {cmd} 1>&2") ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else if let Some(cmd) = cmd.strip_prefix("sub ") { let arg = cmd.trim(); if let Some(l) = last_output.take() { @@ -221,7 +180,6 @@ fn run_cmds( last_output = Some(new_output); } continue; -<<<<<<< HEAD } else if let Some(args) = cmd.strip_prefix("replace-file ") { let Some((path, args)) = args.trim().split_once(" ") else { panic!("replace needs three arguments: file from to"); @@ -257,8 +215,6 @@ fn run_cmds( std::fs::write(path, contents).unwrap(); continue; -======= ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) } else if let Some(args) = cmd.strip_prefix("filter-fn ") { if let Some(output) = last_output.take() { let (name, fns) = args.trim().split_once(" ").unwrap(); @@ -392,7 +348,6 @@ fn run_cmds( let _ = writeln!(snapshot, "{}", last_output.unwrap_or_default()); } toml::Value::Table(map) => { -<<<<<<< HEAD let repeat_type = map["repeat"].as_str().unwrap(); let cmds = map["cmds"].as_array().unwrap(); @@ -406,27 +361,11 @@ fn run_cmds( } let path = PathBuf::from_str(root).unwrap().join("src/main.sw"); -======= - let ty = map["repeat"].as_str().unwrap(); - let cmds = map["cmds"].as_array().unwrap(); - - match ty { - "for-each-block" => { - fn remove_block_from_file(contents: &str, block_name: &str) -> String { - let block_regex = Regex::new(&format!("\\/\\* START {block_name} \\*\\/[.\\s\\S]+?END {block_name} \\*\\/")).unwrap(); - block_regex.replace_all(&contents, |_: &Captures| -> String { - String::new() - }).to_string() - } - - let path = PathBuf::from_str(&root).unwrap().join("src/main.sw"); ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) let byte_contents = std::fs::read(&path).unwrap(); let contents = String::from_utf8(byte_contents.clone()).unwrap(); let mut blocks = BTreeSet::new(); -<<<<<<< HEAD for capture in find_blocks_regex.captures_iter(&contents) { let name = capture.get(1).unwrap().as_str().to_string(); blocks.insert(name); @@ -444,24 +383,6 @@ fn run_cmds( new_contents = remove_block_from_file(&new_contents, remove_block) .to_string(); -======= - let regex = Regex::new(r#"START ([0-9a-zA-Z_]*)"#).unwrap(); - for capture in regex.captures_iter(&contents) { - let name = capture.get(1).unwrap().as_str().to_string(); - blocks.insert(name); - } - - for block in blocks.iter() { - writeln!(snapshot, "> Block: {block}"); - - let mut undo = UndoFiles::default(); - undo.contents.insert(path.clone(), byte_contents.clone()); - - let mut new_contents = contents.clone(); - for remove_block in blocks.iter() { - if remove_block != block { - new_contents = remove_block_from_file(&new_contents, &remove_block).to_string(); ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) } } @@ -469,7 +390,6 @@ fn run_cmds( let _ = run_cmds(test_name, repo_root, root, cmds, snapshot); } } -<<<<<<< HEAD _ => { panic!("`{cmd}` is not a supported repeat type.\nPossible types are: for-each-block."); } @@ -478,12 +398,6 @@ fn run_cmds( _ => { panic!("`cmds` items can only be strings or inline tables."); } -======= - _ => todo!(), - } - } - _ => todo!(), ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) } } From 9f331e6873e822c44da783fae1e8823d2b4b37d0 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 5 Oct 2025 12:25:05 -0300 Subject: [PATCH 04/18] fmt and clippy issues --- sway-lib-std/src/codec.sw | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw index 263c125cf9c..63a7a132891 100644 --- a/sway-lib-std/src/codec.sw +++ b/sway-lib-std/src/codec.sw @@ -3376,28 +3376,23 @@ impl AbiDecode for str[64] { // END STRARRAY_DECODE #[cfg(experimental_const_generics = true)] -impl AbiDecode for [TTT; N] +impl AbiDecode for [T; N] where - TTT: AbiEncode + AbiDecode, + T: AbiDecode, { - #[inline(never)] - fn abi_decode(ref mut buffer: BufferReader) -> [TTT; N] { - const SIZE_OF_TTT = __size_of::(); - const LENGTH: u64 = SIZE_OF_TTT * N; + fn abi_decode(ref mut buffer: BufferReader) -> [T; N] { + const LENGTH: u64 = __size_of::() * N; let mut array = [0u8; LENGTH]; - let array: &mut [TTT; N] = __transmute::<&mut [u8; LENGTH], &mut [TTT; N]>(&mut array); + let array: &mut [T; N] = __transmute::<&mut [u8; LENGTH], &mut [T; N]>(&mut array); let mut i = 0; while i < N { - let item: &mut TTT = __elem_at(array, i); - let decoded = buffer.decode::(); - __log((i, decoded)); - *item = decoded; + let item: &mut T = __elem_at(array, i); + *item = buffer.decode::(); i += 1; } - __log(*array); *array } } From f22ac21b56af04e92010cd3c95e6a3472e0068e0 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 5 Oct 2025 12:29:35 -0300 Subject: [PATCH 05/18] fmt and clippy issues --- sway-lib-std/src/codec.sw | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw index 63a7a132891..1b45e57a97f 100644 --- a/sway-lib-std/src/codec.sw +++ b/sway-lib-std/src/codec.sw @@ -3382,7 +3382,7 @@ where { fn abi_decode(ref mut buffer: BufferReader) -> [T; N] { const LENGTH: u64 = __size_of::() * N; - let mut array = [0u8; LENGTH]; + let mut array = [0u8; LENGTH]; let array: &mut [T; N] = __transmute::<&mut [u8; LENGTH], &mut [T; N]>(&mut array); let mut i = 0; From 24e75dc7126d647bbe41473a1200a5be0ea495fa Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 5 Oct 2025 13:27:35 -0300 Subject: [PATCH 06/18] fix snapshot test harness --- .../const_of_contract_call/stdout.snap | 87 +++++++++++++++---- 1 file changed, 71 insertions(+), 16 deletions(-) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index ddd024d23cb..1d2124c6f67 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -27482,18 +27482,26 @@ contract { >>>>>>> 58e204d50 (better tests to measure cost of contract calls) ======= > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 +exit status: 101 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) +<<<<<<< HEAD Finished release [optimized + fuel] target(s) [40.528 KB] in ??? >>>>>>> dbd26f625 (bring whole snapshot test back) +<<<<<<< HEAD >>>>>>> 8cc595443 (bring whole snapshot test back) +======= +======= + Finished release [optimized + fuel] target(s) [38.76 KB] in ??? +>>>>>>> 3d8d19bf9 (fix snapshot test harness) +>>>>>>> 044822ba8 (fix snapshot test harness) Running 29 tests, filtered 0 tests tested -- const_of_contract_call +<<<<<<< HEAD <<<<<<< HEAD <<<<<<< HEAD test cost_of_in_bool ... ok (???, 14600 gas) @@ -27528,6 +27536,8 @@ tested -- const_of_contract_call ======= ======= >>>>>>> 8cc595443 (bring whole snapshot test back) +======= +>>>>>>> 044822ba8 (fix snapshot test harness) <<<<<<< HEAD test cost_of_in_bool ... ok (???, 2082 gas) test cost_of_in_u8 ... ok (???, 4331 gas) @@ -28435,28 +28445,73 @@ test result: OK. 1 passed; 0 failed; finished in ??? test in_enum_u64_u64 ... ok (???, 3020 gas) test in_enum_u64_u64_u64 ... ok (???, 3130 gas) >>>>>>> dbd26f625 (bring whole snapshot test back) +======= + test cost_of_in_bool ... ok (???, 2627 gas) + test cost_of_in_u8 ... ok (???, 4874 gas) + test cost_of_in_u16 ... ok (???, 4493 gas) + test cost_of_in_u32 ... ok (???, 4926 gas) + test cost_of_in_u64 ... ok (???, 4934 gas) + test cost_of_in_u256 ... ok (???, 4777 gas) + test cost_of_in_b256 ... ok (???, 2491 gas) + test cost_of_in_str_0 ... ok (???, 3043 gas) + test cost_of_in_str_1 ... ok (???, 3345 gas) + test cost_of_in_str_8 ... ok (???, 3768 gas) + test cost_of_in_str_16 ... ok (???, 3374 gas) + test cost_of_in_str_32 ... ok (???, 3572 gas) + test cost_of_in_array_0 ... FAILED (???, 1632 gas) + test cost_of_in_array_1 ... ok (???, 2125 gas) + test cost_of_in_array_8 ... ok (???, 4724 gas) + test cost_of_in_array_16 ... ok (???, 5096 gas) + test cost_of_in_array_32 ... ok (???, 8421 gas) + test cost_of_in_array_64 ... ok (???, 14895 gas) + test cost_of_in_tuple_0 ... ok (???, 3822 gas) + test cost_of_in_tuple_1 ... ok (???, 4392 gas) + test cost_of_in_tuple_2 ... ok (???, 4761 gas) + test cost_of_in_tuple_3 ... ok (???, 5104 gas) + test cost_of_in_tuple_4 ... ok (???, 5468 gas) + test in_struct_u64 ... ok (???, 3635 gas) + test in_struct_u64_u64 ... ok (???, 3897 gas) + test in_struct_u64_u64_u64 ... ok (???, 4156 gas) + test in_enum_u64 ... ok (???, 3186 gas) + test in_enum_u64_u64 ... ok (???, 3061 gas) + test in_enum_u64_u64_u64 ... ok (???, 3173 gas) +>>>>>>> 3d8d19bf9 (fix snapshot test harness) + + failures: + test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 + revert code: 0 + -test result: OK. 29 passed; 0 failed; finished in ??? + +test result: FAILED. 28 passed; 1 failed; finished in ??? Finished in ??? +error: Some tests failed. > Block: ARRAY0 > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 +exit status: 101 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Finished release [optimized + fuel] target(s) [2.448 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_0 ... ok (???, 1664 gas) + test cost_of_in_array_0 ... FAILED (???, 1262 gas) + + failures: + test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 + revert code: 0 -test result: OK. 1 passed; 0 failed; finished in ??? + + +test result: FAILED. 0 passed; 1 failed; finished in ??? Finished in ??? +error: Some tests failed. > Block: ARRAY1 > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics @@ -28465,12 +28520,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.968 KB] in ??? + Finished release [optimized + fuel] target(s) [2.624 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_1 ... ok (???, 2630 gas) + test cost_of_in_array_1 ... ok (???, 1515 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28483,12 +28538,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.992 KB] in ??? + Finished release [optimized + fuel] target(s) [2.648 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_16 ... ok (???, 15867 gas) + test cost_of_in_array_16 ... ok (???, 3955 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28501,12 +28556,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.992 KB] in ??? + Finished release [optimized + fuel] target(s) [2.648 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_32 ... ok (???, 29967 gas) + test cost_of_in_array_32 ... ok (???, 6544 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28519,12 +28574,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [3.192 KB] in ??? + Finished release [optimized + fuel] target(s) [2.848 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_64 ... ok (???, 58218 gas) + test cost_of_in_array_64 ... ok (???, 11787 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28537,12 +28592,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [3.12 KB] in ??? + Finished release [optimized + fuel] target(s) [2.784 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_8 ... ok (???, 9566 gas) + test cost_of_in_array_8 ... ok (???, 3225 gas) test result: OK. 1 passed; 0 failed; finished in ??? From d97c55e7b3501d4228c11140e6910f22cd06097c Mon Sep 17 00:00:00 2001 From: xunilrj Date: Mon, 6 Oct 2025 17:15:01 -0300 Subject: [PATCH 07/18] rename tests for better historic comparison --- justfile | 15 ++ .../compare-gas-usage/extract-gas-usage.sh | 32 ++++ scripts/csv2html/htmltable2report.sh | 51 ++++++ .../const_of_contract_call/snapshot.toml | 2 + .../const_of_contract_call/stdout.snap | 157 +++++++++++------- 5 files changed, 199 insertions(+), 58 deletions(-) create mode 100755 scripts/compare-gas-usage/extract-gas-usage.sh create mode 100755 scripts/csv2html/htmltable2report.sh diff --git a/justfile b/justfile index b2fdc621983..2a06e727041 100644 --- a/justfile +++ b/justfile @@ -153,6 +153,21 @@ perf-remove: echo "Removing canceled." fi +[group('benchmark')] +collect-historic-gas-usage path: + #! /bin/bash + mkdir -p target + rm target/a.csv + rm target/a.html + rm target/report.html + echo "test,gas,hash" > target/a.csv + for HASH in `git log --format='%H' -- {{path}}`; do + TIMESTAMP=$(git show -s --format='%as-%ct-%H' "$HASH") + git --no-pager show "$HASH:{{path}}" | bash -c "scripts/compare-gas-usage/extract-gas-usage.sh $TIMESTAMP" >> target/a.csv + ./scripts/csv2html/csv2html.sh target/a.csv >> target/a.html + done + ./scripts/csv2html/htmltable2report.sh target/a.html > target/report.html + [group('build')] build-prism: cd ./scripts/prism && ./build.sh diff --git a/scripts/compare-gas-usage/extract-gas-usage.sh b/scripts/compare-gas-usage/extract-gas-usage.sh new file mode 100755 index 00000000000..7bcc9107177 --- /dev/null +++ b/scripts/compare-gas-usage/extract-gas-usage.sh @@ -0,0 +1,32 @@ +#!/bin/bash + +# This script extracts full test names and test gas usage from a `forc test` output. +# Usage: `forc test | test_gas_usage.sh`. +# if $1 is not empty it will be appended as a new column to the csv + +current_suite="" +results=() + +while IFS= read -r line; do + # printf 'Line: %s\n' "$line" + + if [[ $line =~ ^tested\ --\ ([^[:space:]]+) ]]; then + current_suite="${BASH_REMATCH[1]}" + fi + # printf 'Suite: %s\n' "$current_suite" + + if [[ $line =~ ^[[:space:]]*test[[:space:]]([^\ ]+)[[:space:]]\.\.\.[[:space:]].*,[[:space:]]([0-9]+)[[:space:]]gas\) ]]; then + test_name="${BASH_REMATCH[1]}" + # printf 'Test: %s\n' "$test_name" + gas="${BASH_REMATCH[2]}" + # printf 'Gas: %s\n' "$gas" + + if [ "$1" = "" ]; then + results+=("${current_suite}::${test_name},${gas}") + else + results+=("${current_suite}::${test_name},${gas},$1") + fi + fi +done + +printf '%s\n' "${results[@]}" | sort \ No newline at end of file diff --git a/scripts/csv2html/htmltable2report.sh b/scripts/csv2html/htmltable2report.sh new file mode 100755 index 00000000000..50c66b72a7c --- /dev/null +++ b/scripts/csv2html/htmltable2report.sh @@ -0,0 +1,51 @@ +echo ' + + + Pivot Demo + + + + + + + + + + + + + + + + + + + + +
+
' +cat $1 +echo '' \ No newline at end of file diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml index e29e5ff922e..e6bea08993f 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml @@ -1,4 +1,6 @@ cmds = [ + #"echo This test will first run all test together. In this way we can measure the cost of contract method selection.", + #"echo After that, each test will be run isolated, giving a more precise cost of encoding/decoding boilerplate for each type.", "forc test --path {root} --release --experimental const_generics", { repeat = "for-each-block", cmds = [ "replace-file src/main.sw \"fn cost_of_in\" \"fn isolated_cost_of_in\"", diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index 1d2124c6f67..6b866570990 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -27487,6 +27487,7 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) +<<<<<<< HEAD <<<<<<< HEAD Finished release [optimized + fuel] target(s) [40.528 KB] in ??? >>>>>>> dbd26f625 (bring whole snapshot test back) @@ -27496,13 +27497,20 @@ output: ======= Finished release [optimized + fuel] target(s) [38.76 KB] in ??? >>>>>>> 3d8d19bf9 (fix snapshot test harness) +<<<<<<< HEAD >>>>>>> 044822ba8 (fix snapshot test harness) +======= +======= + Finished release [optimized + fuel] target(s) [36.248 KB] in ??? +>>>>>>> a763fb282 (rename tests for better historic comparison) +>>>>>>> 1aaba9b99 (rename tests for better historic comparison) Running 29 tests, filtered 0 tests tested -- const_of_contract_call <<<<<<< HEAD <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD test cost_of_in_bool ... ok (???, 14600 gas) test cost_of_in_u8 ... ok (???, 18427 gas) @@ -27538,6 +27546,8 @@ tested -- const_of_contract_call >>>>>>> 8cc595443 (bring whole snapshot test back) ======= >>>>>>> 044822ba8 (fix snapshot test harness) +======= +>>>>>>> 1aaba9b99 (rename tests for better historic comparison) <<<<<<< HEAD test cost_of_in_bool ... ok (???, 2082 gas) test cost_of_in_u8 ... ok (???, 4331 gas) @@ -28476,6 +28486,37 @@ test result: OK. 1 passed; 0 failed; finished in ??? test in_enum_u64_u64 ... ok (???, 3061 gas) test in_enum_u64_u64_u64 ... ok (???, 3173 gas) >>>>>>> 3d8d19bf9 (fix snapshot test harness) +======= + test cost_of_in_bool ... ok (???, 2279 gas) + test cost_of_in_u8 ... ok (???, 4526 gas) + test cost_of_in_u16 ... ok (???, 4141 gas) + test cost_of_in_u32 ... ok (???, 4582 gas) + test cost_of_in_u64 ... ok (???, 4589 gas) + test cost_of_in_u256 ... ok (???, 4433 gas) + test cost_of_in_b256 ... ok (???, 2147 gas) + test cost_of_in_str_0 ... ok (???, 2697 gas) + test cost_of_in_str_1 ... ok (???, 2998 gas) + test cost_of_in_str_8 ... ok (???, 3421 gas) + test cost_of_in_str_16 ... ok (???, 3030 gas) + test cost_of_in_str_32 ... ok (???, 3227 gas) + test cost_of_in_array_0 ... FAILED (???, 1285 gas) + test cost_of_in_array_1 ... ok (???, 1779 gas) + test cost_of_in_array_8 ... ok (???, 4382 gas) + test cost_of_in_array_16 ... ok (???, 4753 gas) + test cost_of_in_array_32 ... ok (???, 8079 gas) + test cost_of_in_array_64 ... ok (???, 14545 gas) + test cost_of_in_tuple_0 ... ok (???, 3479 gas) + test cost_of_in_tuple_1 ... ok (???, 4050 gas) + test cost_of_in_tuple_2 ... ok (???, 4418 gas) + test cost_of_in_tuple_3 ... ok (???, 4761 gas) + test cost_of_in_tuple_4 ... ok (???, 5126 gas) + test in_struct_u64 ... ok (???, 3293 gas) + test in_struct_u64_u64 ... ok (???, 3554 gas) + test in_struct_u64_u64_u64 ... ok (???, 3813 gas) + test in_enum_u64 ... ok (???, 2843 gas) + test in_enum_u64_u64 ... ok (???, 2718 gas) + test in_enum_u64_u64_u64 ... ok (???, 2830 gas) +>>>>>>> a763fb282 (rename tests for better historic comparison) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 @@ -28495,12 +28536,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.448 KB] in ??? + Finished release [optimized + fuel] target(s) [2.016 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_0 ... FAILED (???, 1262 gas) + test cost_of_in_array_0 ... FAILED (???, 956 gas) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 @@ -28520,12 +28561,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.624 KB] in ??? + Finished release [optimized + fuel] target(s) [2.192 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_1 ... ok (???, 1515 gas) + test cost_of_in_array_1 ... ok (???, 1185 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28538,12 +28579,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Finished release [optimized + fuel] target(s) [2.216 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_16 ... ok (???, 3955 gas) + test cost_of_in_array_16 ... ok (???, 3266 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28556,12 +28597,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Finished release [optimized + fuel] target(s) [2.216 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_32 ... ok (???, 6544 gas) + test cost_of_in_array_32 ... ok (???, 5471 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28574,12 +28615,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.848 KB] in ??? + Finished release [optimized + fuel] target(s) [2.288 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_64 ... ok (???, 11787 gas) + test cost_of_in_array_64 ... ok (???, 9914 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28592,12 +28633,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Finished release [optimized + fuel] target(s) [2.352 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_8 ... ok (???, 3225 gas) + test cost_of_in_array_8 ... ok (???, 2728 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28610,12 +28651,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.504 KB] in ??? + Finished release [optimized + fuel] target(s) [2.064 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_b256 ... ok (???, 1462 gas) + test cost_of_in_b256 ... ok (???, 1120 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28628,12 +28669,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.504 KB] in ??? + Finished release [optimized + fuel] target(s) [1.952 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_bool ... ok (???, 1358 gas) + test cost_of_in_bool ... ok (???, 1047 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28646,12 +28687,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.632 KB] in ??? + Finished release [optimized + fuel] target(s) [2.256 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64 ... ok (???, 1644 gas) + test in_enum_u64 ... ok (???, 1333 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28664,12 +28705,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Finished release [optimized + fuel] target(s) [2.408 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64 ... ok (???, 1658 gas) + test in_enum_u64_u64 ... ok (???, 1347 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28682,12 +28723,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.96 KB] in ??? + Finished release [optimized + fuel] target(s) [2.584 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64_u64 ... ok (???, 1661 gas) + test in_enum_u64_u64_u64 ... ok (???, 1350 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28700,12 +28741,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.536 KB] in ??? + Finished release [optimized + fuel] target(s) [1.984 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_0 ... ok (???, 1451 gas) + test cost_of_in_str_0 ... ok (???, 1140 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28718,12 +28759,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.736 KB] in ??? + Finished release [optimized + fuel] target(s) [2.184 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_1 ... ok (???, 1547 gas) + test cost_of_in_str_1 ... ok (???, 1237 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28736,12 +28777,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.776 KB] in ??? + Finished release [optimized + fuel] target(s) [2.224 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_16 ... ok (???, 1552 gas) + test cost_of_in_str_16 ... ok (???, 1241 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28754,12 +28795,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.792 KB] in ??? + Finished release [optimized + fuel] target(s) [2.24 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_32 ... ok (???, 1553 gas) + test cost_of_in_str_32 ... ok (???, 1242 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28772,12 +28813,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.752 KB] in ??? + Finished release [optimized + fuel] target(s) [2.2 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_8 ... ok (???, 1551 gas) + test cost_of_in_str_8 ... ok (???, 1241 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28790,12 +28831,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.496 KB] in ??? + Finished release [optimized + fuel] target(s) [2.072 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64 ... ok (???, 1435 gas) + test in_struct_u64 ... ok (???, 1113 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28808,12 +28849,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.576 KB] in ??? + Finished release [optimized + fuel] target(s) [2.2 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64 ... ok (???, 1615 gas) + test in_struct_u64_u64 ... ok (???, 1304 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28826,12 +28867,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Finished release [optimized + fuel] target(s) [2.272 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64_u64 ... ok (???, 1766 gas) + test in_struct_u64_u64_u64 ... ok (???, 1455 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28844,12 +28885,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.024 KB] in ??? + Finished release [optimized + fuel] target(s) [1.472 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_0 ... ok (???, 1131 gas) + test cost_of_in_tuple_0 ... ok (???, 820 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28862,12 +28903,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.44 KB] in ??? + Finished release [optimized + fuel] target(s) [2.016 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_1 ... ok (???, 1412 gas) + test cost_of_in_tuple_1 ... ok (???, 1090 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28880,12 +28921,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.568 KB] in ??? + Finished release [optimized + fuel] target(s) [2.192 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_2 ... ok (???, 1615 gas) + test cost_of_in_tuple_2 ... ok (???, 1304 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28898,12 +28939,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.64 KB] in ??? + Finished release [optimized + fuel] target(s) [2.264 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_3 ... ok (???, 1766 gas) + test cost_of_in_tuple_3 ... ok (???, 1455 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28916,12 +28957,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.704 KB] in ??? + Finished release [optimized + fuel] target(s) [2.328 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_4 ... ok (???, 1916 gas) + test cost_of_in_tuple_4 ... ok (???, 1605 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28934,12 +28975,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.528 KB] in ??? + Finished release [optimized + fuel] target(s) [1.976 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u16 ... ok (???, 1428 gas) + test cost_of_in_u16 ... ok (???, 1117 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28952,12 +28993,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.616 KB] in ??? + Finished release [optimized + fuel] target(s) [2.064 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u256 ... ok (???, 1431 gas) + test cost_of_in_u256 ... ok (???, 1120 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28970,12 +29011,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.64 KB] in ??? + Finished release [optimized + fuel] target(s) [2.088 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u32 ... ok (???, 1554 gas) + test cost_of_in_u32 ... ok (???, 1243 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28988,12 +29029,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.256 KB] in ??? + Finished release [optimized + fuel] target(s) [1.88 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u64 ... ok (???, 1336 gas) + test cost_of_in_u64 ... ok (???, 1025 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29006,12 +29047,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.472 KB] in ??? + Finished release [optimized + fuel] target(s) [1.92 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u8 ... ok (???, 1352 gas) + test cost_of_in_u8 ... ok (???, 1041 gas) test result: OK. 1 passed; 0 failed; finished in ??? From df5113cc7d90982a8e538a0b6651a6dffa681270 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Mon, 6 Oct 2025 21:19:18 -0300 Subject: [PATCH 08/18] fix CI --- .../tests/fixtures/sample_workspace/Forc.lock | 3 +- .../const_of_contract_call/stdout.snap | 191 ++++++++++++------ 2 files changed, 133 insertions(+), 61 deletions(-) diff --git a/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock b/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock index 3a0e99b3fda..d417554ccd2 100644 --- a/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock +++ b/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock @@ -12,5 +12,4 @@ dependencies = [ [[package]] name = "std" -version = "0.69.0" -source = "registry+std?0.69.0#QmSeLFUtVXk8i13owCv87Kga1MfsYgfn7sdj6WimxLwq2g!" +source = "path+from-root-0CDB23161116D3A1" diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index 6b866570990..bc114c89bf5 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -27488,6 +27488,7 @@ output: Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD Finished release [optimized + fuel] target(s) [40.528 KB] in ??? >>>>>>> dbd26f625 (bring whole snapshot test back) @@ -27503,7 +27504,13 @@ output: ======= Finished release [optimized + fuel] target(s) [36.248 KB] in ??? >>>>>>> a763fb282 (rename tests for better historic comparison) +<<<<<<< HEAD >>>>>>> 1aaba9b99 (rename tests for better historic comparison) +======= +======= + Finished release [optimized + fuel] target(s) [38.76 KB] in ??? +>>>>>>> 41c12b7bb (fix CI) +>>>>>>> 65a8b88af (fix CI) Running 29 tests, filtered 0 tests tested -- const_of_contract_call @@ -27511,6 +27518,7 @@ tested -- const_of_contract_call <<<<<<< HEAD <<<<<<< HEAD <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD test cost_of_in_bool ... ok (???, 14600 gas) test cost_of_in_u8 ... ok (???, 18427 gas) @@ -27548,6 +27556,8 @@ tested -- const_of_contract_call >>>>>>> 044822ba8 (fix snapshot test harness) ======= >>>>>>> 1aaba9b99 (rename tests for better historic comparison) +======= +>>>>>>> 65a8b88af (fix CI) <<<<<<< HEAD test cost_of_in_bool ... ok (???, 2082 gas) test cost_of_in_u8 ... ok (???, 4331 gas) @@ -28456,6 +28466,8 @@ test result: OK. 1 passed; 0 failed; finished in ??? test in_enum_u64_u64_u64 ... ok (???, 3130 gas) >>>>>>> dbd26f625 (bring whole snapshot test back) ======= +======= +>>>>>>> 41c12b7bb (fix CI) test cost_of_in_bool ... ok (???, 2627 gas) test cost_of_in_u8 ... ok (???, 4874 gas) test cost_of_in_u16 ... ok (???, 4493 gas) @@ -28485,6 +28497,7 @@ test result: OK. 1 passed; 0 failed; finished in ??? test in_enum_u64 ... ok (???, 3186 gas) test in_enum_u64_u64 ... ok (???, 3061 gas) test in_enum_u64_u64_u64 ... ok (???, 3173 gas) +<<<<<<< HEAD >>>>>>> 3d8d19bf9 (fix snapshot test harness) ======= test cost_of_in_bool ... ok (???, 2279 gas) @@ -28517,6 +28530,8 @@ test result: OK. 1 passed; 0 failed; finished in ??? test in_enum_u64_u64 ... ok (???, 2718 gas) test in_enum_u64_u64_u64 ... ok (???, 2830 gas) >>>>>>> a763fb282 (rename tests for better historic comparison) +======= +>>>>>>> 41c12b7bb (fix CI) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 @@ -28530,21 +28545,23 @@ test result: FAILED. 28 passed; 1 failed; finished in ??? error: Some tests failed. > Block: ARRAY0 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 101 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.016 KB] in ??? + Finished release [optimized + fuel] target(s) [2.448 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_0 ... FAILED (???, 956 gas) + test isolated_cost_of_in_array_0 ... FAILED (???, 1262 gas) failures: - test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 + test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 revert code: 0 @@ -28555,504 +28572,560 @@ test result: FAILED. 0 passed; 1 failed; finished in ??? error: Some tests failed. > Block: ARRAY1 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.192 KB] in ??? + Finished release [optimized + fuel] target(s) [2.624 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_1 ... ok (???, 1185 gas) + test isolated_cost_of_in_array_1 ... ok (???, 1515 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ARRAY16 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.216 KB] in ??? + Finished release [optimized + fuel] target(s) [2.648 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_16 ... ok (???, 3266 gas) + test isolated_cost_of_in_array_16 ... ok (???, 3955 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ARRAY32 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.216 KB] in ??? + Finished release [optimized + fuel] target(s) [2.648 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_32 ... ok (???, 5471 gas) + test isolated_cost_of_in_array_32 ... ok (???, 6544 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ARRAY64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.288 KB] in ??? + Finished release [optimized + fuel] target(s) [2.848 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_64 ... ok (???, 9914 gas) + test isolated_cost_of_in_array_64 ... ok (???, 11787 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ARRAY8 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.352 KB] in ??? + Finished release [optimized + fuel] target(s) [2.784 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_array_8 ... ok (???, 2728 gas) + test isolated_cost_of_in_array_8 ... ok (???, 3225 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: B256 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.064 KB] in ??? + Finished release [optimized + fuel] target(s) [2.504 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_b256 ... ok (???, 1120 gas) + test isolated_cost_of_in_b256 ... ok (???, 1462 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: BOOL +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.952 KB] in ??? + Finished release [optimized + fuel] target(s) [2.504 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_bool ... ok (???, 1047 gas) + test isolated_cost_of_in_bool ... ok (???, 1358 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ENUM_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.256 KB] in ??? + Finished release [optimized + fuel] target(s) [2.632 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64 ... ok (???, 1333 gas) + test in_enum_u64 ... ok (???, 1644 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ENUM_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.408 KB] in ??? + Finished release [optimized + fuel] target(s) [2.784 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64 ... ok (???, 1347 gas) + test in_enum_u64_u64 ... ok (???, 1658 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: ENUM_U64_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.584 KB] in ??? + Finished release [optimized + fuel] target(s) [2.96 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64_u64 ... ok (???, 1350 gas) + test in_enum_u64_u64_u64 ... ok (???, 1661 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STR0 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.984 KB] in ??? + Finished release [optimized + fuel] target(s) [2.536 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_0 ... ok (???, 1140 gas) + test isolated_cost_of_in_str_0 ... ok (???, 1451 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STR1 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.184 KB] in ??? + Finished release [optimized + fuel] target(s) [2.736 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_1 ... ok (???, 1237 gas) + test isolated_cost_of_in_str_1 ... ok (???, 1547 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STR16 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.224 KB] in ??? + Finished release [optimized + fuel] target(s) [2.776 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_16 ... ok (???, 1241 gas) + test isolated_cost_of_in_str_16 ... ok (???, 1552 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STR32 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.24 KB] in ??? + Finished release [optimized + fuel] target(s) [2.792 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_32 ... ok (???, 1242 gas) + test isolated_cost_of_in_str_32 ... ok (???, 1553 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STR8 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.2 KB] in ??? + Finished release [optimized + fuel] target(s) [2.752 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_str_8 ... ok (???, 1241 gas) + test isolated_cost_of_in_str_8 ... ok (???, 1551 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STRUCT_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.072 KB] in ??? + Finished release [optimized + fuel] target(s) [2.496 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64 ... ok (???, 1113 gas) + test in_struct_u64 ... ok (???, 1435 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STRUCT_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.2 KB] in ??? + Finished release [optimized + fuel] target(s) [2.576 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64 ... ok (???, 1304 gas) + test in_struct_u64_u64 ... ok (???, 1615 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: STRUCT_U64_U64_U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.272 KB] in ??? + Finished release [optimized + fuel] target(s) [2.648 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64_u64 ... ok (???, 1455 gas) + test in_struct_u64_u64_u64 ... ok (???, 1766 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: TUPLE0 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.472 KB] in ??? + Finished release [optimized + fuel] target(s) [2.024 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_0 ... ok (???, 820 gas) + test isolated_cost_of_in_tuple_0 ... ok (???, 1131 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: TUPLE1 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.016 KB] in ??? + Finished release [optimized + fuel] target(s) [2.44 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_1 ... ok (???, 1090 gas) + test isolated_cost_of_in_tuple_1 ... ok (???, 1412 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: TUPLE2 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.192 KB] in ??? + Finished release [optimized + fuel] target(s) [2.568 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_2 ... ok (???, 1304 gas) + test isolated_cost_of_in_tuple_2 ... ok (???, 1615 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: TUPLE3 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.264 KB] in ??? + Finished release [optimized + fuel] target(s) [2.64 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_3 ... ok (???, 1455 gas) + test isolated_cost_of_in_tuple_3 ... ok (???, 1766 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: TUPLE4 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.328 KB] in ??? + Finished release [optimized + fuel] target(s) [2.704 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_tuple_4 ... ok (???, 1605 gas) + test isolated_cost_of_in_tuple_4 ... ok (???, 1916 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: U16 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.976 KB] in ??? + Finished release [optimized + fuel] target(s) [2.528 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u16 ... ok (???, 1117 gas) + test isolated_cost_of_in_u16 ... ok (???, 1428 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: U256 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.064 KB] in ??? + Finished release [optimized + fuel] target(s) [2.616 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u256 ... ok (???, 1120 gas) + test isolated_cost_of_in_u256 ... ok (???, 1431 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: U32 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.088 KB] in ??? + Finished release [optimized + fuel] target(s) [2.64 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u32 ... ok (???, 1243 gas) + test isolated_cost_of_in_u32 ... ok (???, 1554 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: U64 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.88 KB] in ??? + Finished release [optimized + fuel] target(s) [2.256 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u64 ... ok (???, 1025 gas) + test isolated_cost_of_in_u64 ... ok (???, 1336 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? > Block: U8 +> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" + > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 0 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.92 KB] in ??? + Finished release [optimized + fuel] target(s) [2.472 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test cost_of_in_u8 ... ok (???, 1041 gas) + test isolated_cost_of_in_u8 ... ok (???, 1352 gas) test result: OK. 1 passed; 0 failed; finished in ??? From 1b40273c4e786bbc31ef912c768912dfc13f0088 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Mon, 6 Oct 2025 22:05:51 -0300 Subject: [PATCH 09/18] fixing CI --- .../tests/fixtures/sample_workspace/Forc.lock | 3 +- justfile | 20 ++++++-- scripts/bisect-forc/bisect-forc.sh | 19 ++++--- scripts/csv2html/htmltable2report.sh | 51 ------------------- .../const_of_contract_call/snapshot.toml | 2 - 5 files changed, 26 insertions(+), 69 deletions(-) delete mode 100755 scripts/csv2html/htmltable2report.sh diff --git a/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock b/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock index d417554ccd2..3a0e99b3fda 100644 --- a/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock +++ b/forc-plugins/forc-doc/tests/fixtures/sample_workspace/Forc.lock @@ -12,4 +12,5 @@ dependencies = [ [[package]] name = "std" -source = "path+from-root-0CDB23161116D3A1" +version = "0.69.0" +source = "registry+std?0.69.0#QmSeLFUtVXk8i13owCv87Kga1MfsYgfn7sdj6WimxLwq2g!" diff --git a/justfile b/justfile index 2a06e727041..01314fa286e 100644 --- a/justfile +++ b/justfile @@ -153,20 +153,30 @@ perf-remove: echo "Removing canceled." fi +# path: path to file to extract gas usage +# open: "-o" will open the default browser showing the report +[linux] [group('benchmark')] -collect-historic-gas-usage path: +collect-historic-gas-usage path open: #! /bin/bash mkdir -p target rm target/a.csv rm target/a.html - rm target/report.html - echo "test,gas,hash" > target/a.csv + echo "test,gas,commit" > target/a.csv for HASH in `git log --format='%H' -- {{path}}`; do TIMESTAMP=$(git show -s --format='%as-%ct-%H' "$HASH") git --no-pager show "$HASH:{{path}}" | bash -c "scripts/compare-gas-usage/extract-gas-usage.sh $TIMESTAMP" >> target/a.csv - ./scripts/csv2html/csv2html.sh target/a.csv >> target/a.html done - ./scripts/csv2html/htmltable2report.sh target/a.html > target/report.html + ./scripts/csv2html/csv2html.sh target/a.csv >> target/a.html + if [ -n "{{open}}" ]; then + if which xdg-open &>> /dev/null + then + xdg-open target/a.html + elif which gnome-open &>> /dev/null + then + gnome-open target/a.html + fi + fi [group('build')] build-prism: diff --git a/scripts/bisect-forc/bisect-forc.sh b/scripts/bisect-forc/bisect-forc.sh index ae93dae7b5f..3f883ade03c 100755 --- a/scripts/bisect-forc/bisect-forc.sh +++ b/scripts/bisect-forc/bisect-forc.sh @@ -20,7 +20,15 @@ compile_and_cp_to_cache() { fi } - +run_cargo() { + if [ "$2" = "" ]; then + bash -c "$CACHE/$CACHENAME build --path $PROJ" &>> /dev/null + echo "$?" + else + bash -c "$CACHE/$CACHENAME $2 --path $PROJ" &>> /dev/null + echo "$?" + fi +} INITIAL_COMMIT="$(git show -s --format='%H' HEAD)" END_COMMIT="" @@ -39,15 +47,6 @@ git log -1 --oneline echo -n "Running: " CACHENAME="$(git show -s --format='%as-%ct-%H' HEAD)" -run_cargo() { - if [ "$2" = "" ]; then - bash -c "$CACHE/$CACHENAME build --path $PROJ" &>> /dev/null - echo "$?" - else - bash -c "$CACHE/$CACHENAME $2 --path $PROJ" &>> /dev/null - echo "$?" - fi -} compile_and_cp_to_cache "$CACHENAME" INITIAL_COMPILATION_STATUS=$(run_cargo "$1" "$2") diff --git a/scripts/csv2html/htmltable2report.sh b/scripts/csv2html/htmltable2report.sh deleted file mode 100755 index 50c66b72a7c..00000000000 --- a/scripts/csv2html/htmltable2report.sh +++ /dev/null @@ -1,51 +0,0 @@ -echo ' - - - Pivot Demo - - - - - - - - - - - - - - - - - - - - -
-
' -cat $1 -echo '' \ No newline at end of file diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml index e6bea08993f..e29e5ff922e 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/snapshot.toml @@ -1,6 +1,4 @@ cmds = [ - #"echo This test will first run all test together. In this way we can measure the cost of contract method selection.", - #"echo After that, each test will be run isolated, giving a more precise cost of encoding/decoding boilerplate for each type.", "forc test --path {root} --release --experimental const_generics", { repeat = "for-each-block", cmds = [ "replace-file src/main.sw \"fn cost_of_in\" \"fn isolated_cost_of_in\"", From 1d402e32ff50b8d0a4f5e8aa0eba68a70b64bef1 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Mon, 6 Oct 2025 22:10:49 -0300 Subject: [PATCH 10/18] fixing CI --- justfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/justfile b/justfile index 01314fa286e..72599503e10 100644 --- a/justfile +++ b/justfile @@ -153,6 +153,8 @@ perf-remove: echo "Removing canceled." fi +# This recipe should be used on snapshot tests that contains gas usage from `forc test`, +# because it will extract gas usage from all versions of the file and generate an html interactive report. # path: path to file to extract gas usage # open: "-o" will open the default browser showing the report [linux] From fa65599bfbf721a56ea0dd3e3d49ab2d7973d21f Mon Sep 17 00:00:00 2001 From: xunilrj Date: Thu, 16 Oct 2025 09:50:20 -0300 Subject: [PATCH 11/18] improve method selection on contracts --- .../declaration/auto_impl/abi_encoding.rs | 31 +++- .../typed/typed_match_expression.rs | 2 +- sway-ir/src/parser.rs | 2 +- sway-lib-std/src/codec.sw | 4 + .../match_expressions_all/snapshot.toml | 4 + .../match_expressions_all/stdout.snap | 125 ++++++++++++++ .../const_of_contract_call/stdout.snap | 157 +++++++++++------- 7 files changed, 261 insertions(+), 64 deletions(-) create mode 100644 test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/snapshot.toml create mode 100644 test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs index 9ac366bf39d..421096ea533 100644 --- a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs +++ b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs @@ -9,6 +9,8 @@ use crate::{ Engines, TypeInfo, TypeParameter, }; use std::collections::BTreeMap; +use hashbrown::HashMap; +use itertools::{join, Itertools}; use sway_error::{ error::CompileError, handler::{ErrorEmitted, Handler}, @@ -312,15 +314,16 @@ where fallback_fn: Option>, handler: &Handler, ) -> Result { - let mut code = String::new(); - let mut reads = false; let mut writes = false; // used to check for name collisions let mut contract_methods: BTreeMap> = <_>::default(); + let mut arm_by_size = BTreeMap::::default(); + // generate code + let mut method_names = String::new(); for r in contract_fns { let decl = engines.de().get(r); @@ -382,8 +385,20 @@ where }; let method_name = decl.name.as_str(); + let offset = if let Some(offset) = method_names.find(method_name) { + offset + } else { + let offset = method_names.len(); + method_names.push_str(method_name); + offset + }; + + let method_name_len = method_name.len(); + let code = arm_by_size.entry(method_name.len()).or_default(); - code.push_str(&format!("if _method_name == \"{method_name}\" {{\n")); + code.push_str(&format!(" + let is_this_method = asm(r, ptr: _method_name_ptr, name: _method_names_ptr, len: {method_name_len}) {{ addi r name i{offset}; meq r ptr r len; r: bool }}; + if is_this_method {{\n")); if args_types == "()" { code.push_str(&format!( @@ -454,10 +469,18 @@ where (false, false) => "", }; + let code = arm_by_size.iter().map(|(len, code)| { + format!("if _method_len == {len} {{ {code} }}") + }).join(""); let code = format!( "{att} pub fn __entry() {{ + let _method_names = \"{method_names}\"; let mut _buffer = BufferReader::from_second_parameter(); - let _method_name = decode_first_param::(); + + let mut _first_param_buffer = BufferReader::from_first_parameter(); + let _method_len = _first_param_buffer.read::(); + let _method_name_ptr = _first_param_buffer.ptr(); + let _method_names_ptr = _method_names.as_ptr(); {code} {fallback} }}" diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs index 0b38c6d1355..707273611fa 100644 --- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs +++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs @@ -112,7 +112,7 @@ impl ty::TyMatchExpression { let typed_if_exp = handler.scope( |handler| match &*ctx.engines().te().get(self.value_type_id) { - TypeInfo::StringSlice => self.desugar_to_radix_trie(ctx), + //TypeInfo::StringSlice => self.desugar_to_radix_trie(ctx), _ => self.desugar_to_typed_if_expression(instantiate, ctx, handler), }, )?; diff --git a/sway-ir/src/parser.rs b/sway-ir/src/parser.rs index bfcf884144c..2c315017fbe 100644 --- a/sway-ir/src/parser.rs +++ b/sway-ir/src/parser.rs @@ -1263,7 +1263,7 @@ mod ir_builder { }, ) .collect(); - let md_idx = meta_idx.map(|mdi| self.md_map.get(&mdi).unwrap()).copied(); + let md_idx = meta_idx.and_then(|mdi| self.md_map.get(&mdi)).copied(); let return_type = return_type.to_ir_type(context); block .append(context) diff --git a/sway-lib-std/src/codec.sw b/sway-lib-std/src/codec.sw index 1b45e57a97f..f3a0d4a2757 100644 --- a/sway-lib-std/src/codec.sw +++ b/sway-lib-std/src/codec.sw @@ -156,6 +156,10 @@ impl BufferReader { { T::abi_decode(self) } + + pub fn ptr(self) -> raw_ptr { + self.ptr + } } // Encode diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/snapshot.toml b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/snapshot.toml new file mode 100644 index 00000000000..624d6b0cee8 --- /dev/null +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/snapshot.toml @@ -0,0 +1,4 @@ +cmds = [ + "forc build --path {root}", + "forc build --path {root} --ir final --asm final | filter-fn {name} return_match_on_str_slice" +] \ No newline at end of file diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap new file mode 100644 index 00000000000..ae8d21c05db --- /dev/null +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap @@ -0,0 +1,125 @@ +--- +source: test/src/snapshot/mod.rs +--- +> forc build --path test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all +exit status: 0 +output: + Building test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all + Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert) + Compiling script match_expressions_all (test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all) +let packed_string = "get_a_b" +if str.len() == 5 + if str[0..4] == "get_" at packed_string[0] + if str[4..5] == "b" at packed_string[6] + return branch 2 + if str[4..5] == "a" at packed_string[4] + return branch 0 + return wildcard branch + return wildcard branch +if str.len() == 7 + if str[0..7] == "get_a_b" at packed_string[0] + return branch 1 + return wildcard branch +return wildcard branch +let packed_string = "get_a_b" +if str.len() == 5 + if str[0..4] == "get_" at packed_string[0] + if str[4..5] == "b" at packed_string[6] + return branch 2 + if str[4..5] == "a" at packed_string[4] + return branch 0 + return wildcard branch + return wildcard branch +if str.len() == 7 + if str[0..7] == "get_a_b" at packed_string[0] + return branch 1 + return wildcard branch +return wildcard branch + Finished debug [unoptimized + fuel] target(s) [2.736 KB] in ??? + +> forc build --path test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all --ir final --asm final | filter-fn match_expressions_all return_match_on_str_slice + +pshl i15 ; save registers 16..40 +pshh i524288 ; save registers 40..64 +move $$locbase $sp ; save locals base register for function return_match_on_str_slice_8 +cfei i144 ; allocate 144 bytes for locals and 0 slots for call arguments +move $r3 $$reta ; save return address +addi $r0 $$locbase i128 ; get offset to local __ptr slice +mcpi $r0 $$arg0 i16 ; copy memory +movi $r1 i7 ; initialize constant into register +lw $r0 $$locbase i17 +eq $r0 $r0 $r1 +jnzf $r0 $zero i55 +movi $r1 i5 ; initialize constant into register +lw $r0 $$locbase i17 +eq $r0 $r0 $r1 +movi $r1 i1000 ; initialize constant into register +jnzf $r0 $zero i1 +jmpf $zero i48 +addr $r0 data_NonConfigurable_9; get __const_global0's address in data section +addi $r1 $$locbase i32 ; get offset to local __ptr { ptr, u64 } +sw $$locbase $r0 i4 ; store word +movi $r0 i7 ; initialize constant into register +sw $$locbase $r0 i5 ; store word +addi $r0 $$locbase i48 ; get offset to local __ptr slice +mcpi $r0 $r1 i16 ; copy memory +movi $r2 i4 ; initialize constant into register +lw $r0 $$locbase i16 +addi $r0 $r0 i0 +lw $r1 $$locbase i6 +addi $r1 $r1 i0 +meq $r0 $r0 $r1 $r2 +movi $r1 i1000 ; initialize constant into register +jnzf $r0 $zero i1 +jmpf $zero i31 +addr $r0 data_NonConfigurable_9; get __const_global1's address in data section +addi $r1 $$locbase i64 ; get offset to local __ptr { ptr, u64 } +sw $$locbase $r0 i8 ; store word +movi $r0 i7 ; initialize constant into register +sw $$locbase $r0 i9 ; store word +addi $r0 $$locbase i80 ; get offset to local __ptr slice +mcpi $r0 $r1 i16 ; copy memory +lw $r0 $$locbase i16 +addi $r0 $r0 i4 +lw $r1 $$locbase i10 +addi $r1 $r1 i4 +meq $r0 $r0 $r1 $one +move $r1 $one ; move parameter from branch to block argument +jnzf $r0 $zero i16 +addr $r0 data_NonConfigurable_9; get __const_global2's address in data section +addi $r1 $$locbase i96 ; get offset to local __ptr { ptr, u64 } +sw $$locbase $r0 i12 ; store word +movi $r0 i7 ; initialize constant into register +sw $$locbase $r0 i13 ; store word +addi $r0 $$locbase i112 ; get offset to local __ptr slice +mcpi $r0 $r1 i16 ; copy memory +lw $r0 $$locbase i16 +addi $r0 $r0 i4 +lw $r1 $$locbase i14 +addi $r1 $r1 i6 +meq $r0 $r0 $r1 $one +movi $r1 i3 ; initialize constant into register +jnzf $r0 $zero i1 +movi $r1 i1000 ; initialize constant into register +jmpf $zero i16 +addr $r0 data_NonConfigurable_9; get __const_global's address in data section +sw $$locbase $r0 i0 ; store word +movi $r0 i7 ; initialize constant into register +sw $$locbase $r0 i1 ; store word +addi $r0 $$locbase i16 ; get offset to local __ptr slice +mcpi $r0 $$locbase i16 ; copy memory +movi $r2 i7 ; initialize constant into register +lw $r0 $$locbase i16 +addi $r0 $r0 i0 +lw $r1 $$locbase i2 +addi $r1 $r1 i0 +meq $r0 $r0 $r1 $r2 +movi $r1 i2 ; initialize constant into register +jnzf $r0 $zero i1 +movi $r1 i1000 ; initialize constant into register +move $$retv $r1 ; set return value +cfsi i144 ; free 144 bytes for locals and 0 slots for extra call arguments +move $$reta $r3 ; restore return address +poph i524288 ; restore registers 40..64 +popl i15 ; restore registers 16..40 +jal $zero $$reta i0 ; return from call diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index bc114c89bf5..7c6bb7e5841 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -27489,6 +27489,7 @@ output: Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) <<<<<<< HEAD <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD Finished release [optimized + fuel] target(s) [40.528 KB] in ??? >>>>>>> dbd26f625 (bring whole snapshot test back) @@ -27510,7 +27511,13 @@ output: ======= Finished release [optimized + fuel] target(s) [38.76 KB] in ??? >>>>>>> 41c12b7bb (fix CI) +<<<<<<< HEAD >>>>>>> 65a8b88af (fix CI) +======= +======= + Finished release [optimized + fuel] target(s) [36.568 KB] in ??? +>>>>>>> 62f7022c1 (improve method selection on contracts) +>>>>>>> 7ad706b99 (improve method selection on contracts) Running 29 tests, filtered 0 tests tested -- const_of_contract_call @@ -27519,6 +27526,7 @@ tested -- const_of_contract_call <<<<<<< HEAD <<<<<<< HEAD <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD test cost_of_in_bool ... ok (???, 14600 gas) test cost_of_in_u8 ... ok (???, 18427 gas) @@ -27558,6 +27566,8 @@ tested -- const_of_contract_call >>>>>>> 1aaba9b99 (rename tests for better historic comparison) ======= >>>>>>> 65a8b88af (fix CI) +======= +>>>>>>> 7ad706b99 (improve method selection on contracts) <<<<<<< HEAD test cost_of_in_bool ... ok (???, 2082 gas) test cost_of_in_u8 ... ok (???, 4331 gas) @@ -28532,6 +28542,37 @@ test result: OK. 1 passed; 0 failed; finished in ??? >>>>>>> a763fb282 (rename tests for better historic comparison) ======= >>>>>>> 41c12b7bb (fix CI) +======= + test cost_of_in_bool ... ok (???, 1514 gas) + test cost_of_in_u8 ... ok (???, 1493 gas) + test cost_of_in_u16 ... ok (???, 1554 gas) + test cost_of_in_u32 ... ok (???, 1689 gas) + test cost_of_in_u64 ... ok (???, 1512 gas) + test cost_of_in_u256 ... ok (???, 1577 gas) + test cost_of_in_b256 ... ok (???, 1570 gas) + test cost_of_in_str_0 ... ok (???, 1564 gas) + test cost_of_in_str_1 ... ok (???, 1675 gas) + test cost_of_in_str_8 ... ok (???, 1683 gas) + test cost_of_in_str_16 ... ok (???, 1681 gas) + test cost_of_in_str_32 ... ok (???, 1686 gas) + test cost_of_in_array_0 ... FAILED (???, 1403 gas) + test cost_of_in_array_1 ... ok (???, 1703 gas) + test cost_of_in_array_8 ... ok (???, 3783 gas) + test cost_of_in_array_16 ... ok (???, 4645 gas) + test cost_of_in_array_32 ... ok (???, 7809 gas) + test cost_of_in_array_64 ... ok (???, 14122 gas) + test cost_of_in_tuple_0 ... ok (???, 1225 gas) + test cost_of_in_tuple_1 ... ok (???, 1604 gas) + test cost_of_in_tuple_2 ... ok (???, 1782 gas) + test cost_of_in_tuple_3 ... ok (???, 1932 gas) + test cost_of_in_tuple_4 ... ok (???, 2103 gas) + test in_struct_u64 ... ok (???, 1619 gas) + test in_struct_u64_u64 ... ok (???, 1778 gas) + test in_struct_u64_u64_u64 ... ok (???, 1932 gas) + test in_enum_u64 ... ok (???, 1819 gas) + test in_enum_u64_u64 ... ok (???, 1829 gas) + test in_enum_u64_u64_u64 ... ok (???, 1838 gas) +>>>>>>> 62f7022c1 (improve method selection on contracts) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 @@ -28553,12 +28594,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.448 KB] in ??? + Finished release [optimized + fuel] target(s) [2.16 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_0 ... FAILED (???, 1262 gas) + test isolated_cost_of_in_array_0 ... FAILED (???, 1090 gas) failures: test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 @@ -28580,12 +28621,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.624 KB] in ??? + Finished release [optimized + fuel] target(s) [2.336 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_1 ... ok (???, 1515 gas) + test isolated_cost_of_in_array_1 ... ok (???, 1342 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28600,12 +28641,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Finished release [optimized + fuel] target(s) [2.368 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_16 ... ok (???, 3955 gas) + test isolated_cost_of_in_array_16 ... ok (???, 3783 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28620,12 +28661,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Finished release [optimized + fuel] target(s) [2.368 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_32 ... ok (???, 6544 gas) + test isolated_cost_of_in_array_32 ... ok (???, 6371 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28640,12 +28681,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.848 KB] in ??? + Finished release [optimized + fuel] target(s) [2.568 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_64 ... ok (???, 11787 gas) + test isolated_cost_of_in_array_64 ... ok (???, 11611 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28660,12 +28701,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Finished release [optimized + fuel] target(s) [2.496 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_8 ... ok (???, 3225 gas) + test isolated_cost_of_in_array_8 ... ok (???, 3054 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28680,12 +28721,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.504 KB] in ??? + Finished release [optimized + fuel] target(s) [2.224 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_b256 ... ok (???, 1462 gas) + test isolated_cost_of_in_b256 ... ok (???, 1290 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28700,12 +28741,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.504 KB] in ??? + Finished release [optimized + fuel] target(s) [2.216 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_bool ... ok (???, 1358 gas) + test isolated_cost_of_in_bool ... ok (???, 1186 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28720,12 +28761,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.632 KB] in ??? + Finished release [optimized + fuel] target(s) [2.344 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64 ... ok (???, 1644 gas) + test in_enum_u64 ... ok (???, 1472 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28740,12 +28781,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.784 KB] in ??? + Finished release [optimized + fuel] target(s) [2.496 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64 ... ok (???, 1658 gas) + test in_enum_u64_u64 ... ok (???, 1486 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28760,12 +28801,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.96 KB] in ??? + Finished release [optimized + fuel] target(s) [2.672 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64_u64 ... ok (???, 1661 gas) + test in_enum_u64_u64_u64 ... ok (???, 1489 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28780,12 +28821,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.536 KB] in ??? + Finished release [optimized + fuel] target(s) [2.168 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_0 ... ok (???, 1451 gas) + test isolated_cost_of_in_str_0 ... ok (???, 1205 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28800,12 +28841,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.736 KB] in ??? + Finished release [optimized + fuel] target(s) [2.4 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_1 ... ok (???, 1547 gas) + test isolated_cost_of_in_str_1 ... ok (???, 1322 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28820,12 +28861,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.776 KB] in ??? + Finished release [optimized + fuel] target(s) [2.44 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_16 ... ok (???, 1552 gas) + test isolated_cost_of_in_str_16 ... ok (???, 1329 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28840,12 +28881,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.792 KB] in ??? + Finished release [optimized + fuel] target(s) [2.456 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_32 ... ok (???, 1553 gas) + test isolated_cost_of_in_str_32 ... ok (???, 1330 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28860,12 +28901,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.752 KB] in ??? + Finished release [optimized + fuel] target(s) [2.416 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_8 ... ok (???, 1551 gas) + test isolated_cost_of_in_str_8 ... ok (???, 1328 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28880,12 +28921,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.496 KB] in ??? + Finished release [optimized + fuel] target(s) [2.208 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64 ... ok (???, 1435 gas) + test in_struct_u64 ... ok (???, 1263 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28900,12 +28941,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.576 KB] in ??? + Finished release [optimized + fuel] target(s) [2.296 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64 ... ok (???, 1615 gas) + test in_struct_u64_u64 ... ok (???, 1443 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28920,12 +28961,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.648 KB] in ??? + Finished release [optimized + fuel] target(s) [2.36 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64_u64 ... ok (???, 1766 gas) + test in_struct_u64_u64_u64 ... ok (???, 1594 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28940,12 +28981,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.024 KB] in ??? + Finished release [optimized + fuel] target(s) [1.736 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_0 ... ok (???, 1131 gas) + test isolated_cost_of_in_tuple_0 ... ok (???, 959 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28960,12 +29001,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.44 KB] in ??? + Finished release [optimized + fuel] target(s) [2.16 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_1 ... ok (???, 1412 gas) + test isolated_cost_of_in_tuple_1 ... ok (???, 1240 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28980,12 +29021,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.568 KB] in ??? + Finished release [optimized + fuel] target(s) [2.288 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_2 ... ok (???, 1615 gas) + test isolated_cost_of_in_tuple_2 ... ok (???, 1443 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29000,12 +29041,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.64 KB] in ??? + Finished release [optimized + fuel] target(s) [2.352 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_3 ... ok (???, 1766 gas) + test isolated_cost_of_in_tuple_3 ... ok (???, 1594 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29020,12 +29061,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.704 KB] in ??? + Finished release [optimized + fuel] target(s) [2.424 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_4 ... ok (???, 1916 gas) + test isolated_cost_of_in_tuple_4 ... ok (???, 1743 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29040,12 +29081,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.528 KB] in ??? + Finished release [optimized + fuel] target(s) [2.248 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u16 ... ok (???, 1428 gas) + test isolated_cost_of_in_u16 ... ok (???, 1256 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29060,12 +29101,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.616 KB] in ??? + Finished release [optimized + fuel] target(s) [2.336 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u256 ... ok (???, 1431 gas) + test isolated_cost_of_in_u256 ... ok (???, 1259 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29080,12 +29121,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.64 KB] in ??? + Finished release [optimized + fuel] target(s) [2.352 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u32 ... ok (???, 1554 gas) + test isolated_cost_of_in_u32 ... ok (???, 1381 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29100,12 +29141,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.256 KB] in ??? + Finished release [optimized + fuel] target(s) [1.976 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u64 ... ok (???, 1336 gas) + test isolated_cost_of_in_u64 ... ok (???, 1164 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29120,12 +29161,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.472 KB] in ??? + Finished release [optimized + fuel] target(s) [2.192 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u8 ... ok (???, 1352 gas) + test isolated_cost_of_in_u8 ... ok (???, 1179 gas) test result: OK. 1 passed; 0 failed; finished in ??? From b0fb22ebae5fc61c28fe4edf47aec18d29ee52e9 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Thu, 16 Oct 2025 09:59:57 -0300 Subject: [PATCH 12/18] fmt and clippy issues --- .../declaration/auto_impl/abi_encoding.rs | 10 +- .../typed/typed_match_expression.rs | 979 +++++++++--------- 2 files changed, 491 insertions(+), 498 deletions(-) diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs index 421096ea533..2cd6691101f 100644 --- a/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs +++ b/sway-core/src/semantic_analysis/ast_node/declaration/auto_impl/abi_encoding.rs @@ -8,9 +8,8 @@ use crate::{ }, Engines, TypeInfo, TypeParameter, }; +use itertools::Itertools; use std::collections::BTreeMap; -use hashbrown::HashMap; -use itertools::{join, Itertools}; use sway_error::{ error::CompileError, handler::{ErrorEmitted, Handler}, @@ -469,9 +468,10 @@ where (false, false) => "", }; - let code = arm_by_size.iter().map(|(len, code)| { - format!("if _method_len == {len} {{ {code} }}") - }).join(""); + let code = arm_by_size + .iter() + .map(|(len, code)| format!("if _method_len == {len} {{ {code} }}")) + .join(""); let code = format!( "{att} pub fn __entry() {{ let _method_names = \"{method_names}\"; diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs index 707273611fa..88a31331ccf 100644 --- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs +++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_match_expression.rs @@ -2,52 +2,51 @@ use crate::{ compiler_generated::INVALID_DESUGARED_MATCHED_EXPRESSION_SIGNAL, language::{ parsed::*, - ty::{ - self, TyAsmRegisterDeclaration, TyExpression, TyExpressionVariant, - TyIntrinsicFunctionKind, - }, - AsmOp, AsmRegister, + ty::{self, TyExpression}, }, semantic_analysis::{ ast_node::expression::typed_expression::instantiate_if_expression, expression::match_expression::typed::instantiate::Instantiate, TypeCheckContext, }, - CompileError, TypeEngine, TypeId, TypeInfo, + CompileError, TypeId, }; -use std::{collections::BTreeMap, ops::ControlFlow}; +use std::ops::ControlFlow; use sway_error::handler::{ErrorEmitted, Handler}; -use sway_types::{BaseIdent, Ident, Span, Spanned}; +use sway_types::{Span, Spanned}; -// Enable this to see a pseudo-code printed to understand what is being generated. -const RADIX_TREE_DEBUG: bool = true; - -#[derive(Default, Debug, Clone)] -struct TrieNode { - output: Option, - previous: Option, - next: BTreeMap, -} - -struct Trie { - nodes: Vec, -} +// Trie for matching strings is disabled as it is not generating the best possible code. +// Sometimes mac=tching by the trie is actually worse than comparing each individually -fn revert(type_engine: &TypeEngine) -> TyExpression { - TyExpression { - expression: TyExpressionVariant::IntrinsicFunction(TyIntrinsicFunctionKind { - kind: sway_ast::Intrinsic::Revert, - arguments: vec![TyExpression { - expression: TyExpressionVariant::Literal(crate::language::Literal::U64(17)), - return_type: type_engine.id_of_u64(), - span: Span::dummy(), - }], - type_arguments: vec![], - span: Span::dummy(), - }), - return_type: type_engine.id_of_never(), - span: Span::dummy(), - } -} +// Enable this to see a pseudo-code printed to understand what is being generated. +// const RADIX_TRIE_DEBUG: bool = false; + +// #[derive(Default, Debug, Clone)] +// struct TrieNode { +// output: Option, +// previous: Option, +// next: BTreeMap, +// } + +// struct Trie { +// nodes: Vec, +// } + +// fn revert(type_engine: &TypeEngine) -> TyExpression { +// TyExpression { +// expression: TyExpressionVariant::IntrinsicFunction(TyIntrinsicFunctionKind { +// kind: sway_ast::Intrinsic::Revert, +// arguments: vec![TyExpression { +// expression: TyExpressionVariant::Literal(crate::language::Literal::U64(17)), +// return_type: type_engine.id_of_u64(), +// span: Span::dummy(), +// }], +// type_arguments: vec![], +// span: Span::dummy(), +// }), +// return_type: type_engine.id_of_never(), +// span: Span::dummy(), +// } +// } impl ty::TyMatchExpression { pub(crate) fn type_check( @@ -109,466 +108,460 @@ impl ty::TyMatchExpression { ); } - let typed_if_exp = - handler.scope( - |handler| match &*ctx.engines().te().get(self.value_type_id) { - //TypeInfo::StringSlice => self.desugar_to_radix_trie(ctx), - _ => self.desugar_to_typed_if_expression(instantiate, ctx, handler), - }, - )?; + let typed_if_exp = handler + .scope(|handler| self.desugar_to_typed_if_expression(instantiate, ctx, handler))?; Ok(typed_if_exp) } - fn desugar_to_radix_trie( - &self, - mut ctx: TypeCheckContext<'_>, - ) -> Result { - let type_engine = ctx.engines.te(); - - let branch_return_type_id = self - .branches - .iter() - .map(|x| x.result.return_type) - .next() - .unwrap(); - - let matched_value = self - .branches - .iter() - .flat_map(|x| match &x.condition.as_ref().map(|x| &x.expression) { - Some(TyExpressionVariant::FunctionApplication { arguments, .. }) => { - Some(&arguments[0].1) - } - _ => None, - }) - .next() - .unwrap(); - - // the block for the wildcard arm - let wildcard_return_expr = self - .branches - .iter() - .filter(|x| x.condition.is_none()) - .map(|x| x.result.clone()) - .next() - .unwrap_or_else(|| revert(type_engine)); - - // All the match string slices, ignoring the wildcard - let match_arms_string_slices = self - .branches - .iter() - .flat_map(|x| match &x.condition.as_ref().map(|x| &x.expression) { - Some(TyExpressionVariant::FunctionApplication { arguments, .. }) => { - match &arguments[1].1.expression { - TyExpressionVariant::Literal(crate::language::Literal::String(v)) => { - Some(v.as_str().to_string()) - } - _ => None, - } - } - _ => None, - }) - .collect::>(); - - // group match arms by size of the arm string slice - let match_arms_by_size = match_arms_string_slices.iter().enumerate().fold( - BTreeMap::>::new(), - |mut map, (i, item)| { - map.entry(item.len()).or_default().push((item.clone(), i)); - map - }, - ); - - // create and compress all tries. One per arm size - let tries = match_arms_by_size - .values() - .map(|branches| self.generate_radix_trie(branches).unwrap()) - .collect::>(); - - // Navigate all valid nodes and collect string pieces. - // Then pack them starting from the biggest. - let mut string_pieces = tries - .iter() - .flat_map(|x| x.nodes.iter()) - .flat_map(|x| x.next.keys().cloned()) - .collect::>(); - string_pieces.sort_by(|l, r| l.len().cmp(&r.len()).reverse()); - let packed_strings = string_pieces - .into_iter() - .fold(String::new(), |mut pack, item| { - if !pack.contains(&item) { - pack.push_str(&item); - } - pack - }); - - if RADIX_TREE_DEBUG { - println!("let packed_string = {packed_strings:?}"); - } - - // Now create the outer expression checking the size of the string slice - let mut block = wildcard_return_expr.clone(); - - for ((k, _), trie) in match_arms_by_size.into_iter().zip(tries.into_iter()) { - if RADIX_TREE_DEBUG { - println!("if str.len() == {k}"); - } - - let expression = TyExpressionVariant::AsmExpression { - registers: vec![ - TyAsmRegisterDeclaration { - name: Ident::new_no_span("is_eq".into()), - initializer: None, - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("slice".into()), - initializer: Some(matched_value.clone()), - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("len".into()), - initializer: None, - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("expected_len".into()), - initializer: Some(TyExpression { - expression: TyExpressionVariant::Literal( - crate::language::Literal::U64(k as u64), - ), - return_type: type_engine.id_of_u64(), - span: Span::dummy(), - }), - }, - ], - body: vec![ - AsmOp { - op_name: Ident::new_no_span("lw".into()), - op_args: vec![ - BaseIdent::new_no_span("len".into()), - BaseIdent::new_no_span("slice".into()), - ], - immediate: Some(BaseIdent::new_no_span("i1".into())), - span: Span::dummy(), - }, - AsmOp { - op_name: Ident::new_no_span("eq".into()), - op_args: vec![ - BaseIdent::new_no_span("is_eq".into()), - BaseIdent::new_no_span("len".into()), - BaseIdent::new_no_span("expected_len".into()), - ], - immediate: None, - span: Span::dummy(), - }, - ], - returns: Some(( - AsmRegister { - name: "is_eq".into(), - }, - Span::dummy(), - )), - whole_block_span: self.span.clone(), - }; - - let then_node = self - .generate_radix_tree_checks( - ctx.by_ref(), - matched_value, - branch_return_type_id, - wildcard_return_expr.clone(), - trie, - &packed_strings, - ) - .unwrap(); - - block = TyExpression { - expression: TyExpressionVariant::IfExp { - condition: Box::new(TyExpression { - expression, - return_type: type_engine.id_of_bool(), - span: self.span.clone(), - }), - then: Box::new(then_node), - r#else: Some(Box::new(block)), - }, - return_type: branch_return_type_id, - span: self.span.clone(), - }; - } - - if RADIX_TREE_DEBUG { - println!("return wildcard branch"); - } - - Ok(block) - } - - #[allow(clippy::too_many_arguments)] - fn generate_radix_trie(&self, branches: &[(String, usize)]) -> Result { - let mut nodes = vec![TrieNode::default()]; - - for (b, i) in branches.iter() { - let mut current = 0; - for c in b.chars() { - let c = c.to_string(); - if let Some(next) = nodes[current].next.get(&c) { - current = *next; - continue; - } - - let next = nodes.len(); - nodes[current].next.insert(c, next); - current = next; - nodes.push(TrieNode::default()); - } - - nodes[current].output = Some(*i); - } - - // compress trie - let mut q = vec![0]; - while let Some(i) = q.pop() { - let mut current = nodes[i].clone(); - if current.next.len() == 1 { - let edge = current.next.pop_first().unwrap(); - let mut next = nodes[edge.1].clone(); - if next.next.len() == 1 { - let next_edge = next.next.pop_first().unwrap(); - let compressed_key = format!("{}{}", edge.0, next_edge.0); - - nodes[i].next.clear(); - nodes[i].next.insert(compressed_key, next_edge.1); - nodes[i].output = next.output.take(); - - q.push(i); - } else { - nodes[edge.1].previous = Some(i); - q.push(edge.1); - } - } else { - for (_, v) in current.next.iter() { - nodes[*v].previous = Some(i); - q.push(*v); - } - } - } - - Ok(Trie { nodes }) - } - - #[allow(clippy::too_many_arguments)] - fn generate_radix_tree_checks( - &self, - ctx: TypeCheckContext<'_>, - matched_value: &TyExpression, - branch_return_type_id: TypeId, - wildcard_return_expr: TyExpression, - trie: Trie, - packed_strings: &str, - ) -> Result { - let type_engine = ctx.engines.te(); - - let packed_strings_expr = TyExpression { - expression: TyExpressionVariant::Literal(crate::language::Literal::String( - Span::from_string(packed_strings.to_string()), - )), - return_type: type_engine.id_of_string_slice(), - span: Span::dummy(), - }; - - let expr = self.generate_radrix_trie_code( - matched_value, - packed_strings, - &packed_strings_expr, - &trie.nodes, - 0, - 0, - type_engine.id_of_bool(), - type_engine.id_of_u64(), - branch_return_type_id, - 1, - wildcard_return_expr, - ); - - Ok(expr) - } - - #[allow(clippy::too_many_arguments)] - fn generate_radrix_trie_code( - &self, - matched_value: &TyExpression, - packed_strings: &str, - packed_strings_expr: &TyExpression, - nodes: &[TrieNode], - slice_pos: usize, - current_node_index: usize, - bool_type_id: TypeId, - u64_type_id: TypeId, - branch_return_type_id: TypeId, - depth: usize, - block_when_all_fail: TyExpression, - ) -> TyExpression { - let current = &nodes[current_node_index]; - - if let Some(output) = current.output { - assert!(current.next.is_empty()); - - if RADIX_TREE_DEBUG { - println!("{}return branch {:?}", " ".repeat(depth * 4), output); - } - - let branch = &self.branches[output]; - return branch.result.clone(); - } - - let mut block = block_when_all_fail.clone(); - - for (prefix, next_node_index) in current.next.iter().rev() { - let start = current_node_index; - let end = current_node_index + prefix.len(); - let eq_len: u64 = end as u64 - start as u64; - - let prefix_pos = packed_strings - .find(prefix) - .expect("prefix should be inside this string"); - - if RADIX_TREE_DEBUG { - println!( - "{}if str[{start}..{end}] == \"{prefix}\" at packed_string[{prefix_pos}]", - " ".repeat(depth * 4), - ); - } - - let then_node = self.generate_radrix_trie_code( - matched_value, - packed_strings, - packed_strings_expr, - nodes, - end, - *next_node_index, - bool_type_id, - u64_type_id, - branch_return_type_id, - depth + 1, - block_when_all_fail.clone(), - ); - - let prefix_pos = packed_strings - .find(prefix) - .expect("prefix should be inside this string"); - - let expression = TyExpressionVariant::AsmExpression { - registers: vec![ - TyAsmRegisterDeclaration { - name: Ident::new_no_span("slice".into()), - initializer: Some(matched_value.clone()), - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("prefix".into()), - initializer: Some(packed_strings_expr.clone()), - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("slice_ptr".into()), - initializer: None, - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("prefix_ptr".into()), - initializer: None, - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("len".into()), - initializer: Some(TyExpression { - expression: TyExpressionVariant::Literal( - crate::language::Literal::U64(eq_len), - ), - return_type: u64_type_id, - span: Span::dummy(), - }), - }, - TyAsmRegisterDeclaration { - name: Ident::new_no_span("is_eq".into()), - initializer: None, - }, - ], - body: vec![ - AsmOp { - op_name: Ident::new_no_span("lw".into()), - op_args: vec![ - BaseIdent::new_no_span("slice_ptr".into()), - BaseIdent::new_no_span("slice".into()), - ], - immediate: Some(BaseIdent::new_no_span("i0".into())), - span: Span::dummy(), - }, - AsmOp { - op_name: Ident::new_no_span("addi".into()), - op_args: vec![ - BaseIdent::new_no_span("slice_ptr".into()), - BaseIdent::new_no_span("slice_ptr".into()), - ], - immediate: Some(BaseIdent::new_no_span(format!("i{slice_pos}"))), - span: Span::dummy(), - }, - AsmOp { - op_name: Ident::new_no_span("lw".into()), - op_args: vec![ - BaseIdent::new_no_span("prefix_ptr".into()), - BaseIdent::new_no_span("prefix".into()), - ], - immediate: Some(BaseIdent::new_no_span("i0".into())), - span: Span::dummy(), - }, - AsmOp { - op_name: Ident::new_no_span("addi".into()), - op_args: vec![ - BaseIdent::new_no_span("prefix_ptr".into()), - BaseIdent::new_no_span("prefix_ptr".into()), - ], - immediate: Some(BaseIdent::new_no_span(format!("i{prefix_pos}"))), - span: Span::dummy(), - }, - AsmOp { - op_name: Ident::new_no_span("meq".into()), - op_args: vec![ - BaseIdent::new_no_span("is_eq".into()), - BaseIdent::new_no_span("slice_ptr".into()), - BaseIdent::new_no_span("prefix_ptr".into()), - BaseIdent::new_no_span("len".into()), - ], - immediate: None, - span: Span::dummy(), - }, - ], - returns: Some(( - AsmRegister { - name: "is_eq".into(), - }, - Span::dummy(), - )), - whole_block_span: Span::dummy(), - }; - - block = TyExpression { - expression: TyExpressionVariant::IfExp { - condition: Box::new(TyExpression { - expression, - return_type: bool_type_id, - span: Span::dummy(), - }), - then: Box::new(then_node), - r#else: Some(Box::new(block)), - }, - return_type: branch_return_type_id, - span: Span::dummy(), - }; - } - - if RADIX_TREE_DEBUG { - println!("{}return wildcard branch", " ".repeat(depth * 4),); - } - - block - } + // fn desugar_to_radix_trie( + // &self, + // mut ctx: TypeCheckContext<'_>, + // ) -> Result { + // let type_engine = ctx.engines.te(); + + // let branch_return_type_id = self + // .branches + // .iter() + // .map(|x| x.result.return_type) + // .next() + // .unwrap(); + + // let matched_value = self + // .branches + // .iter() + // .flat_map(|x| match &x.condition.as_ref().map(|x| &x.expression) { + // Some(TyExpressionVariant::FunctionApplication { arguments, .. }) => { + // Some(&arguments[0].1) + // } + // _ => None, + // }) + // .next() + // .unwrap(); + + // // the block for the wildcard arm + // let wildcard_return_expr = self + // .branches + // .iter() + // .filter(|x| x.condition.is_none()) + // .map(|x| x.result.clone()) + // .next() + // .unwrap_or_else(|| revert(type_engine)); + + // // All the match string slices, ignoring the wildcard + // let match_arms_string_slices = self + // .branches + // .iter() + // .flat_map(|x| match &x.condition.as_ref().map(|x| &x.expression) { + // Some(TyExpressionVariant::FunctionApplication { arguments, .. }) => { + // match &arguments[1].1.expression { + // TyExpressionVariant::Literal(crate::language::Literal::String(v)) => { + // Some(v.as_str().to_string()) + // } + // _ => None, + // } + // } + // _ => None, + // }) + // .collect::>(); + + // // group match arms by size of the arm string slice + // let match_arms_by_size = match_arms_string_slices.iter().enumerate().fold( + // BTreeMap::>::new(), + // |mut map, (i, item)| { + // map.entry(item.len()).or_default().push((item.clone(), i)); + // map + // }, + // ); + + // // create and compress all tries. One per arm size + // let tries = match_arms_by_size + // .values() + // .map(|branches| self.generate_radix_trie(branches).unwrap()) + // .collect::>(); + + // // Navigate all valid nodes and collect string pieces. + // // Then pack them starting from the biggest. + // let mut string_pieces = tries + // .iter() + // .flat_map(|x| x.nodes.iter()) + // .flat_map(|x| x.next.keys().cloned()) + // .collect::>(); + // string_pieces.sort_by(|l, r| l.len().cmp(&r.len()).reverse()); + // let packed_strings = string_pieces + // .into_iter() + // .fold(String::new(), |mut pack, item| { + // if !pack.contains(&item) { + // pack.push_str(&item); + // } + // pack + // }); + + // if RADIX_TRIE_DEBUG { + // println!("let packed_string = {packed_strings:?}"); + // } + + // // Now create the outer expression checking the size of the string slice + // let mut block = wildcard_return_expr.clone(); + + // for ((k, _), trie) in match_arms_by_size.into_iter().zip(tries.into_iter()) { + // if RADIX_TRIE_DEBUG { + // println!("if str.len() == {k}"); + // } + + // let expression = TyExpressionVariant::AsmExpression { + // registers: vec![ + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("is_eq".into()), + // initializer: None, + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("slice".into()), + // initializer: Some(matched_value.clone()), + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("len".into()), + // initializer: None, + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("expected_len".into()), + // initializer: Some(TyExpression { + // expression: TyExpressionVariant::Literal( + // crate::language::Literal::U64(k as u64), + // ), + // return_type: type_engine.id_of_u64(), + // span: Span::dummy(), + // }), + // }, + // ], + // body: vec![ + // AsmOp { + // op_name: Ident::new_no_span("lw".into()), + // op_args: vec![ + // BaseIdent::new_no_span("len".into()), + // BaseIdent::new_no_span("slice".into()), + // ], + // immediate: Some(BaseIdent::new_no_span("i1".into())), + // span: Span::dummy(), + // }, + // AsmOp { + // op_name: Ident::new_no_span("eq".into()), + // op_args: vec![ + // BaseIdent::new_no_span("is_eq".into()), + // BaseIdent::new_no_span("len".into()), + // BaseIdent::new_no_span("expected_len".into()), + // ], + // immediate: None, + // span: Span::dummy(), + // }, + // ], + // returns: Some(( + // AsmRegister { + // name: "is_eq".into(), + // }, + // Span::dummy(), + // )), + // whole_block_span: self.span.clone(), + // }; + + // let then_node = self + // .generate_radix_tree_checks( + // ctx.by_ref(), + // matched_value, + // branch_return_type_id, + // wildcard_return_expr.clone(), + // trie, + // &packed_strings, + // ) + // .unwrap(); + + // block = TyExpression { + // expression: TyExpressionVariant::IfExp { + // condition: Box::new(TyExpression { + // expression, + // return_type: type_engine.id_of_bool(), + // span: self.span.clone(), + // }), + // then: Box::new(then_node), + // r#else: Some(Box::new(block)), + // }, + // return_type: branch_return_type_id, + // span: self.span.clone(), + // }; + // } + + // if RADIX_TRIE_DEBUG { + // println!("return wildcard branch"); + // } + + // Ok(block) + // } + + // fn generate_radix_trie(&self, branches: &[(String, usize)]) -> Result { + // let mut nodes = vec![TrieNode::default()]; + + // for (b, i) in branches.iter() { + // let mut current = 0; + // for c in b.chars() { + // let c = c.to_string(); + // if let Some(next) = nodes[current].next.get(&c) { + // current = *next; + // continue; + // } + + // let next = nodes.len(); + // nodes[current].next.insert(c, next); + // current = next; + // nodes.push(TrieNode::default()); + // } + + // nodes[current].output = Some(*i); + // } + + // // compress trie + // let mut q = vec![0]; + // while let Some(i) = q.pop() { + // let mut current = nodes[i].clone(); + // if current.next.len() == 1 { + // let edge = current.next.pop_first().unwrap(); + // let mut next = nodes[edge.1].clone(); + // if next.next.len() == 1 { + // let next_edge = next.next.pop_first().unwrap(); + // let compressed_key = format!("{}{}", edge.0, next_edge.0); + + // nodes[i].next.clear(); + // nodes[i].next.insert(compressed_key, next_edge.1); + // nodes[i].output = next.output.take(); + + // q.push(i); + // } else { + // nodes[edge.1].previous = Some(i); + // q.push(edge.1); + // } + // } else { + // for (_, v) in current.next.iter() { + // nodes[*v].previous = Some(i); + // q.push(*v); + // } + // } + // } + + // Ok(Trie { nodes }) + // } + + // #[allow(clippy::too_many_arguments)] + // fn generate_radix_tree_checks( + // &self, + // ctx: TypeCheckContext<'_>, + // matched_value: &TyExpression, + // branch_return_type_id: TypeId, + // wildcard_return_expr: TyExpression, + // trie: Trie, + // packed_strings: &str, + // ) -> Result { + // let type_engine = ctx.engines.te(); + + // let packed_strings_expr = TyExpression { + // expression: TyExpressionVariant::Literal(crate::language::Literal::String( + // Span::from_string(packed_strings.to_string()), + // )), + // return_type: type_engine.id_of_string_slice(), + // span: Span::dummy(), + // }; + + // let expr = self.generate_radrix_trie_code( + // matched_value, + // packed_strings, + // &packed_strings_expr, + // &trie.nodes, + // 0, + // 0, + // type_engine.id_of_bool(), + // type_engine.id_of_u64(), + // branch_return_type_id, + // 1, + // wildcard_return_expr, + // ); + + // Ok(expr) + // } + + // #[allow(clippy::too_many_arguments)] + // fn generate_radrix_trie_code( + // &self, + // matched_value: &TyExpression, + // packed_strings: &str, + // packed_strings_expr: &TyExpression, + // nodes: &[TrieNode], + // slice_pos: usize, + // current_node_index: usize, + // bool_type_id: TypeId, + // u64_type_id: TypeId, + // branch_return_type_id: TypeId, + // depth: usize, + // block_when_all_fail: TyExpression, + // ) -> TyExpression { + // let current = &nodes[current_node_index]; + + // if let Some(output) = current.output { + // assert!(current.next.is_empty()); + + // if RADIX_TRIE_DEBUG { + // println!("{}return branch {:?}", " ".repeat(depth * 4), output); + // } + + // let branch = &self.branches[output]; + // return branch.result.clone(); + // } + + // let mut block = block_when_all_fail.clone(); + + // for (prefix, next_node_index) in current.next.iter().rev() { + // let start = current_node_index; + // let end = current_node_index + prefix.len(); + // let eq_len: u64 = end as u64 - start as u64; + + // let prefix_pos = packed_strings + // .find(prefix) + // .expect("prefix should be inside this string"); + + // if RADIX_TRIE_DEBUG { + // println!( + // "{}if str[{start}..{end}] == \"{prefix}\" at packed_string[{prefix_pos}]", + // " ".repeat(depth * 4), + // ); + // } + + // let then_node = self.generate_radrix_trie_code( + // matched_value, + // packed_strings, + // packed_strings_expr, + // nodes, + // end, + // *next_node_index, + // bool_type_id, + // u64_type_id, + // branch_return_type_id, + // depth + 1, + // block_when_all_fail.clone(), + // ); + + // let prefix_pos = packed_strings + // .find(prefix) + // .expect("prefix should be inside this string"); + + // let expression = TyExpressionVariant::AsmExpression { + // registers: vec![ + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("slice".into()), + // initializer: Some(matched_value.clone()), + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("prefix".into()), + // initializer: Some(packed_strings_expr.clone()), + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("slice_ptr".into()), + // initializer: None, + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("prefix_ptr".into()), + // initializer: None, + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("len".into()), + // initializer: Some(TyExpression { + // expression: TyExpressionVariant::Literal( + // crate::language::Literal::U64(eq_len), + // ), + // return_type: u64_type_id, + // span: Span::dummy(), + // }), + // }, + // TyAsmRegisterDeclaration { + // name: Ident::new_no_span("is_eq".into()), + // initializer: None, + // }, + // ], + // body: vec![ + // AsmOp { + // op_name: Ident::new_no_span("lw".into()), + // op_args: vec![ + // BaseIdent::new_no_span("slice_ptr".into()), + // BaseIdent::new_no_span("slice".into()), + // ], + // immediate: Some(BaseIdent::new_no_span("i0".into())), + // span: Span::dummy(), + // }, + // AsmOp { + // op_name: Ident::new_no_span("addi".into()), + // op_args: vec![ + // BaseIdent::new_no_span("slice_ptr".into()), + // BaseIdent::new_no_span("slice_ptr".into()), + // ], + // immediate: Some(BaseIdent::new_no_span(format!("i{slice_pos}"))), + // span: Span::dummy(), + // }, + // AsmOp { + // op_name: Ident::new_no_span("lw".into()), + // op_args: vec![ + // BaseIdent::new_no_span("prefix_ptr".into()), + // BaseIdent::new_no_span("prefix".into()), + // ], + // immediate: Some(BaseIdent::new_no_span("i0".into())), + // span: Span::dummy(), + // }, + // AsmOp { + // op_name: Ident::new_no_span("addi".into()), + // op_args: vec![ + // BaseIdent::new_no_span("prefix_ptr".into()), + // BaseIdent::new_no_span("prefix_ptr".into()), + // ], + // immediate: Some(BaseIdent::new_no_span(format!("i{prefix_pos}"))), + // span: Span::dummy(), + // }, + // AsmOp { + // op_name: Ident::new_no_span("meq".into()), + // op_args: vec![ + // BaseIdent::new_no_span("is_eq".into()), + // BaseIdent::new_no_span("slice_ptr".into()), + // BaseIdent::new_no_span("prefix_ptr".into()), + // BaseIdent::new_no_span("len".into()), + // ], + // immediate: None, + // span: Span::dummy(), + // }, + // ], + // returns: Some(( + // AsmRegister { + // name: "is_eq".into(), + // }, + // Span::dummy(), + // )), + // whole_block_span: Span::dummy(), + // }; + + // block = TyExpression { + // expression: TyExpressionVariant::IfExp { + // condition: Box::new(TyExpression { + // expression, + // return_type: bool_type_id, + // span: Span::dummy(), + // }), + // then: Box::new(then_node), + // r#else: Some(Box::new(block)), + // }, + // return_type: branch_return_type_id, + // span: Span::dummy(), + // }; + // } + + // if RADIX_TRIE_DEBUG { + // println!("{}return wildcard branch", " ".repeat(depth * 4),); + // } + + // block + // } fn desugar_to_typed_if_expression( &self, From 00d810d40ff12b78fd0fb3075b8b661aee6d8e3f Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 26 Oct 2025 13:15:35 -0300 Subject: [PATCH 13/18] update test snapshot --- .../language/array/array_repeat/stdout.snap | 106 +++++------ .../attributes_deprecated/stdout.snap | 22 +-- .../configurable_dedup_decode/stdout.snap | 62 +++---- .../match_expressions_all/stdout.snap | 155 +++++----------- .../panicking_contract/stdout.snap | 133 +++++++++++++- .../const_of_contract_call/stdout.snap | 171 ++++++++++++------ 6 files changed, 389 insertions(+), 260 deletions(-) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap index 176de197a7e..15f6e0847a4 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/array/array_repeat/stdout.snap @@ -1115,12 +1115,12 @@ script { !182 = span !160 1257 1262 !183 = (!157 !158 !179 !180 !182) !184 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/codec.sw" -!185 = span !184 70930 71103 -!186 = fn_name_span !184 70937 70947 +!185 = span !184 70988 71161 +!186 = fn_name_span !184 70995 71005 !187 = (!185 !186 !69) -!188 = span !184 71045 71049 -!189 = span !184 71045 71055 -!190 = fn_call_path_span !184 71050 71053 +!188 = span !184 71103 71107 +!189 = span !184 71103 71113 +!190 = fn_call_path_span !184 71108 71111 !191 = (!189 !190) !192 = span !160 2922 2926 !193 = (!189 !190 !192) @@ -1131,9 +1131,9 @@ script { !198 = (!189 !190 !194 !195 !197) !199 = span !160 2928 2929 !200 = (!189 !190 !199) -!201 = span !184 71057 71061 -!202 = span !184 71057 71073 -!203 = fn_call_path_span !184 71062 71065 +!201 = span !184 71115 71119 +!202 = span !184 71115 71131 +!203 = fn_call_path_span !184 71120 71123 !204 = (!202 !203) !205 = span !160 3420 3424 !206 = (!202 !203 !205) @@ -1155,39 +1155,39 @@ script { !222 = (!202 !203 !213 !214 !221) !223 = (!202 !203 !213 !214) !224 = (!202 !203 !213 !214) -!225 = span !184 71020 71074 -!226 = fn_call_path_span !184 71020 71044 +!225 = span !184 71078 71132 +!226 = fn_call_path_span !184 71078 71102 !227 = (!225 !226) !228 = span !184 750 753 !229 = (!225 !226 !228) !230 = span !184 735 755 !231 = (!225 !226 !230) -!232 = span !184 71003 71075 -!233 = span !184 71094 71100 -!234 = span !184 71080 71101 -!235 = fn_call_path_span !184 71080 71093 +!232 = span !184 71061 71133 +!233 = span !184 71152 71158 +!234 = span !184 71138 71159 +!235 = fn_call_path_span !184 71138 71151 !236 = (!234 !235) -!237 = span !184 89756 89796 +!237 = span !184 89814 89854 !238 = (!234 !235 !237) -!239 = span !184 89776 89796 +!239 = span !184 89834 89854 !240 = (!234 !235 !237) -!241 = span !184 89822 89835 +!241 = span !184 89880 89893 !242 = (!234 !235 !241) -!243 = span !184 89806 89836 +!243 = span !184 89864 89894 !244 = (!234 !235 !243) -!245 = span !184 89921 89926 +!245 = span !184 89979 89984 !246 = (!234 !235 !245) -!247 = span !184 89845 89928 +!247 = span !184 89903 89986 !248 = (!234 !235 !247) !249 = (!234 !235 !247) -!250 = span !184 89938 89952 +!250 = span !184 89996 90010 !251 = (!234 !235 !250) -!252 = span !184 89950 89951 +!252 = span !184 90008 90009 !253 = (!234 !235 !250) -!254 = span !184 89968 89969 +!254 = span !184 90026 90027 !255 = (!234 !235 !254) -!256 = span !184 89968 89973 -!257 = fn_call_path_span !184 89970 89971 +!256 = span !184 90026 90031 +!257 = fn_call_path_span !184 90028 90029 !258 = (!234 !235 !256 !257) !259 = (!234 !235 !256 !257) !260 = (!234 !235 !256 !257) @@ -1198,27 +1198,27 @@ script { !265 = (!234 !235 !256 !257 !264) !266 = (!234 !235 !256 !257) !267 = (!234 !235 !256 !257) -!268 = span !184 90017 90022 +!268 = span !184 90075 90080 !269 = (!234 !235 !268) -!270 = span !184 90024 90025 +!270 = span !184 90082 90083 !271 = (!234 !235 !270) -!272 = span !184 89988 90027 +!272 = span !184 90046 90085 !273 = (!234 !235 !272) !274 = (!234 !235 !272) -!275 = span !184 90048 90054 +!275 = span !184 90106 90112 !276 = (!234 !235 !275) -!277 = span !184 90048 90068 -!278 = fn_call_path_span !184 90055 90061 +!277 = span !184 90106 90126 +!278 = fn_call_path_span !184 90113 90119 !279 = (!234 !235 !277 !278) !280 = span !184 3973 3977 !281 = (!234 !235 !277 !278 !280) !282 = span !184 3959 3978 !283 = fn_call_path_span !184 3959 3972 !284 = (!234 !235 !277 !278 !282 !283) -!285 = span !184 72720 72726 +!285 = span !184 72778 72784 !286 = (!234 !235 !277 !278 !282 !283 !285) -!287 = span !184 72720 72739 -!288 = fn_call_path_span !184 72727 72731 +!287 = span !184 72778 72797 +!288 = fn_call_path_span !184 72785 72789 !289 = (!234 !235 !277 !278 !282 !283 !287 !288) !290 = span !184 3371 3399 !291 = (!234 !235 !277 !278 !282 !283 !287 !288 !290) @@ -1333,17 +1333,17 @@ script { !400 = (!234 !235 !277 !278 !282 !283 !287 !288 !371 !372) !401 = (!234 !235 !277 !278 !282 !283 !287 !288) !402 = (!234 !235 !277 !278 !282 !283 !287 !288) -!403 = span !184 90041 90045 +!403 = span !184 90099 90103 !404 = (!234 !235 !403) -!405 = span !184 90040 90068 +!405 = span !184 90098 90126 !406 = (!234 !235 !405) -!407 = span !184 90082 90083 +!407 = span !184 90140 90141 !408 = (!234 !235 !407) -!409 = span !184 90082 90088 -!410 = fn_call_path_span !184 90084 90086 +!409 = span !184 90140 90146 +!410 = fn_call_path_span !184 90142 90144 !411 = (!234 !235 !409 !410) !412 = (!234 !235 !409 !410) -!413 = span !184 90087 90088 +!413 = span !184 90145 90146 !414 = (!234 !235 !409 !410) !415 = span !28 1322 1326 !416 = (!234 !235 !409 !410 !415) @@ -1354,7 +1354,7 @@ script { !421 = (!234 !235 !409 !410) !422 = (!234 !235 !409) !423 = (!234 !235 !409) -!424 = span !184 90110 90115 +!424 = span !184 90168 90173 !425 = (!234 !235 !424) !426 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert/src/logging.sw" !427 = span !426 591 596 @@ -1362,10 +1362,10 @@ script { !429 = fn_name_span !426 584 587 !430 = (!428 !429) !431 = span !426 642 647 -!432 = span !184 70852 70856 +!432 = span !184 70910 70914 !433 = (!431 !432) -!434 = span !184 70868 70881 -!435 = fn_call_path_span !184 70868 70879 +!434 = span !184 70926 70939 +!435 = fn_call_path_span !184 70926 70937 !436 = (!431 !434 !435) !437 = (!431 !434 !435) !438 = (!431 !434 !435) @@ -1377,11 +1377,11 @@ script { !444 = span !184 191 254 !445 = (!431 !434 !435 !444) !446 = (!431 !434 !435) -!447 = span !184 70852 70882 -!448 = fn_call_path_span !184 70857 70867 +!447 = span !184 70910 70940 +!448 = fn_call_path_span !184 70915 70925 !449 = (!431 !447 !448) !450 = (!431 !447 !448) -!451 = span !184 5301 5307 +!451 = span !184 5359 5365 !452 = (!431 !447 !448 !451) !453 = span !184 87 114 !454 = (!431 !447 !448 !453) @@ -1392,7 +1392,7 @@ script { !459 = (!431 !447 !448) !460 = (!431 !447 !448) !461 = (!431 !447 !448) -!462 = span !184 5316 5320 +!462 = span !184 5374 5378 !463 = (!431 !447 !448 !462) !464 = (!431 !447 !448) !465 = (!431 !447 !448) @@ -1409,15 +1409,15 @@ script { !476 = (!431 !447 !448) !477 = (!431 !447 !448) !478 = (!431 !447 !448) -!479 = span !184 5249 5332 +!479 = span !184 5307 5390 !480 = (!431 !447 !448 !479) !481 = (!431 !447 !448) -!482 = span !184 70839 70883 +!482 = span !184 70897 70941 !483 = (!431 !482) -!484 = span !184 70888 70894 +!484 = span !184 70946 70952 !485 = (!431 !484) -!486 = span !184 70888 70909 -!487 = fn_call_path_span !184 70895 70907 +!486 = span !184 70946 70967 +!487 = fn_call_path_span !184 70953 70965 !488 = (!431 !486 !487) !489 = span !184 573 577 !490 = (!431 !486 !487 !489) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/stdout.snap index cc80fbe2efe..b88db32e087 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/stdout.snap @@ -164,22 +164,22 @@ warning: Struct field is deprecated ____ warning: Function is deprecated - --> test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/src/main..sw:5:15 - | + --> test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/src/main..sw:12:15 + | ... -5 | let _result = __contract_entry_deprecated_to_be_abi_method(); - | -------------------------------------------- Function "deprecated_to_be_abi_method" is deprecated. - | +12 | let _result = __contract_entry_deprecated_to_be_abi_method(); + | -------------------------------------------- Function "deprecated_to_be_abi_method" is deprecated. + | ____ warning: Function is deprecated - --> test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/src/main..sw:9:15 - | + --> test/src/e2e_vm_tests/test_programs/should_pass/language/attributes_deprecated/src/main..sw:18:15 + | ... -9 | let _result = __contract_entry_deprecated_abi_provided_method(); - | ----------------------------------------------- Function "deprecated_abi_provided_method" is deprecated. - | +18 | let _result = __contract_entry_deprecated_abi_provided_method(); + | ----------------------------------------------- Function "deprecated_abi_provided_method" is deprecated. + | ____ Compiled contract "attributes_deprecated" with 19 warnings. - Finished release [optimized + fuel] target(s) [872 B] in ??? + Finished release [optimized + fuel] target(s) [480 B] in ??? diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap index 5526fc5bfb3..876bf6a3e70 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/stdout.snap @@ -209,27 +209,27 @@ script { !1 = span !0 177 182 !2 = span !0 136 143 !3 = "sway-lib-std/src/codec.sw" -!4 = span !3 71152 71155 -!5 = span !3 71166 71169 -!6 = span !3 71176 71182 -!7 = span !3 71122 71455 -!8 = fn_name_span !3 71129 71148 +!4 = span !3 71210 71213 +!5 = span !3 71224 71227 +!6 = span !3 71234 71240 +!7 = span !3 71180 71513 +!8 = fn_name_span !3 71187 71206 !9 = inline "never" !10 = (!7 !8 !9) -!11 = span !3 71240 71274 -!12 = fn_call_path_span !3 71240 71264 +!11 = span !3 71298 71332 +!12 = fn_call_path_span !3 71298 71322 !13 = span !3 735 755 !14 = (!11 !12 !13) !15 = (!11 !12) !16 = (!11 !12 !13) -!17 = span !3 71223 71275 -!18 = span !3 71305 71311 -!19 = span !3 71291 71312 -!20 = fn_call_path_span !3 71291 71304 -!21 = span !3 115325 115346 -!22 = fn_call_path_span !3 115325 115338 -!23 = span !3 71904 71932 -!24 = fn_call_path_span !3 71911 71923 +!17 = span !3 71281 71333 +!18 = span !3 71363 71369 +!19 = span !3 71349 71370 +!20 = fn_call_path_span !3 71349 71362 +!21 = span !3 115383 115404 +!22 = fn_call_path_span !3 115383 115396 +!23 = span !3 71962 71990 +!24 = fn_call_path_span !3 71969 71981 !25 = span !3 625 637 !26 = (!19 !20 !21 !22 !23 !24 !25) !27 = (!19 !20 !21 !22 !23 !24) @@ -241,15 +241,15 @@ script { !33 = (!19 !20 !21 !22 !23 !24) !34 = span !3 2857 2896 !35 = (!19 !20 !21 !22 !23 !24 !34) -!36 = span !3 115324 115349 +!36 = span !3 115382 115407 !37 = (!19 !20 !36) !38 = (!19 !20 !36) !39 = (!19 !20 !36) -!40 = span !3 71280 71313 -!41 = span !3 71371 71375 -!42 = span !3 71361 71376 -!43 = span !3 71318 71453 -!44 = span !3 71426 71446 +!40 = span !3 71338 71371 +!41 = span !3 71429 71433 +!42 = span !3 71419 71434 +!43 = span !3 71376 71511 +!44 = span !3 71484 71504 !45 = "test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_dedup_decode/src/main..sw" !46 = span !45 0 127 !47 = fn_name_span !45 7 14 @@ -259,8 +259,8 @@ script { !51 = (!49 !50) !52 = span !45 91 113 !53 = fn_call_path_span !45 91 97 -!54 = span !3 70868 70881 -!55 = fn_call_path_span !3 70868 70879 +!54 = span !3 70926 70939 +!55 = fn_call_path_span !3 70926 70937 !56 = (!52 !53 !54 !55) !57 = (!52 !53 !54 !55) !58 = (!52 !53 !54 !55) @@ -272,10 +272,10 @@ script { !64 = span !3 191 254 !65 = (!52 !53 !54 !55 !64) !66 = (!52 !53 !54 !55) -!67 = span !3 70852 70882 -!68 = fn_call_path_span !3 70857 70867 +!67 = span !3 70910 70940 +!68 = fn_call_path_span !3 70915 70925 !69 = (!52 !53 !67 !68) -!70 = span !3 4768 4774 +!70 = span !3 4826 4832 !71 = (!52 !53 !67 !68 !70) !72 = span !3 87 114 !73 = (!52 !53 !67 !68 !72) @@ -299,15 +299,15 @@ script { !91 = (!52 !53 !67 !68) !92 = (!52 !53 !67 !68) !93 = (!52 !53 !67 !68) -!94 = span !3 4716 4799 +!94 = span !3 4774 4857 !95 = (!52 !53 !67 !68 !94) !96 = (!52 !53 !67 !68) -!97 = span !3 70839 70883 +!97 = span !3 70897 70941 !98 = (!52 !53 !97) -!99 = span !3 70888 70894 +!99 = span !3 70946 70952 !100 = (!52 !53 !99) -!101 = span !3 70888 70909 -!102 = fn_call_path_span !3 70895 70907 +!101 = span !3 70946 70967 +!102 = fn_call_path_span !3 70953 70965 !103 = (!52 !53 !101 !102) !104 = span !3 573 577 !105 = (!52 !53 !101 !102 !104) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap index ae8d21c05db..11088732398 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all/stdout.snap @@ -7,119 +7,62 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-assert) Compiling script match_expressions_all (test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all) -let packed_string = "get_a_b" -if str.len() == 5 - if str[0..4] == "get_" at packed_string[0] - if str[4..5] == "b" at packed_string[6] - return branch 2 - if str[4..5] == "a" at packed_string[4] - return branch 0 - return wildcard branch - return wildcard branch -if str.len() == 7 - if str[0..7] == "get_a_b" at packed_string[0] - return branch 1 - return wildcard branch -return wildcard branch -let packed_string = "get_a_b" -if str.len() == 5 - if str[0..4] == "get_" at packed_string[0] - if str[4..5] == "b" at packed_string[6] - return branch 2 - if str[4..5] == "a" at packed_string[4] - return branch 0 - return wildcard branch - return wildcard branch -if str.len() == 7 - if str[0..7] == "get_a_b" at packed_string[0] - return branch 1 - return wildcard branch -return wildcard branch - Finished debug [unoptimized + fuel] target(s) [2.736 KB] in ??? + Finished debug [unoptimized + fuel] target(s) [3.072 KB] in ??? > forc build --path test/src/e2e_vm_tests/test_programs/should_pass/language/match_expressions_all --ir final --asm final | filter-fn match_expressions_all return_match_on_str_slice pshl i15 ; save registers 16..40 pshh i524288 ; save registers 40..64 move $$locbase $sp ; save locals base register for function return_match_on_str_slice_8 -cfei i144 ; allocate 144 bytes for locals and 0 slots for call arguments -move $r3 $$reta ; save return address -addi $r0 $$locbase i128 ; get offset to local __ptr slice -mcpi $r0 $$arg0 i16 ; copy memory -movi $r1 i7 ; initialize constant into register -lw $r0 $$locbase i17 -eq $r0 $r0 $r1 -jnzf $r0 $zero i55 -movi $r1 i5 ; initialize constant into register -lw $r0 $$locbase i17 -eq $r0 $r0 $r1 -movi $r1 i1000 ; initialize constant into register -jnzf $r0 $zero i1 -jmpf $zero i48 -addr $r0 data_NonConfigurable_9; get __const_global0's address in data section -addi $r1 $$locbase i32 ; get offset to local __ptr { ptr, u64 } -sw $$locbase $r0 i4 ; store word -movi $r0 i7 ; initialize constant into register -sw $$locbase $r0 i5 ; store word -addi $r0 $$locbase i48 ; get offset to local __ptr slice -mcpi $r0 $r1 i16 ; copy memory -movi $r2 i4 ; initialize constant into register -lw $r0 $$locbase i16 -addi $r0 $r0 i0 -lw $r1 $$locbase i6 -addi $r1 $r1 i0 -meq $r0 $r0 $r1 $r2 -movi $r1 i1000 ; initialize constant into register -jnzf $r0 $zero i1 -jmpf $zero i31 -addr $r0 data_NonConfigurable_9; get __const_global1's address in data section -addi $r1 $$locbase i64 ; get offset to local __ptr { ptr, u64 } -sw $$locbase $r0 i8 ; store word -movi $r0 i7 ; initialize constant into register -sw $$locbase $r0 i9 ; store word -addi $r0 $$locbase i80 ; get offset to local __ptr slice -mcpi $r0 $r1 i16 ; copy memory -lw $r0 $$locbase i16 -addi $r0 $r0 i4 -lw $r1 $$locbase i10 -addi $r1 $r1 i4 -meq $r0 $r0 $r1 $one -move $r1 $one ; move parameter from branch to block argument -jnzf $r0 $zero i16 -addr $r0 data_NonConfigurable_9; get __const_global2's address in data section -addi $r1 $$locbase i96 ; get offset to local __ptr { ptr, u64 } -sw $$locbase $r0 i12 ; store word -movi $r0 i7 ; initialize constant into register -sw $$locbase $r0 i13 ; store word -addi $r0 $$locbase i112 ; get offset to local __ptr slice -mcpi $r0 $r1 i16 ; copy memory -lw $r0 $$locbase i16 -addi $r0 $r0 i4 -lw $r1 $$locbase i14 -addi $r1 $r1 i6 -meq $r0 $r0 $r1 $one -movi $r1 i3 ; initialize constant into register -jnzf $r0 $zero i1 -movi $r1 i1000 ; initialize constant into register -jmpf $zero i16 -addr $r0 data_NonConfigurable_9; get __const_global's address in data section -sw $$locbase $r0 i0 ; store word -movi $r0 i7 ; initialize constant into register -sw $$locbase $r0 i1 ; store word -addi $r0 $$locbase i16 ; get offset to local __ptr slice -mcpi $r0 $$locbase i16 ; copy memory +cfei i112 ; allocate 112 bytes for locals and 0 slots for call arguments +move $r0 $$arg0 ; save argument 0 (param) +move $r1 $$reta ; save return address +addi $r2 $$locbase i96 ; get offset to local __ptr slice +mcpi $r2 $$arg0 i16 ; copy memory +addr $r2 data_NonConfigurable_7; get __const_global's address in data section +sw $$locbase $r2 i0 ; store word +movi $r2 i5 ; initialize constant into register +sw $$locbase $r2 i1 ; store word +addi $r2 $$locbase i16 ; get offset to local __ptr slice +mcpi $r2 $$locbase i16 ; copy memory +addi $r2 $$locbase i16 ; get offset to local __ptr slice +move $$arg0 $r0 ; [call]: pass argument 0 +move $$arg1 $r2 ; [call]: pass argument 1 +jal $$reta $pc i40 ; [call]: call eq_9 +move $r0 $one ; move parameter from branch to block argument +jnzf $$retv $zero i31 +addi $r0 $$locbase i96 ; get offset to local __ptr slice +addr $r2 data_NonConfigurable_9; get __const_global0's address in data section +addi $r3 $$locbase i32 ; get offset to local __ptr { ptr, u64 } +sw $$locbase $r2 i4 ; store word movi $r2 i7 ; initialize constant into register -lw $r0 $$locbase i16 -addi $r0 $r0 i0 -lw $r1 $$locbase i2 -addi $r1 $r1 i0 -meq $r0 $r0 $r1 $r2 -movi $r1 i2 ; initialize constant into register -jnzf $r0 $zero i1 -movi $r1 i1000 ; initialize constant into register -move $$retv $r1 ; set return value -cfsi i144 ; free 144 bytes for locals and 0 slots for extra call arguments -move $$reta $r3 ; restore return address +sw $$locbase $r2 i5 ; store word +addi $r2 $$locbase i48 ; get offset to local __ptr slice +mcpi $r2 $r3 i16 ; copy memory +addi $r2 $$locbase i48 ; get offset to local __ptr slice +move $$arg0 $r0 ; [call]: pass argument 0 +move $$arg1 $r2 ; [call]: pass argument 1 +jal $$reta $pc i25 ; [call]: call eq_9 +movi $r0 i2 ; initialize constant into register +jnzf $$retv $zero i16 +addi $r0 $$locbase i96 ; get offset to local __ptr slice +addr $r2 data_NonConfigurable_10; get __const_global1's address in data section +addi $r3 $$locbase i64 ; get offset to local __ptr { ptr, u64 } +sw $$locbase $r2 i8 ; store word +movi $r2 i5 ; initialize constant into register +sw $$locbase $r2 i9 ; store word +addi $r2 $$locbase i80 ; get offset to local __ptr slice +mcpi $r2 $r3 i16 ; copy memory +addi $r2 $$locbase i80 ; get offset to local __ptr slice +move $$arg0 $r0 ; [call]: pass argument 0 +move $$arg1 $r2 ; [call]: pass argument 1 +jal $$reta $pc i10 ; [call]: call eq_9 +movi $r0 i3 ; initialize constant into register +jnzf $$retv $zero i1 +movi $r0 i1000 ; initialize constant into register +move $$retv $r0 ; set return value +cfsi i112 ; free 112 bytes for locals and 0 slots for extra call arguments +move $$reta $r1 ; restore return address poph i524288 ; restore registers 40..64 popl i15 ; restore registers 16..40 jal $zero $$reta i0 ; return from call diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap index bbd404dfe9d..8dbc150853b 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap @@ -8,11 +8,12 @@ output: Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling library panicking_lib (test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_lib) Compiling contract panicking_contract (test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract) - Finished debug [unoptimized + fuel] target(s) [8.88 KB] in ??? + Finished debug [unoptimized + fuel] target(s) [8.584 KB] in ??? Running 12 tests, filtered 0 tests tested -- panicking_contract +<<<<<<< HEAD test test_panicking_in_contract_self_impl ... ok (???, 11571 gas) revert code: 8000000000000001 ├─ panic message: panicking in contract self impl @@ -20,14 +21,28 @@ tested -- panicking_contract │ └─ at panicking_contract@1.2.3, src/main.sw:22:9 test test_directly_panicking_method ... ok (???, 12853 gas) revert code: 8080000000000002 +======= + test test_panicking_in_contract_self_impl ... ok (???, 794 gas) + revert code: 828000000000000c + ├─ panic message: panicking in contract self impl + ├─ panicked: in ::panicking_in_contract_self_impl + │ └─ at panicking_contract@1.2.3, src/main.sw:22:9 + test test_directly_panicking_method ... ok (???, 1156 gas) + revert code: 820000000000000b +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error C. ├─ panic value: C(true) ├─ panicked: in ::directly_panicking_method │ └─ at panicking_contract@1.2.3, src/main.sw:28:9 decoded log values: C(true), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_inlined ... ok (???, 15735 gas) revert code: 830000000540a013 +======= + test test_nested_panic_inlined ... ok (???, 1578 gas) + revert code: 8000000000c01001 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) ├─ panicked: in panicking_lib::nested_panic_inlined @@ -38,8 +53,13 @@ C(true), log rb: 5503570629422409978 └─ at panicking_contract@1.2.3, src/main.sw:32:9 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_inlined_same_revert_code ... ok (???, 15735 gas) revert code: 830000000540a013 +======= + test test_nested_panic_inlined_same_revert_code ... ok (???, 1578 gas) + revert code: 8000000000c01001 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) ├─ panicked: in panicking_lib::nested_panic_inlined @@ -50,8 +70,13 @@ E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString └─ at panicking_contract@1.2.3, src/main.sw:32:9 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_non_inlined ... ok (???, 16289 gas) revert code: 838000000680c818 +======= + test test_nested_panic_non_inlined ... ok (???, 1638 gas) + revert code: 8180000002804808 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) ├─ panicked: in panicking_lib::nested_panic_non_inlined @@ -62,8 +87,13 @@ E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString └─ at panicking_contract@1.2.3, src/main.sw:40:9 decoded log values: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_non_inlined_same_revert_code ... ok (???, 16289 gas) revert code: 838000000680c818 +======= + test test_nested_panic_non_inlined_same_revert_code ... ok (???, 1638 gas) + revert code: 8180000002804808 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) ├─ panicked: in panicking_lib::nested_panic_non_inlined @@ -74,8 +104,13 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:40:9 decoded log values: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 +<<<<<<< HEAD test test_generic_panic_with_unit ... ok (???, 14026 gas) revert code: 828000000000800f +======= + test test_generic_panic_with_unit ... ok (???, 909 gas) + revert code: 8100000000003806 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic value: () ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -83,8 +118,13 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:48:9 decoded log values: (), log rb: 3330666440490685604 +<<<<<<< HEAD test test_generic_panic_with_unit_same_revert_code ... ok (???, 14026 gas) revert code: 828000000000800f +======= + test test_generic_panic_with_unit_same_revert_code ... ok (???, 909 gas) + revert code: 8100000000003806 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic value: () ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -92,8 +132,13 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:48:9 decoded log values: (), log rb: 3330666440490685604 +<<<<<<< HEAD test test_generic_panic_with_str ... ok (???, 13958 gas) revert code: 818000000000700d +======= + test test_generic_panic_with_str ... ok (???, 1002 gas) + revert code: 8080000000002804 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: generic panic with string ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -101,8 +146,13 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:56:9 decoded log values: AsciiString { data: "generic panic with string" }, log rb: 10098701174489624218 +<<<<<<< HEAD test test_generic_panic_with_different_str_same_revert_code ... ok (???, 13190 gas) revert code: 8180000000004007 +======= + test test_generic_panic_with_different_str_same_revert_code ... ok (???, 1122 gas) + revert code: 808000000000d019 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: generic panic with different string ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -110,8 +160,13 @@ AsciiString { data: "generic panic with string" }, log rb: 10098701174489624218 └─ at panicking_contract@1.2.3, src/main.sw:60:9 decoded log values: AsciiString { data: "generic panic with different string" }, log rb: 10098701174489624218 +<<<<<<< HEAD test test_generic_panic_with_error_type_enum ... ok (???, 13475 gas) revert code: 8200000000005009 +======= + test test_generic_panic_with_error_type_enum ... ok (???, 1093 gas) + revert code: 830000000000700d +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error A. ├─ panic value: A ├─ panicked: in panicking_lib::generic_panic @@ -120,8 +175,13 @@ AsciiString { data: "generic panic with different string" }, log rb: 10098701174 └─ at panicking_contract@1.2.3, src/main.sw:64:9 decoded log values: A, log rb: 5503570629422409978 +<<<<<<< HEAD test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 13867 gas) revert code: 820000000000600b +======= + test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 1244 gas) + revert code: 830000000000e01b +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error B. ├─ panic value: B(42) ├─ panicked: in panicking_lib::generic_panic @@ -142,11 +202,12 @@ output: Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling library panicking_lib (test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_lib) Compiling contract panicking_contract (test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract) - Finished release [optimized + fuel] target(s) [7.4 KB] in ??? + Finished release [optimized + fuel] target(s) [6.576 KB] in ??? Running 12 tests, filtered 0 tests tested -- panicking_contract +<<<<<<< HEAD test test_panicking_in_contract_self_impl ... ok (???, 10831 gas) revert code: 8000000000000000 ├─ panic message: panicking in contract self impl @@ -154,28 +215,48 @@ tested -- panicking_contract └─ at panicking_contract@1.2.3, src/main.sw:22:9 test test_directly_panicking_method ... ok (???, 11938 gas) revert code: 8080000000000000 +======= + test test_panicking_in_contract_self_impl ... ok (???, 488 gas) + revert code: 8280000000000000 + ├─ panic message: panicking in contract self impl + └─ panicked: in ::panicking_in_contract_self_impl + └─ at panicking_contract@1.2.3, src/main.sw:22:9 + test test_directly_panicking_method ... ok (???, 800 gas) + revert code: 8200000000000000 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error C. ├─ panic value: C(true) └─ panicked: in ::directly_panicking_method └─ at panicking_contract@1.2.3, src/main.sw:28:9 decoded log values: C(true), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_inlined ... ok (???, 14064 gas) revert code: 8300000000000000 +======= + test test_nested_panic_inlined ... ok (???, 1182 gas) + revert code: 8000000000000000 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) └─ panicked: in panicking_lib::nested_panic_inlined └─ at panicking_lib, src/lib.sw:35:5 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_inlined_same_revert_code ... ok (???, 14064 gas) revert code: 8300000000000000 +======= + test test_nested_panic_inlined_same_revert_code ... ok (???, 1182 gas) + revert code: 8000000000000000 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) └─ panicked: in panicking_lib::nested_panic_inlined └─ at panicking_lib, src/lib.sw:35:5 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 +<<<<<<< HEAD test test_nested_panic_non_inlined ... ok (???, 14454 gas) revert code: 8380000000000000 ├─ panic message: Error E. @@ -207,29 +288,77 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d decoded log values: (), log rb: 3330666440490685604 test test_generic_panic_with_str ... ok (???, 12720 gas) +======= + test test_nested_panic_non_inlined ... ok (???, 1212 gas) +>>>>>>> 5f2f098c4 (update test snapshot) revert code: 8180000000000000 + ├─ panic message: Error E. + ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) + └─ panicked: in panicking_lib::nested_panic_non_inlined + └─ at panicking_lib, src/lib.sw:41:9 + decoded log values: +E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 + test test_nested_panic_non_inlined_same_revert_code ... ok (???, 1212 gas) + revert code: 8180000000000000 + ├─ panic message: Error E. + ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) + └─ panicked: in panicking_lib::nested_panic_non_inlined + └─ at panicking_lib, src/lib.sw:41:9 + decoded log values: +E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 + test test_generic_panic_with_unit ... ok (???, 604 gas) + revert code: 8100000000000000 + ├─ panic value: () + └─ panicked: in panicking_lib::generic_panic + └─ at panicking_lib, src/lib.sw:74:5 + decoded log values: +(), log rb: 3330666440490685604 + test test_generic_panic_with_unit_same_revert_code ... ok (???, 604 gas) + revert code: 8100000000000000 + ├─ panic value: () + └─ panicked: in panicking_lib::generic_panic + └─ at panicking_lib, src/lib.sw:74:5 + decoded log values: +(), log rb: 3330666440490685604 + test test_generic_panic_with_str ... ok (???, 710 gas) + revert code: 8080000000000000 ├─ panic message: generic panic with string └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: AsciiString { data: "generic panic with string" }, log rb: 10098701174489624218 +<<<<<<< HEAD test test_generic_panic_with_different_str_same_revert_code ... ok (???, 12186 gas) revert code: 8180000000000000 +======= + test test_generic_panic_with_different_str_same_revert_code ... ok (???, 750 gas) + revert code: 8080000000000000 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: generic panic with different string └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: AsciiString { data: "generic panic with different string" }, log rb: 10098701174489624218 +<<<<<<< HEAD test test_generic_panic_with_error_type_enum ... ok (???, 12364 gas) revert code: 8200000000000000 +======= + test test_generic_panic_with_error_type_enum ... ok (???, 745 gas) + revert code: 8300000000000000 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error A. ├─ panic value: A └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: A, log rb: 5503570629422409978 +<<<<<<< HEAD test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 12642 gas) revert code: 8200000000000000 +======= + test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 826 gas) + revert code: 8300000000000000 +>>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error B. ├─ panic value: B(42) └─ panicked: in panicking_lib::generic_panic diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index 7c6bb7e5841..a3e7c444f1f 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -2,6 +2,7 @@ source: test/src/snapshot/mod.rs --- <<<<<<< HEAD +<<<<<<< HEAD ======= <<<<<<< HEAD <<<<<<< HEAD @@ -27481,6 +27482,8 @@ contract { Finished release [optimized + fuel] target(s) [55.368 KB] in ??? >>>>>>> 58e204d50 (better tests to measure cost of contract calls) ======= +======= +>>>>>>> 5f2f098c4 (update test snapshot) > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 101 output: @@ -27490,6 +27493,7 @@ output: <<<<<<< HEAD <<<<<<< HEAD <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD Finished release [optimized + fuel] target(s) [40.528 KB] in ??? >>>>>>> dbd26f625 (bring whole snapshot test back) @@ -27518,6 +27522,9 @@ output: Finished release [optimized + fuel] target(s) [36.568 KB] in ??? >>>>>>> 62f7022c1 (improve method selection on contracts) >>>>>>> 7ad706b99 (improve method selection on contracts) +======= + Finished release [optimized + fuel] target(s) [32.624 KB] in ??? +>>>>>>> 5f2f098c4 (update test snapshot) Running 29 tests, filtered 0 tests tested -- const_of_contract_call @@ -27527,6 +27534,7 @@ tested -- const_of_contract_call <<<<<<< HEAD <<<<<<< HEAD <<<<<<< HEAD +<<<<<<< HEAD <<<<<<< HEAD test cost_of_in_bool ... ok (???, 14600 gas) test cost_of_in_u8 ... ok (???, 18427 gas) @@ -27599,6 +27607,37 @@ tested -- const_of_contract_call test in_enum_u64_u64 ... ok (???, 2528 gas) test in_enum_u64_u64_u64 ... ok (???, 2640 gas) >>>>>>> ce8248b66 (better tests to measure cost of contract calls) +======= + test cost_of_in_bool ... ok (???, 969 gas) + test cost_of_in_u8 ... ok (???, 952 gas) + test cost_of_in_u16 ... ok (???, 1017 gas) + test cost_of_in_u32 ... ok (???, 1152 gas) + test cost_of_in_u64 ... ok (???, 973 gas) + test cost_of_in_u256 ... ok (???, 1040 gas) + test cost_of_in_b256 ... ok (???, 1033 gas) + test cost_of_in_str_0 ... ok (???, 1028 gas) + test cost_of_in_str_1 ... ok (???, 1138 gas) + test cost_of_in_str_8 ... ok (???, 1146 gas) + test cost_of_in_str_16 ... ok (???, 1144 gas) + test cost_of_in_str_32 ... ok (???, 1149 gas) + test cost_of_in_array_0 ... FAILED (???, 866 gas) + test cost_of_in_array_1 ... ok (???, 1167 gas) + test cost_of_in_array_8 ... ok (???, 3251 gas) + test cost_of_in_array_16 ... ok (???, 4112 gas) + test cost_of_in_array_32 ... ok (???, 7277 gas) + test cost_of_in_array_64 ... ok (???, 13579 gas) + test cost_of_in_tuple_0 ... ok (???, 692 gas) + test cost_of_in_tuple_1 ... ok (???, 1071 gas) + test cost_of_in_tuple_2 ... ok (???, 1249 gas) + test cost_of_in_tuple_3 ... ok (???, 1398 gas) + test cost_of_in_tuple_4 ... ok (???, 1570 gas) + test in_struct_u64 ... ok (???, 1086 gas) + test in_struct_u64_u64 ... ok (???, 1245 gas) + test in_struct_u64_u64_u64 ... ok (???, 1398 gas) + test in_enum_u64 ... ok (???, 1286 gas) + test in_enum_u64_u64 ... ok (???, 1296 gas) + test in_enum_u64_u64_u64 ... ok (???, 1305 gas) +>>>>>>> 5f2f098c4 (update test snapshot) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 @@ -27620,12 +27659,16 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.768 KB] in ??? + Finished release [optimized + fuel] target(s) [1.48 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call +<<<<<<< HEAD test isolated_cost_of_in_array_0 ... FAILED (???, 10911 gas) +======= + test isolated_cost_of_in_array_0 ... FAILED (???, 623 gas) +>>>>>>> 5f2f098c4 (update test snapshot) failures: test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 @@ -27647,12 +27690,16 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.944 KB] in ??? + Finished release [optimized + fuel] target(s) [1.656 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call +<<<<<<< HEAD test isolated_cost_of_in_array_1 ... ok (???, 11355 gas) +======= + test isolated_cost_of_in_array_1 ... ok (???, 852 gas) +>>>>>>> 5f2f098c4 (update test snapshot) test result: OK. 1 passed; 0 failed; finished in ??? @@ -27667,12 +27714,16 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.968 KB] in ??? + Finished release [optimized + fuel] target(s) [1.688 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call +<<<<<<< HEAD test isolated_cost_of_in_array_16 ... ok (???, 15174 gas) +======= + test isolated_cost_of_in_array_16 ... ok (???, 2933 gas) +>>>>>>> 5f2f098c4 (update test snapshot) test result: OK. 1 passed; 0 failed; finished in ??? @@ -27687,12 +27738,16 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.968 KB] in ??? + Finished release [optimized + fuel] target(s) [1.688 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call +<<<<<<< HEAD test isolated_cost_of_in_array_32 ... ok (???, 19221 gas) +======= + test isolated_cost_of_in_array_32 ... ok (???, 5138 gas) +>>>>>>> 5f2f098c4 (update test snapshot) test result: OK. 1 passed; 0 failed; finished in ??? @@ -27707,6 +27762,7 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) +<<<<<<< HEAD Finished release [optimized + fuel] target(s) [2.008 KB] in ??? Running 1 test, filtered 0 tests @@ -27847,11 +27903,14 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) +======= +>>>>>>> 5f2f098c4 (update test snapshot) Finished release [optimized + fuel] target(s) [1.728 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call +<<<<<<< HEAD test isolated_cost_of_in_str_0 ... ok (???, 11250 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28687,6 +28746,9 @@ output: tested -- const_of_contract_call test isolated_cost_of_in_array_64 ... ok (???, 11611 gas) +======= + test isolated_cost_of_in_array_64 ... ok (???, 9569 gas) +>>>>>>> 5f2f098c4 (update test snapshot) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28701,12 +28763,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.496 KB] in ??? + Finished release [optimized + fuel] target(s) [1.816 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_8 ... ok (???, 3054 gas) + test isolated_cost_of_in_array_8 ... ok (???, 2397 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28721,12 +28783,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.224 KB] in ??? + Finished release [optimized + fuel] target(s) [1.528 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_b256 ... ok (???, 1290 gas) + test isolated_cost_of_in_b256 ... ok (???, 787 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28741,12 +28803,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.216 KB] in ??? + Finished release [optimized + fuel] target(s) [1.408 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_bool ... ok (???, 1186 gas) + test isolated_cost_of_in_bool ... ok (???, 714 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28761,12 +28823,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.344 KB] in ??? + Finished release [optimized + fuel] target(s) [1.72 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64 ... ok (???, 1472 gas) + test in_enum_u64 ... ok (???, 1001 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28781,12 +28843,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.496 KB] in ??? + Finished release [optimized + fuel] target(s) [1.872 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64 ... ok (???, 1486 gas) + test in_enum_u64_u64 ... ok (???, 1015 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28801,12 +28863,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.672 KB] in ??? + Finished release [optimized + fuel] target(s) [2.056 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_enum_u64_u64_u64 ... ok (???, 1489 gas) + test in_enum_u64_u64_u64 ... ok (???, 1018 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28821,12 +28883,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.168 KB] in ??? + Finished release [optimized + fuel] target(s) [1.36 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_0 ... ok (???, 1205 gas) + test isolated_cost_of_in_str_0 ... ok (???, 733 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28841,12 +28903,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.4 KB] in ??? + Finished release [optimized + fuel] target(s) [1.592 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_1 ... ok (???, 1322 gas) + test isolated_cost_of_in_str_1 ... ok (???, 851 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28861,12 +28923,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.44 KB] in ??? + Finished release [optimized + fuel] target(s) [1.64 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_16 ... ok (???, 1329 gas) + test isolated_cost_of_in_str_16 ... ok (???, 858 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28881,12 +28943,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.456 KB] in ??? + Finished release [optimized + fuel] target(s) [1.656 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_32 ... ok (???, 1330 gas) + test isolated_cost_of_in_str_32 ... ok (???, 858 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28901,12 +28963,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.416 KB] in ??? + Finished release [optimized + fuel] target(s) [1.608 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_str_8 ... ok (???, 1328 gas) + test isolated_cost_of_in_str_8 ... ok (???, 857 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28921,12 +28983,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.208 KB] in ??? + Finished release [optimized + fuel] target(s) [1.536 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64 ... ok (???, 1263 gas) + test in_struct_u64 ... ok (???, 781 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28941,12 +29003,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.296 KB] in ??? + Finished release [optimized + fuel] target(s) [1.68 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64 ... ok (???, 1443 gas) + test in_struct_u64_u64 ... ok (???, 972 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28961,12 +29023,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.36 KB] in ??? + Finished release [optimized + fuel] target(s) [1.744 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test in_struct_u64_u64_u64 ... ok (???, 1594 gas) + test in_struct_u64_u64_u64 ... ok (???, 1122 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28981,12 +29043,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.736 KB] in ??? + Finished release [optimized + fuel] target(s) [832 B] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_0 ... ok (???, 959 gas) + test isolated_cost_of_in_tuple_0 ... ok (???, 454 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29001,12 +29063,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.16 KB] in ??? + Finished release [optimized + fuel] target(s) [1.488 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_1 ... ok (???, 1240 gas) + test isolated_cost_of_in_tuple_1 ... ok (???, 758 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29021,12 +29083,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.288 KB] in ??? + Finished release [optimized + fuel] target(s) [1.664 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_2 ... ok (???, 1443 gas) + test isolated_cost_of_in_tuple_2 ... ok (???, 972 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29041,12 +29103,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.352 KB] in ??? + Finished release [optimized + fuel] target(s) [1.728 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_3 ... ok (???, 1594 gas) + test isolated_cost_of_in_tuple_3 ... ok (???, 1122 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29061,12 +29123,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.424 KB] in ??? + Finished release [optimized + fuel] target(s) [1.8 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_tuple_4 ... ok (???, 1743 gas) + test isolated_cost_of_in_tuple_4 ... ok (???, 1271 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29081,12 +29143,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.248 KB] in ??? + Finished release [optimized + fuel] target(s) [1.44 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u16 ... ok (???, 1256 gas) + test isolated_cost_of_in_u16 ... ok (???, 784 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29101,12 +29163,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.336 KB] in ??? + Finished release [optimized + fuel] target(s) [1.528 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u256 ... ok (???, 1259 gas) + test isolated_cost_of_in_u256 ... ok (???, 787 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29121,12 +29183,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.352 KB] in ??? + Finished release [optimized + fuel] target(s) [1.544 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u32 ... ok (???, 1381 gas) + test isolated_cost_of_in_u32 ... ok (???, 909 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29141,12 +29203,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.976 KB] in ??? + Finished release [optimized + fuel] target(s) [1.344 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u64 ... ok (???, 1164 gas) + test isolated_cost_of_in_u64 ... ok (???, 692 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29161,18 +29223,13 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.192 KB] in ??? + Finished release [optimized + fuel] target(s) [1.384 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u8 ... ok (???, 1179 gas) + test isolated_cost_of_in_u8 ... ok (???, 707 gas) test result: OK. 1 passed; 0 failed; finished in ??? Finished in ??? -<<<<<<< HEAD -error: Some tests failed. ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) -======= ->>>>>>> dbd26f625 (bring whole snapshot test back) From c3f97e1c2db9fbfc9108aaedd77304749a1ac667 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 26 Oct 2025 14:35:51 -0300 Subject: [PATCH 14/18] update tests ids --- .../array_of_structs_caller/src/main.sw | 2 +- .../require_contract_deployment/asset_ops_test/src/main.sw | 4 ++-- .../require_contract_deployment/bal_opcode/src/main.sw | 2 +- .../call_abi_with_tuples/src/main.sw | 2 +- .../call_contract_with_type_aliases/src/main.sw | 2 +- .../call_increment_contract/src/main.sw | 2 +- .../require_contract_deployment/caller_auth_test/src/main.sw | 2 +- .../caller_context_test/src/main.sw | 2 +- .../nested_struct_args_caller/src/main.sw | 2 +- 9 files changed, 10 insertions(+), 10 deletions(-) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw index 570d34d72cd..9de52291359 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/array_of_structs_caller/src/main.sw @@ -6,7 +6,7 @@ use std::hash::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0x14ed3cd06c2947248f69d54bfa681fe40d26267be84df7e19e253622b7921bbe; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x9e0048a62c58414e5bbe689ad3fc0ef7f887bcf5668f01b5a60d513248d816c6; // AUTO-CONTRACT-ID ../../test_contracts/array_of_structs_contract --release +const CONTRACT_ID = 0x510e6c19520792268ca632dbc288092b1fe1e0ff1f9e1864e9a16054486644c8; // AUTO-CONTRACT-ID ../../test_contracts/array_of_structs_contract --release fn get_address() -> Option { Some(CONTRACT_ID.into()) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw index 457c8b52e62..6ef8dbdf5e9 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/asset_ops_test/src/main.sw @@ -9,12 +9,12 @@ use test_fuel_coin_abi::*; #[cfg(experimental_new_encoding = false)] const FUEL_COIN_CONTRACT_ID = 0xec2277ebe007ade87e3d797c3b1e070dcd542d5ef8f038b471f262ef9cebc87c; #[cfg(experimental_new_encoding = true)] -const FUEL_COIN_CONTRACT_ID = 0x17aa1f86a9e0a25c639b22341c4af4d31f2335c4244cab2c4022cf644efa7c46; // AUTO-CONTRACT-ID ../../test_contracts/test_fuel_coin_contract --release +const FUEL_COIN_CONTRACT_ID = 0x019af5b2fa0576ffd889b3843d08b9c1f352baf98031faabc098a0b6f1e5c46f; // AUTO-CONTRACT-ID ../../test_contracts/test_fuel_coin_contract --release #[cfg(experimental_new_encoding = false)] const BALANCE_CONTRACT_ID = 0xf6cd545152ac83225e8e7df2efb5c6fa6e37bc9b9e977b5ea8103d28668925df; #[cfg(experimental_new_encoding = true)] -const BALANCE_CONTRACT_ID = 0xa52577728c59f4b6bc6cb06901f748ed182f4bf55aba325de8a2dc8369e86c08; // AUTO-CONTRACT-ID ../../test_contracts/balance_test_contract --release +const BALANCE_CONTRACT_ID = 0xa30c5df660b642a857e4675dbab622031aca65a538eeca3961a7a5ff44a8dc07; // AUTO-CONTRACT-ID ../../test_contracts/balance_test_contract --release fn main() -> bool { let default_gas = 1_000_000_000_000; diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw index 6106221df19..cd6f084f77c 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/bal_opcode/src/main.sw @@ -5,7 +5,7 @@ use balance_test_abi::BalanceTest; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0xf6cd545152ac83225e8e7df2efb5c6fa6e37bc9b9e977b5ea8103d28668925df; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0xa52577728c59f4b6bc6cb06901f748ed182f4bf55aba325de8a2dc8369e86c08; // AUTO-CONTRACT-ID ../../test_contracts/balance_test_contract --release +const CONTRACT_ID = 0xa30c5df660b642a857e4675dbab622031aca65a538eeca3961a7a5ff44a8dc07; // AUTO-CONTRACT-ID ../../test_contracts/balance_test_contract --release fn main() -> bool { let balance_test_contract = abi(BalanceTest, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw index 2d6101b12a5..6eb4cb53be9 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_abi_with_tuples/src/main.sw @@ -6,7 +6,7 @@ use abi_with_tuples::{MyContract, Location, Person}; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0xfdc14550c8aee742cd556d0ab7f378b7be0d3b1e6e086c097352e94590d4ed02; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x73d7a99965a456f581c871ac5a55d7417797a08edc7edc043a66bed4f6352734; // AUTO-CONTRACT-ID ../../test_contracts/abi_with_tuples_contract --release +const CONTRACT_ID = 0xb17647b40915b3b1041040156882f95d7abe06818ebd4caf80baf9347c88d782; // AUTO-CONTRACT-ID ../../test_contracts/abi_with_tuples_contract --release fn main() -> bool { let the_abi = abi(MyContract, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw index fae9126b8c8..5ffb41293e0 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_contract_with_type_aliases/src/main.sw @@ -5,7 +5,7 @@ use contract_with_type_aliases_abi::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0x0cbeb6efe3104b460be769bdc4ea101ebf16ccc16f2d7b667ec3e1c7f5ce35b5; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0xa0d3d4d39f1d9504b31696cfc28f42003c68f0743583084876d6ad914b42e063; // AUTO-CONTRACT-ID ../../test_contracts/contract_with_type_aliases --release +const CONTRACT_ID = 0xbbfb864b80edb429347a9dec482fb9fcd4a925e54ab3f78e90e51b61986cec3d; // AUTO-CONTRACT-ID ../../test_contracts/contract_with_type_aliases --release fn main() { let caller = abi(MyContract, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw index 1658aeffe61..37a21dad59d 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_increment_contract/src/main.sw @@ -6,7 +6,7 @@ use dynamic_contract_call::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0xd1b4047af7ef111c023ab71069e01dc2abfde487c0a0ce1268e4f447e6c6e4c2; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x4ed3a95cb7daa9eac3ca954623d3fcb52c65011fc677c579e96662003605c2f8; // AUTO-CONTRACT-ID ../../test_contracts/increment_contract --release +const CONTRACT_ID = 0xbb33081bc6da28392260b076e53494190a1ff4426134921fd98b4371c2b00a3b; // AUTO-CONTRACT-ID ../../test_contracts/increment_contract --release fn main() -> bool { let the_abi = abi(Incrementor, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw index 95803416473..fc125998751 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_auth_test/src/main.sw @@ -5,7 +5,7 @@ use auth_testing_abi::AuthTesting; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0xc2eec20491b53aab7232cbd27c31d15417b4e9daf0b89c74cc242ef1295f681f; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0xa6cc9483ac189658ac9e50dea8a2fcaf288d8bc413b30636f8af302fbb1e9960; // AUTO-CONTRACT-ID ../../test_contracts/auth_testing_contract --release +const CONTRACT_ID = 0x8be75eacc0b96df2f77c12139a5f400c90757405cf3dda6a4efe98ec57469cc0; // AUTO-CONTRACT-ID ../../test_contracts/auth_testing_contract --release // should be false in the case of a script fn main() -> bool { diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw index 5224f74dafa..0970e26df21 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/caller_context_test/src/main.sw @@ -6,7 +6,7 @@ use context_testing_abi::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0x6054c11cda000f5990373a4d61929396165be4dfdd61d5b7bd26da60ab0d8577; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x3c7b414d62b63b1d63d762508b7524dffb89ed39ab49c87934e3b0bb202481a8; // AUTO-CONTRACT-ID ../../test_contracts/context_testing_contract --release +const CONTRACT_ID = 0x8b12252020214149904b24e98bd8c021f05f576d6e332eb473b08d776eecdf0e; // AUTO-CONTRACT-ID ../../test_contracts/context_testing_contract --release fn main() -> bool { let gas: u64 = u64::max(); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw index d614d953460..f5c305540cb 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/nested_struct_args_caller/src/main.sw @@ -5,7 +5,7 @@ use nested_struct_args_abi::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0xe63d33a1b3a6903808b379f6a41a72fa8a370e8b76626775e7d9d2f9c4c5da40; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0xd9d43e4d932376f6407d64131c127bfb97ed8039dcbfdb628875e9945eb566af; // AUTO-CONTRACT-ID ../../test_contracts/nested_struct_args_contract --release +const CONTRACT_ID = 0x95243bcc200f70abd7e9efa48d592c5d36ad3ebfc6be0d5a6c00f2f68c4bf79c; // AUTO-CONTRACT-ID ../../test_contracts/nested_struct_args_contract --release fn main() -> bool { let caller = abi(NestedStructArgs, CONTRACT_ID); From 5e92567eb222ce8f64ff2f3012a9ae73668b85f6 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 26 Oct 2025 15:09:10 -0300 Subject: [PATCH 15/18] update test --- forc/tests/cli_integration.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/forc/tests/cli_integration.rs b/forc/tests/cli_integration.rs index e57c14cf7e0..4355a69ac2a 100644 --- a/forc/tests/cli_integration.rs +++ b/forc/tests/cli_integration.rs @@ -51,10 +51,10 @@ fn test_forc_test_raw_logs() -> Result<(), rexpect::error::Error> { // Assert that the output is correct process.exp_string(" test test_log_4")?; process.exp_string("raw logs:")?; - process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12408,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; + process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12044,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; process.exp_string(" test test_log_2")?; process.exp_string("raw logs:")?; - process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12408,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; + process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12044,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; process.process.exit()?; Ok(()) @@ -77,12 +77,12 @@ fn test_forc_test_both_logs() -> Result<(), rexpect::error::Error> { process.exp_string("decoded log values:")?; process.exp_string("4, log rb: 1515152261580153489")?; process.exp_string("raw logs:")?; - process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12408,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; + process.exp_string(r#"[{"LogData":{"data":"0000000000000004","digest":"8005f02d43fa06e7d0585fb64c961d57e318b27a145c857bcd3a6bdb413ff7fc","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12044,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; process.exp_string(" test test_log_2")?; process.exp_string("decoded log values:")?; process.exp_string("2, log rb: 1515152261580153489")?; process.exp_string("raw logs:")?; - process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12408,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; + process.exp_string(r#"[{"LogData":{"data":"0000000000000002","digest":"cd04a4754498e06db5a13c5f371f1f04ff6d2470f24aa9bd886540e5dce77f70","id":"0000000000000000000000000000000000000000000000000000000000000000","is":10368,"len":8,"pc":12044,"ptr":67107840,"ra":0,"rb":1515152261580153489}}]"#)?; process.process.exit()?; Ok(()) } From faf660778cdd33df1753b8c8ecc4f58025089829 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Mon, 27 Oct 2025 07:56:35 -0300 Subject: [PATCH 16/18] remove scripts --- justfile | 27 ---------------- .../compare-gas-usage/extract-gas-usage.sh | 32 ------------------- 2 files changed, 59 deletions(-) delete mode 100755 scripts/compare-gas-usage/extract-gas-usage.sh diff --git a/justfile b/justfile index 72599503e10..b2fdc621983 100644 --- a/justfile +++ b/justfile @@ -153,33 +153,6 @@ perf-remove: echo "Removing canceled." fi -# This recipe should be used on snapshot tests that contains gas usage from `forc test`, -# because it will extract gas usage from all versions of the file and generate an html interactive report. -# path: path to file to extract gas usage -# open: "-o" will open the default browser showing the report -[linux] -[group('benchmark')] -collect-historic-gas-usage path open: - #! /bin/bash - mkdir -p target - rm target/a.csv - rm target/a.html - echo "test,gas,commit" > target/a.csv - for HASH in `git log --format='%H' -- {{path}}`; do - TIMESTAMP=$(git show -s --format='%as-%ct-%H' "$HASH") - git --no-pager show "$HASH:{{path}}" | bash -c "scripts/compare-gas-usage/extract-gas-usage.sh $TIMESTAMP" >> target/a.csv - done - ./scripts/csv2html/csv2html.sh target/a.csv >> target/a.html - if [ -n "{{open}}" ]; then - if which xdg-open &>> /dev/null - then - xdg-open target/a.html - elif which gnome-open &>> /dev/null - then - gnome-open target/a.html - fi - fi - [group('build')] build-prism: cd ./scripts/prism && ./build.sh diff --git a/scripts/compare-gas-usage/extract-gas-usage.sh b/scripts/compare-gas-usage/extract-gas-usage.sh deleted file mode 100755 index 7bcc9107177..00000000000 --- a/scripts/compare-gas-usage/extract-gas-usage.sh +++ /dev/null @@ -1,32 +0,0 @@ -#!/bin/bash - -# This script extracts full test names and test gas usage from a `forc test` output. -# Usage: `forc test | test_gas_usage.sh`. -# if $1 is not empty it will be appended as a new column to the csv - -current_suite="" -results=() - -while IFS= read -r line; do - # printf 'Line: %s\n' "$line" - - if [[ $line =~ ^tested\ --\ ([^[:space:]]+) ]]; then - current_suite="${BASH_REMATCH[1]}" - fi - # printf 'Suite: %s\n' "$current_suite" - - if [[ $line =~ ^[[:space:]]*test[[:space:]]([^\ ]+)[[:space:]]\.\.\.[[:space:]].*,[[:space:]]([0-9]+)[[:space:]]gas\) ]]; then - test_name="${BASH_REMATCH[1]}" - # printf 'Test: %s\n' "$test_name" - gas="${BASH_REMATCH[2]}" - # printf 'Gas: %s\n' "$gas" - - if [ "$1" = "" ]; then - results+=("${current_suite}::${test_name},${gas}") - else - results+=("${current_suite}::${test_name},${gas},$1") - fi - fi -done - -printf '%s\n' "${results[@]}" | sort \ No newline at end of file From 6a4a3bb2fbdc3c2e4eb28f4831f6b455edf89514 Mon Sep 17 00:00:00 2001 From: xunilrj Date: Fri, 31 Oct 2025 14:21:16 -0300 Subject: [PATCH 17/18] rebase issues --- .../panicking_contract/stdout.snap | 177 +- .../call_basic_storage/src/main.sw | 2 +- .../call_storage_enum/src/main.sw | 2 +- .../storage_access_caller/src/main.sw | 2 +- .../const_of_contract_call/stdout.snap | 28724 +--------------- 5 files changed, 92 insertions(+), 28815 deletions(-) diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap index 8dbc150853b..ac6484c4825 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/panic_expression/panicking_contract/stdout.snap @@ -13,36 +13,21 @@ output: tested -- panicking_contract -<<<<<<< HEAD - test test_panicking_in_contract_self_impl ... ok (???, 11571 gas) - revert code: 8000000000000001 - ├─ panic message: panicking in contract self impl - ├─ panicked: in ::panicking_in_contract_self_impl - │ └─ at panicking_contract@1.2.3, src/main.sw:22:9 - test test_directly_panicking_method ... ok (???, 12853 gas) - revert code: 8080000000000002 -======= - test test_panicking_in_contract_self_impl ... ok (???, 794 gas) + test test_panicking_in_contract_self_impl ... ok (???, 11170 gas) revert code: 828000000000000c ├─ panic message: panicking in contract self impl ├─ panicked: in ::panicking_in_contract_self_impl │ └─ at panicking_contract@1.2.3, src/main.sw:22:9 - test test_directly_panicking_method ... ok (???, 1156 gas) + test test_directly_panicking_method ... ok (???, 12169 gas) revert code: 820000000000000b ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error C. ├─ panic value: C(true) ├─ panicked: in ::directly_panicking_method │ └─ at panicking_contract@1.2.3, src/main.sw:28:9 decoded log values: C(true), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_inlined ... ok (???, 15735 gas) - revert code: 830000000540a013 -======= - test test_nested_panic_inlined ... ok (???, 1578 gas) + test test_nested_panic_inlined ... ok (???, 12903 gas) revert code: 8000000000c01001 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) ├─ panicked: in panicking_lib::nested_panic_inlined @@ -53,13 +38,8 @@ C(true), log rb: 5503570629422409978 └─ at panicking_contract@1.2.3, src/main.sw:32:9 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_inlined_same_revert_code ... ok (???, 15735 gas) - revert code: 830000000540a013 -======= - test test_nested_panic_inlined_same_revert_code ... ok (???, 1578 gas) + test test_nested_panic_inlined_same_revert_code ... ok (???, 12903 gas) revert code: 8000000000c01001 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) ├─ panicked: in panicking_lib::nested_panic_inlined @@ -70,13 +50,8 @@ E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString └─ at panicking_contract@1.2.3, src/main.sw:32:9 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_non_inlined ... ok (???, 16289 gas) - revert code: 838000000680c818 -======= - test test_nested_panic_non_inlined ... ok (???, 1638 gas) + test test_nested_panic_non_inlined ... ok (???, 13013 gas) revert code: 8180000002804808 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) ├─ panicked: in panicking_lib::nested_panic_non_inlined @@ -87,13 +62,8 @@ E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString └─ at panicking_contract@1.2.3, src/main.sw:40:9 decoded log values: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_non_inlined_same_revert_code ... ok (???, 16289 gas) - revert code: 838000000680c818 -======= - test test_nested_panic_non_inlined_same_revert_code ... ok (???, 1638 gas) + test test_nested_panic_non_inlined_same_revert_code ... ok (???, 13013 gas) revert code: 8180000002804808 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) ├─ panicked: in panicking_lib::nested_panic_non_inlined @@ -104,13 +74,8 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:40:9 decoded log values: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_generic_panic_with_unit ... ok (???, 14026 gas) - revert code: 828000000000800f -======= - test test_generic_panic_with_unit ... ok (???, 909 gas) + test test_generic_panic_with_unit ... ok (???, 11756 gas) revert code: 8100000000003806 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic value: () ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -118,13 +83,8 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:48:9 decoded log values: (), log rb: 3330666440490685604 -<<<<<<< HEAD - test test_generic_panic_with_unit_same_revert_code ... ok (???, 14026 gas) - revert code: 828000000000800f -======= - test test_generic_panic_with_unit_same_revert_code ... ok (???, 909 gas) + test test_generic_panic_with_unit_same_revert_code ... ok (???, 11756 gas) revert code: 8100000000003806 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic value: () ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -132,13 +92,8 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:48:9 decoded log values: (), log rb: 3330666440490685604 -<<<<<<< HEAD - test test_generic_panic_with_str ... ok (???, 13958 gas) - revert code: 818000000000700d -======= - test test_generic_panic_with_str ... ok (???, 1002 gas) + test test_generic_panic_with_str ... ok (???, 11923 gas) revert code: 8080000000002804 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: generic panic with string ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -146,13 +101,8 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_contract@1.2.3, src/main.sw:56:9 decoded log values: AsciiString { data: "generic panic with string" }, log rb: 10098701174489624218 -<<<<<<< HEAD - test test_generic_panic_with_different_str_same_revert_code ... ok (???, 13190 gas) - revert code: 8180000000004007 -======= - test test_generic_panic_with_different_str_same_revert_code ... ok (???, 1122 gas) + test test_generic_panic_with_different_str_same_revert_code ... ok (???, 12146 gas) revert code: 808000000000d019 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: generic panic with different string ├─ panicked: in panicking_lib::generic_panic │ └─ at panicking_lib, src/lib.sw:74:5 @@ -160,13 +110,8 @@ AsciiString { data: "generic panic with string" }, log rb: 10098701174489624218 └─ at panicking_contract@1.2.3, src/main.sw:60:9 decoded log values: AsciiString { data: "generic panic with different string" }, log rb: 10098701174489624218 -<<<<<<< HEAD - test test_generic_panic_with_error_type_enum ... ok (???, 13475 gas) - revert code: 8200000000005009 -======= - test test_generic_panic_with_error_type_enum ... ok (???, 1093 gas) + test test_generic_panic_with_error_type_enum ... ok (???, 12064 gas) revert code: 830000000000700d ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error A. ├─ panic value: A ├─ panicked: in panicking_lib::generic_panic @@ -175,13 +120,8 @@ AsciiString { data: "generic panic with different string" }, log rb: 10098701174 └─ at panicking_contract@1.2.3, src/main.sw:64:9 decoded log values: A, log rb: 5503570629422409978 -<<<<<<< HEAD - test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 13867 gas) - revert code: 820000000000600b -======= - test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 1244 gas) + test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 12331 gas) revert code: 830000000000e01b ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error B. ├─ panic value: B(42) ├─ panicked: in panicking_lib::generic_panic @@ -207,90 +147,36 @@ output: tested -- panicking_contract -<<<<<<< HEAD - test test_panicking_in_contract_self_impl ... ok (???, 10831 gas) - revert code: 8000000000000000 - ├─ panic message: panicking in contract self impl - └─ panicked: in ::panicking_in_contract_self_impl - └─ at panicking_contract@1.2.3, src/main.sw:22:9 - test test_directly_panicking_method ... ok (???, 11938 gas) - revert code: 8080000000000000 -======= - test test_panicking_in_contract_self_impl ... ok (???, 488 gas) + test test_panicking_in_contract_self_impl ... ok (???, 10462 gas) revert code: 8280000000000000 ├─ panic message: panicking in contract self impl └─ panicked: in ::panicking_in_contract_self_impl └─ at panicking_contract@1.2.3, src/main.sw:22:9 - test test_directly_panicking_method ... ok (???, 800 gas) + test test_directly_panicking_method ... ok (???, 11382 gas) revert code: 8200000000000000 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error C. ├─ panic value: C(true) └─ panicked: in ::directly_panicking_method └─ at panicking_contract@1.2.3, src/main.sw:28:9 decoded log values: C(true), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_inlined ... ok (???, 14064 gas) - revert code: 8300000000000000 -======= - test test_nested_panic_inlined ... ok (???, 1182 gas) + test test_nested_panic_inlined ... ok (???, 12044 gas) revert code: 8000000000000000 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) └─ panicked: in panicking_lib::nested_panic_inlined └─ at panicking_lib, src/lib.sw:35:5 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_inlined_same_revert_code ... ok (???, 14064 gas) - revert code: 8300000000000000 -======= - test test_nested_panic_inlined_same_revert_code ... ok (???, 1182 gas) + test test_nested_panic_inlined_same_revert_code ... ok (???, 12044 gas) revert code: 8000000000000000 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]) └─ panicked: in panicking_lib::nested_panic_inlined └─ at panicking_lib, src/lib.sw:35:5 decoded log values: E([AsciiString { data: "to have" }, AsciiString { data: "strings" }, AsciiString { data: "in error enum variants" }]), log rb: 5503570629422409978 -<<<<<<< HEAD - test test_nested_panic_non_inlined ... ok (???, 14454 gas) - revert code: 8380000000000000 - ├─ panic message: Error E. - ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) - └─ panicked: in panicking_lib::nested_panic_non_inlined - └─ at panicking_lib, src/lib.sw:41:9 - decoded log values: -E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 - test test_nested_panic_non_inlined_same_revert_code ... ok (???, 14454 gas) - revert code: 8380000000000000 - ├─ panic message: Error E. - ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) - └─ panicked: in panicking_lib::nested_panic_non_inlined - └─ at panicking_lib, src/lib.sw:41:9 - decoded log values: -E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 - test test_generic_panic_with_unit ... ok (???, 12702 gas) - revert code: 8280000000000000 - ├─ panic value: () - └─ panicked: in panicking_lib::generic_panic - └─ at panicking_lib, src/lib.sw:74:5 - decoded log values: -(), log rb: 3330666440490685604 - test test_generic_panic_with_unit_same_revert_code ... ok (???, 12702 gas) - revert code: 8280000000000000 - ├─ panic value: () - └─ panicked: in panicking_lib::generic_panic - └─ at panicking_lib, src/lib.sw:74:5 - decoded log values: -(), log rb: 3330666440490685604 - test test_generic_panic_with_str ... ok (???, 12720 gas) -======= - test test_nested_panic_non_inlined ... ok (???, 1212 gas) ->>>>>>> 5f2f098c4 (update test snapshot) + test test_nested_panic_non_inlined ... ok (???, 12100 gas) revert code: 8180000000000000 ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) @@ -298,7 +184,7 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_lib, src/lib.sw:41:9 decoded log values: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 - test test_nested_panic_non_inlined_same_revert_code ... ok (???, 1212 gas) + test test_nested_panic_non_inlined_same_revert_code ... ok (???, 12100 gas) revert code: 8180000000000000 ├─ panic message: Error E. ├─ panic value: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]) @@ -306,59 +192,44 @@ E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { d └─ at panicking_lib, src/lib.sw:41:9 decoded log values: E([AsciiString { data: "this" }, AsciiString { data: "is not" }, AsciiString { data: "the best practice" }]), log rb: 5503570629422409978 - test test_generic_panic_with_unit ... ok (???, 604 gas) + test test_generic_panic_with_unit ... ok (???, 11056 gas) revert code: 8100000000000000 ├─ panic value: () └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: (), log rb: 3330666440490685604 - test test_generic_panic_with_unit_same_revert_code ... ok (???, 604 gas) + test test_generic_panic_with_unit_same_revert_code ... ok (???, 11056 gas) revert code: 8100000000000000 ├─ panic value: () └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: (), log rb: 3330666440490685604 - test test_generic_panic_with_str ... ok (???, 710 gas) + test test_generic_panic_with_str ... ok (???, 11245 gas) revert code: 8080000000000000 ├─ panic message: generic panic with string └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: AsciiString { data: "generic panic with string" }, log rb: 10098701174489624218 -<<<<<<< HEAD - test test_generic_panic_with_different_str_same_revert_code ... ok (???, 12186 gas) - revert code: 8180000000000000 -======= - test test_generic_panic_with_different_str_same_revert_code ... ok (???, 750 gas) + test test_generic_panic_with_different_str_same_revert_code ... ok (???, 11328 gas) revert code: 8080000000000000 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: generic panic with different string └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: AsciiString { data: "generic panic with different string" }, log rb: 10098701174489624218 -<<<<<<< HEAD - test test_generic_panic_with_error_type_enum ... ok (???, 12364 gas) - revert code: 8200000000000000 -======= - test test_generic_panic_with_error_type_enum ... ok (???, 745 gas) + test test_generic_panic_with_error_type_enum ... ok (???, 11287 gas) revert code: 8300000000000000 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error A. ├─ panic value: A └─ panicked: in panicking_lib::generic_panic └─ at panicking_lib, src/lib.sw:74:5 decoded log values: A, log rb: 5503570629422409978 -<<<<<<< HEAD - test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 12642 gas) - revert code: 8200000000000000 -======= - test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 826 gas) + test test_generic_panic_with_error_type_enum_different_variant_same_revert_code ... ok (???, 11434 gas) revert code: 8300000000000000 ->>>>>>> 5f2f098c4 (update test snapshot) ├─ panic message: Error B. ├─ panic value: B(42) └─ panicked: in panicking_lib::generic_panic diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw index 8a90da58329..59d87106133 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_basic_storage/src/main.sw @@ -4,7 +4,7 @@ use basic_storage_abi::{BasicStorage, Quad}; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0x94db39f409a31b9f2ebcadeea44378e419208c20de90f5d8e1e33dc1523754cb; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x841aa8d101ee9b06ff89b72bb5a2bdb46cd6981ba602619fda7424b8b7d47ada; // AUTO-CONTRACT-ID ../../test_contracts/basic_storage --release +const CONTRACT_ID = 0x04e4446fc4569e39c182de577ef794cf095a34119e1bb875fcca828cba85bb97; // AUTO-CONTRACT-ID ../../test_contracts/basic_storage --release fn main() -> u64 { let addr = abi(BasicStorage, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw index 58521ebadfe..acddf36dffd 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/call_storage_enum/src/main.sw @@ -5,7 +5,7 @@ use storage_enum_abi::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0xc601d11767195485a6654d566c67774134668863d8c797a8c69e8778fb1f89e9; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x000c798c2f211f31bb2fb6c02fac49dcd461bab4b3c6ade2977ae71537f77406; // AUTO-CONTRACT-ID ../../test_contracts/storage_enum_contract --release +const CONTRACT_ID = 0x2f3c33ca9c000ae2e56515ce4796cb419393e7fd65da04adbb1d327aa7cc31fa; // AUTO-CONTRACT-ID ../../test_contracts/storage_enum_contract --release fn main() -> u64 { let caller = abi(StorageEnum, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw index 20760ddf675..b35d46e2ff1 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw +++ b/test/src/e2e_vm_tests/test_programs/should_pass/require_contract_deployment/storage_access_caller/src/main.sw @@ -6,7 +6,7 @@ use std::hash::*; #[cfg(experimental_new_encoding = false)] const CONTRACT_ID = 0x3bc28acd66d327b8c1b9624c1fabfc07e9ffa1b5d71c2832c3bfaaf8f4b805e9; #[cfg(experimental_new_encoding = true)] -const CONTRACT_ID = 0x4dc4ea62820f5db502781296582ac9e02132eec4452af5a994f92ad2185bb398; // AUTO-CONTRACT-ID ../../test_contracts/storage_access_contract --release +const CONTRACT_ID = 0x804f5350f8830794f6b7b470e3d9ad878be3afba9f326dbbf6623c4dd58e7fae; // AUTO-CONTRACT-ID ../../test_contracts/storage_access_contract --release fn main() -> bool { let caller = abi(StorageAccess, CONTRACT_ID); diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap index a3e7c444f1f..bcac2272e45 100644 --- a/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap +++ b/test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/stdout.snap @@ -1,28637 +1,46 @@ --- source: test/src/snapshot/mod.rs --- -<<<<<<< HEAD -<<<<<<< HEAD -======= -<<<<<<< HEAD -<<<<<<< HEAD ->>>>>>> 8cc595443 (bring whole snapshot test back) > forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics exit status: 101 output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [35.272 KB] in ??? -<<<<<<< HEAD -======= -======= -// IR: Final -library { -} - - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) -// IR: Final -contract { - global __const_global : string<10> = const string<10> "in_array_0" - global __const_global0 : string<10> = const string<10> "in_array_1" - global __const_global1 : string<11> = const string<11> "in_array_16" - global __const_global10 : string<8> = const string<8> "in_str_0" - global __const_global11 : string<8> = const string<8> "in_str_1" - global __const_global12 : string<9> = const string<9> "in_str_16" - global __const_global13 : string<9> = const string<9> "in_str_32" - global __const_global14 : string<8> = const string<8> "in_str_8" - global __const_global15 : string<13> = const string<13> "in_struct_u64" - global __const_global16 : string<17> = const string<17> "in_struct_u64_u64" - global __const_global17 : string<21> = const string<21> "in_struct_u64_u64_u64" - global __const_global18 : string<10> = const string<10> "in_tuple_0" - global __const_global19 : string<10> = const string<10> "in_tuple_1" - global __const_global2 : string<11> = const string<11> "in_array_32" - global __const_global20 : string<10> = const string<10> "in_tuple_2" - global __const_global21 : string<10> = const string<10> "in_tuple_3" - global __const_global22 : string<10> = const string<10> "in_tuple_4" - global __const_global23 : string<6> = const string<6> "in_u16" - global __const_global24 : string<7> = const string<7> "in_u256" - global __const_global25 : string<6> = const string<6> "in_u32" - global __const_global26 : string<6> = const string<6> "in_u64" - global __const_global27 : string<5> = const string<5> "in_u8" - global __const_global3 : string<11> = const string<11> "in_array_64" - global __const_global4 : string<10> = const string<10> "in_array_8" - global __const_global5 : string<7> = const string<7> "in_b256" - global __const_global6 : string<7> = const string<7> "in_bool" - global __const_global7 : string<11> = const string<11> "in_enum_u64" - global __const_global8 : string<15> = const string<15> "in_enum_u64_u64" - global __const_global9 : string<19> = const string<19> "in_enum_u64_u64_u64" - - pub entry fn __entry() -> (), !3 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut slice __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_010 - local mut { ptr, u64, u64 } __aggr_memcpy_011 - local mut { ptr, u64, u64 } __aggr_memcpy_012 - local mut { ptr, u64 } __aggr_memcpy_013 - local mut { ptr, u64 } __aggr_memcpy_014 - local mut { ptr, u64 } __aggr_memcpy_015 - local mut { ptr, u64 } __aggr_memcpy_016 - local mut { ptr, u64 } __aggr_memcpy_017 - local mut string<0> __aggr_memcpy_018 - local mut { ptr, u64, u64 } __aggr_memcpy_019 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut { ptr, u64, u64 } __aggr_memcpy_020 - local mut { ptr, u64 } __aggr_memcpy_021 - local mut { ptr, u64 } __aggr_memcpy_022 - local mut string<1> __aggr_memcpy_023 - local mut { ptr, u64, u64 } __aggr_memcpy_024 - local mut { ptr, u64, u64 } __aggr_memcpy_025 - local mut { ptr, u64 } __aggr_memcpy_026 - local mut { ptr, u64 } __aggr_memcpy_027 - local mut string<16> __aggr_memcpy_028 - local mut { ptr, u64, u64 } __aggr_memcpy_029 - local mut { ptr, u64 } __aggr_memcpy_03 - local mut { ptr, u64, u64 } __aggr_memcpy_030 - local mut { ptr, u64 } __aggr_memcpy_031 - local mut { ptr, u64 } __aggr_memcpy_032 - local mut string<32> __aggr_memcpy_033 - local mut { ptr, u64, u64 } __aggr_memcpy_034 - local mut { ptr, u64, u64 } __aggr_memcpy_035 - local mut { ptr, u64 } __aggr_memcpy_036 - local mut { ptr, u64 } __aggr_memcpy_037 - local mut string<8> __aggr_memcpy_038 - local mut { ptr, u64, u64 } __aggr_memcpy_039 - local mut { ptr, u64 } __aggr_memcpy_04 - local mut { ptr, u64, u64 } __aggr_memcpy_040 - local mut { ptr, u64 } __aggr_memcpy_041 - local mut { ptr, u64 } __aggr_memcpy_042 - local mut { ptr, u64 } __aggr_memcpy_043 - local mut { ptr, u64 } __aggr_memcpy_044 - local mut { ptr, u64 } __aggr_memcpy_045 - local mut { ptr, u64 } __aggr_memcpy_046 - local mut { ptr, u64 } __aggr_memcpy_047 - local mut { ptr, u64 } __aggr_memcpy_048 - local mut { ptr, u64, u64 } __aggr_memcpy_049 - local mut { ptr, u64 } __aggr_memcpy_05 - local mut { ptr, u64, u64 } __aggr_memcpy_050 - local mut { ptr, u64 } __aggr_memcpy_051 - local mut u256 __aggr_memcpy_052 - local mut { ptr, u64, u64 } __aggr_memcpy_053 - local mut { ptr, u64, u64 } __aggr_memcpy_054 - local mut { ptr, u64 } __aggr_memcpy_055 - local mut { ptr, u64, u64 } __aggr_memcpy_056 - local mut { ptr, u64, u64 } __aggr_memcpy_057 - local mut { ptr, u64 } __aggr_memcpy_058 - local mut { ptr, u64 } __aggr_memcpy_059 - local mut { ptr, u64 } __aggr_memcpy_06 - local mut { ptr, u64, u64 } __aggr_memcpy_060 - local mut { ptr, u64, u64 } __aggr_memcpy_061 - local mut { ptr, u64 } __aggr_memcpy_062 - local mut b256 __aggr_memcpy_07 - local mut { ptr, u64, u64 } __aggr_memcpy_08 - local mut { ptr, u64, u64 } __aggr_memcpy_09 - local { ptr, u64 } __anon_0 - local { ptr } __anon_00 - local { ptr, u64 } __anon_000 - local { u64, ( u64 ) } __anon_001 - local { u64, u64, u64, u64 } __anon_0010 - local { u64, ( u64 | u64 ) } __anon_002 - local { u64, ( u64 | u64 | u64 ) } __anon_003 - local { u64 } __anon_004 - local { u64, u64 } __anon_005 - local { u64, u64, u64 } __anon_006 - local { u64 } __anon_007 - local { u64, u64 } __anon_008 - local { u64, u64, u64 } __anon_009 - local { ptr } __anon_01 - local { bool } __anon_010 - local { ptr, u64, u64 } __anon_011 - local { { u64, ( u64 ) } } __anon_012 - local { { u64, ( u64 | u64 ) } } __anon_013 - local { { u64, ( u64 | u64 | u64 ) } } __anon_014 - local { string<0> } __anon_015 - local { ptr, u64, u64 } __anon_016 - local { string<1> } __anon_017 - local { ptr, u64, u64 } __anon_018 - local { string<16> } __anon_019 - local { [u64; 0] } __anon_02 - local { ptr, u64, u64 } __anon_020 - local { string<32> } __anon_021 - local { ptr, u64, u64 } __anon_022 - local { string<8> } __anon_023 - local { ptr, u64, u64 } __anon_024 - local { { u64 } } __anon_025 - local { { u64, u64 } } __anon_026 - local { { u64, u64, u64 } } __anon_027 - local { () } __anon_028 - local { { u64 } } __anon_029 - local { [u64; 1] } __anon_03 - local { { u64, u64 } } __anon_030 - local { { u64, u64, u64 } } __anon_031 - local { { u64, u64, u64, u64 } } __anon_032 - local { u64 } __anon_033 - local { ptr, u64, u64 } __anon_034 - local { u256 } __anon_035 - local { ptr, u64, u64 } __anon_036 - local { u64 } __anon_037 - local { ptr, u64, u64 } __anon_038 - local { u64 } __anon_039 - local { [u64; 16] } __anon_04 - local { u8 } __anon_040 - local { ptr, u64, u64 } __anon_041 - local { ptr, u64 } __anon_042 - local { ptr, u64 } __anon_043 - local { ptr, u64 } __anon_044 - local { ptr, u64 } __anon_045 - local { ptr, u64 } __anon_046 - local { ptr, u64 } __anon_047 - local { ptr, u64 } __anon_048 - local { ptr, u64 } __anon_049 - local { [u64; 32] } __anon_05 - local { ptr, u64 } __anon_050 - local { ptr, u64 } __anon_051 - local { ptr, u64 } __anon_052 - local { ptr, u64 } __anon_053 - local { ptr, u64 } __anon_054 - local { ptr, u64 } __anon_055 - local { ptr, u64 } __anon_056 - local { ptr, u64 } __anon_057 - local { ptr, u64 } __anon_058 - local { ptr, u64 } __anon_059 - local { [u64; 64] } __anon_06 - local { ptr, u64 } __anon_060 - local { ptr, u64 } __anon_061 - local { ptr, u64 } __anon_062 - local { ptr, u64 } __anon_063 - local { ptr, u64 } __anon_064 - local { ptr, u64 } __anon_065 - local { ptr, u64 } __anon_066 - local { ptr, u64 } __anon_067 - local { ptr, u64 } __anon_068 - local { ptr, u64 } __anon_069 - local { [u64; 8] } __anon_07 - local { ptr, u64 } __anon_070 - local { ptr, u64 } __anon_071 - local { ptr, u64 } __anon_072 - local { ptr, u64 } __anon_073 - local { ptr, u64 } __anon_074 - local { ptr, u64 } __anon_075 - local { b256 } __anon_08 - local { ptr, u64, u64 } __anon_09 - local slice __anon_1 - local { ptr, u64 } __anon_10 - local slice __anon_11 - local b256 __anon_110 - local { ptr, u64, u64 } __anon_111 - local { u64, ( u64 | u64 ) } __anon_112 - local { u64, ( u64 | u64 | u64 ) } __anon_113 - local string<0> __anon_114 - local string<1> __anon_115 - local string<16> __anon_116 - local string<32> __anon_117 - local string<8> __anon_118 - local u64 __anon_119 - local { ptr, u64 } __anon_12 - local u256 __anon_120 - local u64 __anon_121 - local { ptr, u64, u64 } __anon_122 - local slice __anon_13 - local { ptr, u64 } __anon_14 - local slice __anon_15 - local { ptr, u64 } __anon_16 - local slice __anon_17 - local { ptr, u64 } __anon_18 - local slice __anon_19 - local { ptr, u64 } __anon_2 - local { ptr, u64 } __anon_20 - local slice __anon_21 - local { ptr, u64, u64 } __anon_210 - local { { ptr, u64, u64 } } __anon_211 - local { u64, ( u64 | u64 | u64 ) } __anon_212 - local { ptr, u64, u64 } __anon_213 - local { ptr, u64, u64 } __anon_214 - local { ptr, u64, u64 } __anon_215 - local { ptr, u64, u64 } __anon_216 - local { ptr, u64, u64 } __anon_217 - local { ptr, u64, u64 } __anon_218 - local { ptr, u64, u64 } __anon_219 - local { ptr, u64 } __anon_22 - local { ptr, u64, u64 } __anon_220 - local { { ptr, u64, u64 } } __anon_221 - local slice __anon_23 - local { ptr, u64 } __anon_24 - local slice __anon_25 - local { ptr, u64 } __anon_26 - local slice __anon_27 - local { ptr, u64 } __anon_28 - local slice __anon_29 - local slice __anon_3 - local { ptr, u64 } __anon_30 - local slice __anon_31 - local { { ptr, u64, u64 } } __anon_310 - local { { ptr, u64, u64 } } __anon_311 - local { { ptr, u64, u64 } } __anon_312 - local { { ptr, u64, u64 } } __anon_313 - local { { ptr, u64, u64 } } __anon_314 - local { { ptr, u64, u64 } } __anon_315 - local { { ptr, u64, u64 } } __anon_316 - local { { ptr, u64, u64 } } __anon_317 - local { { ptr, u64, u64 } } __anon_318 - local { ptr, u64 } __anon_32 - local slice __anon_33 - local { ptr, u64 } __anon_34 - local slice __anon_35 - local { ptr, u64 } __anon_36 - local slice __anon_37 - local { ptr, u64 } __anon_38 - local slice __anon_39 - local { ptr, u64 } __anon_4 - local { ptr, u64 } __anon_40 - local slice __anon_41 - local { ptr, u64 } __anon_42 - local slice __anon_43 - local { ptr, u64 } __anon_44 - local slice __anon_45 - local { ptr, u64 } __anon_46 - local slice __anon_47 - local { ptr, u64 } __anon_48 - local slice __anon_49 - local slice __anon_5 - local { ptr, u64 } __anon_50 - local slice __anon_51 - local { ptr, u64 } __anon_52 - local slice __anon_53 - local { ptr, u64 } __anon_54 - local slice __anon_55 - local { ptr, u64 } __anon_56 - local slice __anon_57 - local { ptr, u64 } __anon_6 - local slice __anon_7 - local { ptr, u64 } __anon_8 - local slice __anon_9 - local slice __log_arg - local { u64, ( u64 ) } __matched_value_10 - local { u64, ( u64 | u64 ) } __matched_value_12 - local { u64, ( u64 | u64 | u64 ) } __matched_value_14 - local slice __ret_val - local slice __ret_val0 - local slice __ret_val1 - local { { ptr, u64, u64 } } __ret_val10 - local { { ptr, u64, u64 } } __ret_val11 - local { { ptr, u64, u64 } } __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local { { ptr, u64, u64 } } __ret_val15 - local { { ptr, u64, u64 } } __ret_val16 - local { { ptr, u64, u64 } } __ret_val17 - local { { ptr, u64, u64 } } __ret_val18 - local { { ptr, u64, u64 } } __ret_val19 - local slice __ret_val2 - local { { ptr, u64, u64 } } __ret_val20 - local { { ptr, u64, u64 } } __ret_val21 - local { { ptr, u64, u64 } } __ret_val22 - local { { ptr, u64, u64 } } __ret_val23 - local { { ptr, u64, u64 } } __ret_val24 - local { { ptr, u64, u64 } } __ret_val25 - local { { ptr, u64, u64 } } __ret_val26 - local { { ptr, u64, u64 } } __ret_val27 - local { { ptr, u64, u64 } } __ret_val28 - local { { ptr, u64, u64 } } __ret_val29 - local slice __ret_val3 - local { { ptr, u64, u64 } } __ret_val30 - local { { ptr, u64, u64 } } __ret_val31 - local { { ptr, u64, u64 } } __ret_val32 - local { { ptr, u64, u64 } } __ret_val33 - local { { ptr, u64, u64 } } __ret_val34 - local { { ptr, u64, u64 } } __ret_val35 - local { { ptr, u64, u64 } } __ret_val36 - local { { ptr, u64, u64 } } __ret_val37 - local { { ptr, u64, u64 } } __ret_val38 - local { { ptr, u64, u64 } } __ret_val39 - local slice __ret_val4 - local { { ptr, u64, u64 } } __ret_val40 - local { { ptr, u64, u64 } } __ret_val41 - local { { ptr, u64, u64 } } __ret_val42 - local { { ptr, u64, u64 } } __ret_val43 - local { { ptr, u64, u64 } } __ret_val44 - local { { ptr, u64, u64 } } __ret_val45 - local { { ptr, u64, u64 } } __ret_val46 - local { { ptr, u64, u64 } } __ret_val47 - local { { ptr, u64, u64 } } __ret_val48 - local slice __ret_val49 - local [u64; 0] __ret_val5 - local slice __ret_val50 - local slice __ret_val51 - local slice __ret_val52 - local slice __ret_val53 - local slice __ret_val54 - local slice __ret_val55 - local slice __ret_val56 - local slice __ret_val57 - local slice __ret_val58 - local slice __ret_val59 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val60 - local slice __ret_val61 - local slice __ret_val62 - local slice __ret_val63 - local slice __ret_val64 - local slice __ret_val65 - local slice __ret_val66 - local slice __ret_val67 - local slice __ret_val68 - local slice __ret_val69 - local { { ptr, u64, u64 } } __ret_val7 - local [u64; 1] __ret_val70 - local [u64; 16] __ret_val71 - local [u64; 32] __ret_val72 - local [u64; 64] __ret_val73 - local [u64; 8] __ret_val74 - local slice __ret_val75 - local slice __ret_val76 - local slice __ret_val77 - local slice __ret_val78 - local slice __ret_val79 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val80 - local slice __ret_val81 - local slice __ret_val82 - local { { ptr, u64, u64 } } __ret_val9 - local slice __tmp_arg - local slice __tmp_arg0 - local slice __tmp_arg1 - local slice __tmp_arg10 - local slice __tmp_arg100 - local slice __tmp_arg101 - local slice __tmp_arg102 - local slice __tmp_arg103 - local slice __tmp_arg104 - local slice __tmp_arg105 - local slice __tmp_arg106 - local slice __tmp_arg107 - local slice __tmp_arg108 - local slice __tmp_arg109 - local slice __tmp_arg11 - local slice __tmp_arg110 - local slice __tmp_arg111 - local slice __tmp_arg112 - local slice __tmp_arg113 - local slice __tmp_arg114 - local slice __tmp_arg115 - local slice __tmp_arg116 - local slice __tmp_arg117 - local slice __tmp_arg118 - local slice __tmp_arg119 - local slice __tmp_arg12 - local slice __tmp_arg120 - local slice __tmp_arg121 - local slice __tmp_arg122 - local slice __tmp_arg123 - local slice __tmp_arg124 - local slice __tmp_arg125 - local slice __tmp_arg126 - local slice __tmp_arg127 - local [u64; 8] __tmp_arg128 - local [u64; 8] __tmp_arg129 - local slice __tmp_arg13 - local { u64 } __tmp_arg130 - local { u64 } __tmp_arg131 - local { u64, u64, u64 } __tmp_arg132 - local { u64, u64, u64 } __tmp_arg133 - local { u64, u64 } __tmp_arg134 - local { u64, u64 } __tmp_arg135 - local slice __tmp_arg14 - local slice __tmp_arg15 - local slice __tmp_arg16 - local slice __tmp_arg17 - local slice __tmp_arg18 - local slice __tmp_arg19 - local slice __tmp_arg2 - local slice __tmp_arg20 - local slice __tmp_arg21 - local slice __tmp_arg22 - local slice __tmp_arg23 - local slice __tmp_arg24 - local slice __tmp_arg25 - local slice __tmp_arg26 - local slice __tmp_arg27 - local slice __tmp_arg28 - local slice __tmp_arg29 - local slice __tmp_arg3 - local slice __tmp_arg30 - local slice __tmp_arg31 - local slice __tmp_arg32 - local slice __tmp_arg33 - local slice __tmp_arg34 - local slice __tmp_arg35 - local slice __tmp_arg36 - local slice __tmp_arg37 - local slice __tmp_arg38 - local slice __tmp_arg39 - local slice __tmp_arg4 - local slice __tmp_arg40 - local slice __tmp_arg41 - local slice __tmp_arg42 - local slice __tmp_arg43 - local slice __tmp_arg44 - local slice __tmp_arg45 - local slice __tmp_arg46 - local slice __tmp_arg47 - local slice __tmp_arg48 - local slice __tmp_arg49 - local slice __tmp_arg5 - local slice __tmp_arg50 - local slice __tmp_arg51 - local slice __tmp_arg52 - local slice __tmp_arg53 - local slice __tmp_arg54 - local slice __tmp_arg55 - local slice __tmp_arg56 - local { { ptr, u64, u64 } } __tmp_arg57 - local { { ptr, u64, u64 } } __tmp_arg58 - local { { ptr, u64, u64 } } __tmp_arg59 - local slice __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg60 - local { { ptr, u64, u64 } } __tmp_arg61 - local { { ptr, u64, u64 } } __tmp_arg62 - local { { ptr, u64, u64 } } __tmp_arg63 - local { { ptr, u64, u64 } } __tmp_arg64 - local { { ptr, u64, u64 } } __tmp_arg65 - local { { ptr, u64, u64 } } __tmp_arg66 - local { { ptr, u64, u64 } } __tmp_arg67 - local { { ptr, u64, u64 } } __tmp_arg68 - local { { ptr, u64, u64 } } __tmp_arg69 - local slice __tmp_arg7 - local { { ptr, u64, u64 } } __tmp_arg70 - local { { ptr, u64, u64 } } __tmp_arg71 - local { { ptr, u64, u64 } } __tmp_arg72 - local { { ptr, u64, u64 } } __tmp_arg73 - local { { ptr, u64, u64 } } __tmp_arg74 - local { { ptr, u64, u64 } } __tmp_arg75 - local { { ptr, u64, u64 } } __tmp_arg76 - local { { ptr, u64, u64 } } __tmp_arg77 - local { { ptr, u64, u64 } } __tmp_arg78 - local { { ptr, u64, u64 } } __tmp_arg79 - local slice __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg80 - local { { ptr, u64, u64 } } __tmp_arg81 - local { { ptr, u64, u64 } } __tmp_arg82 - local { { ptr, u64, u64 } } __tmp_arg83 - local { { ptr, u64, u64 } } __tmp_arg84 - local { { ptr, u64, u64 } } __tmp_arg85 - local { { ptr, u64, u64 } } __tmp_arg86 - local { { ptr, u64, u64 } } __tmp_arg87 - local { { ptr, u64, u64 } } __tmp_arg88 - local { { ptr, u64, u64 } } __tmp_arg89 - local slice __tmp_arg9 - local { { ptr, u64, u64 } } __tmp_arg90 - local { { ptr, u64, u64 } } __tmp_arg91 - local { { ptr, u64, u64 } } __tmp_arg92 - local { { ptr, u64, u64 } } __tmp_arg93 - local { { ptr, u64, u64 } } __tmp_arg94 - local { { ptr, u64, u64 } } __tmp_arg95 - local { { ptr, u64, u64 } } __tmp_arg96 - local { { ptr, u64, u64 } } __tmp_arg97 - local { { ptr, u64, u64 } } __tmp_arg98 - local { { ptr, u64, u64 } } __tmp_arg99 - local { u64, ( u64 | u64 ) } __tmp_block_arg - local { { ptr, u64, u64 } } __tmp_block_arg0 - local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg1 - local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg2 - local { { ptr, u64, u64 } } __tmp_block_arg3 - local { { ptr, u64, u64 } } __tmp_block_arg4 - local mut { ptr } _buffer - local slice _method_name - local [u64; 0] _result - local slice _result_ - local [u64; 1] _result__ - local slice _result___ - local [u64; 16] _result____ - local slice _result_____ - local [u64; 32] _result______ - local slice _result_______ - local [u64; 64] _result________ - local slice _result_________ - local [u64; 8] _result__________ - local slice _result___________ - local b256 _result____________ - local slice _result_____________ - local slice _result_______________ - local { u64, ( u64 ) } _result________________ - local slice _result_________________ - local { u64, ( u64 | u64 ) } _result__________________ - local slice _result___________________ - local { u64, ( u64 | u64 | u64 ) } _result____________________ - local slice _result_____________________ - local string<0> _result______________________ - local slice _result_______________________ - local string<1> _result________________________ - local slice _result_________________________ - local string<16> _result__________________________ - local slice _result___________________________ - local string<32> _result____________________________ - local slice _result_____________________________ - local string<8> _result______________________________ - local slice _result_______________________________ - local { u64 } _result________________________________ - local slice _result_________________________________ - local { u64, u64 } _result__________________________________ - local slice _result___________________________________ - local { u64, u64, u64 } _result____________________________________ - local slice _result_____________________________________ - local { u64 } _result_______________________________________ - local slice _result________________________________________ - local { u64, u64 } _result_________________________________________ - local slice _result__________________________________________ - local { u64, u64, u64 } _result___________________________________________ - local slice _result____________________________________________ - local { u64, u64, u64, u64 } _result_____________________________________________ - local slice _result______________________________________________ - local slice _result________________________________________________ - local u256 _result_________________________________________________ - local slice _result__________________________________________________ - local slice _result____________________________________________________ - local slice _result______________________________________________________ - local slice _result________________________________________________________ - local { [u64; 0] } args - local { [u64; 1] } args_ - local { [u64; 16] } args__ - local { [u64; 32] } args___ - local { [u64; 64] } args____ - local { [u64; 8] } args_____ - local { b256 } args______ - local { bool } args_______ - local { { u64, ( u64 ) } } args________ - local { { u64, ( u64 | u64 ) } } args_________ - local { { u64, ( u64 | u64 | u64 ) } } args__________ - local { string<0> } args___________ - local { string<1> } args____________ - local { string<16> } args_____________ - local { string<32> } args______________ - local { string<8> } args_______________ - local { { u64 } } args________________ - local { { u64, u64 } } args_________________ - local { { u64, u64, u64 } } args__________________ - local { () } args___________________ - local { { u64 } } args____________________ - local { { u64, u64 } } args_____________________ - local { { u64, u64, u64 } } args______________________ - local { { u64, u64, u64, u64 } } args_______________________ - local { u64 } args________________________ - local { u256 } args_________________________ - local { u64 } args__________________________ - local { u64 } args___________________________ - local { u8 } args____________________________ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer10 - local { { ptr, u64, u64 } } buffer11 - local { { ptr, u64, u64 } } buffer12 - local { { ptr, u64, u64 } } buffer13 - local { { ptr, u64, u64 } } buffer14 - local { { ptr, u64, u64 } } buffer15 - local { { ptr, u64, u64 } } buffer16 - local { { ptr, u64, u64 } } buffer17 - local { { ptr, u64, u64 } } buffer18 - local { { ptr, u64, u64 } } buffer19 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer20 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer5 - local { { ptr, u64, u64 } } buffer6 - local { { ptr, u64, u64 } } buffer7 - local { { ptr, u64, u64 } } buffer8 - local { { ptr, u64, u64 } } buffer9 - local { { ptr, u64, u64 } } buffer_1 - local { { ptr, u64, u64 } } buffer_12 - local { { ptr, u64, u64 } } buffer_14 - local { { ptr, u64, u64 } } buffer_17 - local { { ptr, u64, u64 } } buffer_21 - local { { ptr, u64, u64 } } buffer_24 - local { { ptr, u64, u64 } } buffer_26 - local { { ptr, u64, u64 } } buffer_28 - local { { ptr, u64, u64 } } buffer_3 - local { { ptr, u64, u64 } } buffer_31 - local { { ptr, u64, u64 } } buffer_33 - local { { ptr, u64, u64 } } buffer_35 - local { { ptr, u64, u64 } } buffer_44 - local { { ptr, u64, u64 } } buffer_46 - local { { ptr, u64, u64 } } buffer_48 - local { { ptr, u64, u64 } } buffer_5 - local { { ptr, u64, u64 } } buffer_50 - local { { ptr, u64, u64 } } buffer_53 - local { { ptr, u64, u64 } } buffer_7 - local { { ptr, u64, u64 } } buffer_9 - local mut { { ptr, u64, u64 } } buffer__ - local mut { { ptr, u64, u64 } } buffer__0 - local mut { { ptr, u64, u64 } } buffer__1 - local mut { { ptr, u64, u64 } } buffer__2 - local mut { { ptr, u64, u64 } } buffer__3 - local { { ptr, u64, u64 } } buffer__4 - local { { ptr, u64, u64 } } buffer__5 - local { { ptr, u64, u64 } } buffer__6 - local { { ptr, u64, u64 } } buffer__7 - local { { ptr, u64, u64 } } buffer___ - local { { ptr, u64, u64 } } buffer___0 - local { { ptr, u64, u64 } } buffer___1 - local { { ptr, u64, u64 } } buffer___2 - local { { ptr, u64, u64 } } buffer____ - local { { ptr, u64, u64 } } buffer____0 - local { { ptr, u64, u64 } } buffer____1 - local { { ptr, u64, u64 } } buffer____2 - local { { ptr, u64, u64 } } buffer_____ - local { { ptr, u64, u64 } } buffer_____0 - local { { ptr, u64, u64 } } buffer_____1 - local { { ptr, u64, u64 } } buffer______ - local { { ptr, u64, u64 } } buffer______0 - local { { ptr, u64, u64 } } buffer_______ - local { { ptr, u64, u64 } } buffer________ - local slice data - local slice data0 - local slice data1 - local slice data2 - local slice data3 - local slice data4 - local [u64; 0] item_ - local [u64; 1] item_0 - local [u64; 16] item_1 - local string<1> item_10 - local string<16> item_11 - local string<32> item_12 - local string<8> item_13 - local { u64, u64, u64, u64 } item_14 - local u256 item_16 - local [u64; 32] item_2 - local [u64; 64] item_3 - local b256 item_4 - local { u64, ( u64 ) } item_6 - local { u64, ( u64 | u64 ) } item_7 - local { u64, ( u64 | u64 | u64 ) } item_8 - local string<0> item_9 - local slice self_ - local slice self_0 - local slice self_1 - local slice self_10 - local slice self_11 - local slice self_12 - local slice self_13 - local [u64; 64] self_14 - local slice self_15 - local slice self_16 - local slice self_17 - local b256 self_18 - local slice self_19 - local [u64; 0] self_2 - local slice self_20 - local slice self_21 - local { u64, ( u64 ) } self_22 - local slice self_23 - local slice self_24 - local { u64, ( u64 | u64 ) } self_25 - local slice self_26 - local slice self_27 - local { u64, ( u64 | u64 | u64 ) } self_28 - local slice self_29 - local slice self_3 - local slice self_30 - local slice self_31 - local slice self_32 - local string<0> self_33 - local slice self_34 - local string<1> self_35 - local slice self_36 - local string<16> self_37 - local slice self_38 - local string<32> self_39 - local [u64; 1] self_4 - local slice self_40 - local slice self_41 - local string<8> self_42 - local slice self_43 - local slice self_44 - local slice self_45 - local slice self_46 - local slice self_5 - local { u64, u64, u64, u64 } self_52 - local u256 self_56 - local [u64; 16] self_6 - local slice self_7 - local [u64; 32] self_8 - local slice self_9 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_10 - local slice slice_11 - local slice slice_12 - local slice slice_13 - local slice slice_14 - local slice slice_15 - local slice slice_16 - local slice slice_17 - local slice slice_18 - local slice slice_19 - local slice slice_2 - local slice slice_20 - local slice slice_21 - local slice slice_22 - local slice slice_23 - local slice slice_24 - local slice slice_25 - local slice slice_26 - local slice slice_27 - local slice slice_28 - local slice slice_29 - local slice slice_3 - local slice slice_30 - local slice slice_31 - local slice slice_32 - local slice slice_4 - local slice slice_5 - local slice slice_6 - local slice slice_7 - local slice slice_8 - local slice slice_9 - local b256 v - local u256 v0 - local [u64; 0] v_ - local [u64; 1] v_0 - local [u64; 16] v_1 - local string<0> v_10 - local string<1> v_11 - local string<16> v_12 - local string<32> v_13 - local string<8> v_14 - local { u64 } v_15 - local { u64, u64 } v_16 - local { u64, u64, u64 } v_17 - local { u64 } v_19 - local [u64; 32] v_2 - local { u64, u64 } v_20 - local { u64, u64, u64 } v_21 - local { u64, u64, u64, u64 } v_22 - local u256 v_24 - local [u64; 64] v_3 - local [u64; 8] v_4 - local b256 v_5 - local { u64, ( u64 ) } v_7 - local { u64, ( u64 | u64 ) } v_8 - local { u64, ( u64 | u64 | u64 ) } v_9 - - entry(): - v0 = asm() -> ptr fp, !8 { - } - v1 = const u64 592, !11 - v2 = add v0, v1, !12 - v3 = asm(ptr: v2, val) -> u64 val, !17 { - lw val ptr i0, !18 - } - v4 = asm(ptr: v3) -> ptr ptr, !20 { - } - v5 = get_local __ptr { ptr }, __anon_00, !22 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6, !23 - store v4 to v7, !24 - v8 = get_local __ptr { ptr }, _buffer, !25 - mem_copy_val v8, v5 - v9 = asm() -> ptr fp, !31 { - } - v10 = const u64 584, !34 - v11 = add v9, v10, !35 - v12 = asm(ptr: v11, val) -> u64 val, !38 { - lw val ptr i0, !18 - } - v13 = asm(ptr: v12) -> ptr ptr, !40 { - } - v14 = get_local __ptr { ptr }, __anon_01, !42 - v15 = const u64 0 - v16 = get_elem_ptr v14, __ptr ptr, v15, !43 - store v13 to v16, !44 - v17 = get_local __ptr { ptr }, buffer, !46 - mem_copy_val v17, v14 - v18 = get_local __ptr { ptr }, buffer, !48 - v19 = const u64 0 - v20 = get_elem_ptr v18, __ptr ptr, v19, !54 - v21 = load v20, !55 - v22 = asm(ptr: v21, val) -> u64 val, !57 { - lw val ptr i0, !58 - } - v23 = load v20, !55 - v24 = const u64 8, !55 - v25 = add v23, v24, !55 - store v25 to v20, !60 - v26 = get_local __ptr slice, __ret_val - v27 = call read_bytes_8(v18, v22, v26) - v28 = get_local __ptr slice, data, !62 - mem_copy_val v28, v26 - v29 = get_local __ptr slice, data, !64 - v30 = get_local __ptr slice, self_, !67 - mem_copy_val v30, v29 - v31 = get_local __ptr slice, self_, !70 - v32 = get_local __ptr slice, slice_, !73 - mem_copy_val v32, v31 - v33 = get_local __ptr slice, slice_, !75 - v34 = asm(ptr: v33) -> __ptr { ptr, u64 } ptr { - } - v35 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v35, v34 - v36 = get_local __ptr { ptr, u64 }, __anon_042, !67 - mem_copy_val v36, v35 - v37 = const u64 0 - v38 = get_elem_ptr v36, __ptr ptr, v37, !77 - v39 = get_local __ptr { ptr, u64 }, __anon_000, !79 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr ptr, v40, !80 - mem_copy_val v41, v38 - v42 = const u64 1 - v43 = get_elem_ptr v39, __ptr u64, v42, !81 - store v22 to v43, !82 - v44 = asm(s: v39) -> __ptr slice s { - } - v45 = get_local __ptr slice, __aggr_memcpy_00 - mem_copy_val v45, v44 - v46 = get_local __ptr slice, _method_name, !83 - mem_copy_val v46, v45 - v47 = get_local __ptr slice, _method_name, !84 - v48 = get_global __ptr string<10>, __const_global - v49 = cast_ptr v48 to ptr, !85 - v50 = get_local __ptr { ptr, u64 }, __anon_0, !85 - v51 = const u64 0 - v52 = get_elem_ptr v50, __ptr ptr, v51 - store v49 to v52, !85 - v53 = const u64 1 - v54 = get_elem_ptr v50, __ptr u64, v53 - v55 = const u64 10 - store v55 to v54, !85 - v56 = get_local __ptr slice, __anon_1, !85 - mem_copy_bytes v56, v50, 16 - v57 = get_local __ptr slice, __tmp_arg - mem_copy_val v57, v47 - v58 = get_local __ptr slice, __tmp_arg0 - mem_copy_val v58, v56 - v59 = call eq_11(v57, v58) - cbr v59, block0(), block1(), !86 - - block0(): - v60 = get_local __ptr { ptr }, _buffer, !87 - v61 = get_local __ptr [u64; 0], __ret_val5 - v62 = call abi_decode_18(v60, v61) - v63 = get_local __ptr { [u64; 0] }, __anon_02, !93 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr [u64; 0], v64, !94 - mem_copy_val v65, v61 - v66 = get_local __ptr { [u64; 0] }, args, !95 - mem_copy_val v66, v63 - v67 = get_local __ptr { [u64; 0] }, args, !96 - v68 = const u64 0 - v69 = get_elem_ptr v67, __ptr [u64; 0], v68, !97 - v70 = get_local __ptr [u64; 0], v_, !100 - mem_copy_val v70, v69 - v71 = get_local __ptr [u64; 0], v_, !103 - v72 = get_local __ptr [u64; 0], _result, !104 - mem_copy_val v72, v71 - v73 = get_local __ptr [u64; 0], _result, !105 - v74 = get_local __ptr [u64; 0], item_, !108 - mem_copy_val v74, v73 - v75 = get_local __ptr [u64; 0], item_, !110 - v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val28 - v77 = call new_21(v76) - v78 = get_local __ptr [u64; 0], self_2, !113 - mem_copy_val v78, v75 - v79 = get_local __ptr { { ptr, u64, u64 } }, buffer_1, !114 - mem_copy_val v79, v76 - v80 = get_local __ptr { { ptr, u64, u64 } }, buffer_1, !116 - v81 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !118 - mem_copy_val v81, v80 - v82 = const u64 0, !119 - br encode_28_abi_encode_29_while(v82), !120 - - encode_28_abi_encode_29_while(v83: u64): - v84 = const u64 0 - v85 = cmp lt v83 v84, !123 - cbr v85, encode_28_abi_encode_29_while_body(), encode_28_abi_encode_29_end_while(), !124 - - encode_28_abi_encode_29_while_body(): - v86 = get_local __ptr [u64; 0], self_2, !126 - v87 = get_elem_ptr v86, __ptr u64, v83, !128 - v88 = load v87, !129 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !131 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg57 - mem_copy_val v90, v89 - v91 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v92 = call abi_encode_20(v88, v90, v91) - v93 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !133 - mem_copy_val v93, v91 - v94 = const u64 1, !134 - v95 = add v83, v94, !137 - br encode_28_abi_encode_29_while(v95), !138 - - encode_28_abi_encode_29_end_while(): - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !140 - v97 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !142 - mem_copy_val v97, v96 - v98 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !144 - v99 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg79 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, __ret_val49 - v101 = call as_raw_slice_22(v99, v100) - v102 = get_local __ptr slice, _result_, !145 - mem_copy_val v102, v100 - v103 = get_local __ptr slice, _result_, !146 - v104 = get_local __ptr slice, self_0, !149 - mem_copy_val v104, v103 - v105 = get_local __ptr slice, self_0, !150 - v106 = get_local __ptr slice, slice_0, !151 - mem_copy_val v106, v105 - v107 = get_local __ptr slice, slice_0, !152 - v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { - } - v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v109, v108 - v110 = get_local __ptr { ptr, u64 }, __anon_043, !149 - mem_copy_val v110, v109 - v111 = get_elem_ptr v110, __ptr ptr, v37, !153 - v112 = load v111, !149 - v113 = get_local __ptr slice, _result_, !154 - v114 = get_local __ptr slice, __tmp_arg100 - mem_copy_val v114, v113 - v115 = call len_30(v114) - retd v112 v115, !155 - - block1(): - v116 = get_local __ptr slice, _method_name, !156 - v117 = get_global __ptr string<10>, __const_global0 - v118 = cast_ptr v117 to ptr, !157 - v119 = get_local __ptr { ptr, u64 }, __anon_2, !157 - v120 = const u64 0 - v121 = get_elem_ptr v119, __ptr ptr, v120 - store v118 to v121, !157 - v122 = const u64 1 - v123 = get_elem_ptr v119, __ptr u64, v122 - v124 = const u64 10 - store v124 to v123, !157 - v125 = get_local __ptr slice, __anon_3, !157 - mem_copy_bytes v125, v119, 16 - v126 = get_local __ptr slice, __tmp_arg1 - mem_copy_val v126, v116 - v127 = get_local __ptr slice, __tmp_arg2 - mem_copy_val v127, v125 - v128 = call eq_11(v126, v127) - cbr v128, block3(), block4(), !158 - - block3(): - v129 = get_local __ptr { ptr }, _buffer, !159 - v130 = get_local __ptr [u64; 1], __ret_val70 - v131 = call abi_decode_34(v129, v130) - v132 = get_local __ptr { [u64; 1] }, __anon_03, !162 - v133 = const u64 0 - v134 = get_elem_ptr v132, __ptr [u64; 1], v133, !163 - mem_copy_val v134, v130 - v135 = get_local __ptr { [u64; 1] }, args_, !164 - mem_copy_val v135, v132 - v136 = get_local __ptr { [u64; 1] }, args_, !165 - v137 = const u64 0 - v138 = get_elem_ptr v136, __ptr [u64; 1], v137, !166 - v139 = get_local __ptr [u64; 1], v_0, !169 - mem_copy_val v139, v138 - v140 = get_local __ptr [u64; 1], v_0, !171 - v141 = get_local __ptr [u64; 1], _result__, !172 - mem_copy_val v141, v140 - v142 = get_local __ptr [u64; 1], _result__, !173 - v143 = get_local __ptr [u64; 1], item_0, !176 - mem_copy_val v143, v142 - v144 = get_local __ptr [u64; 1], item_0, !177 - v145 = get_local __ptr { { ptr, u64, u64 } }, __ret_val29 - v146 = call new_21(v145) - v147 = get_local __ptr [u64; 1], self_4, !178 - mem_copy_val v147, v144 - v148 = get_local __ptr { { ptr, u64, u64 } }, buffer_3, !179 - mem_copy_val v148, v145 - v149 = get_local __ptr { { ptr, u64, u64 } }, buffer_3, !180 - v150 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !181 - mem_copy_val v150, v149 - v151 = const u64 0, !119 - br encode_36_abi_encode_37_while(v151), !182 - - encode_36_abi_encode_37_while(v152: u64): - v153 = const u64 1 - v154 = cmp lt v152 v153, !183 - cbr v154, encode_36_abi_encode_37_while_body(), encode_36_abi_encode_37_end_while(), !184 - - encode_36_abi_encode_37_while_body(): - v155 = get_local __ptr [u64; 1], self_4, !185 - v156 = get_elem_ptr v155, __ptr u64, v152, !186 - v157 = load v156, !187 - v158 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !188 - v159 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg58 - mem_copy_val v159, v158 - v160 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v161 = call abi_encode_20(v157, v159, v160) - v162 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !189 - mem_copy_val v162, v160 - v163 = const u64 1, !134 - v164 = add v152, v163, !190 - br encode_36_abi_encode_37_while(v164), !191 - - encode_36_abi_encode_37_end_while(): - v165 = get_local __ptr { { ptr, u64, u64 } }, buffer__0, !192 - v166 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !193 - mem_copy_val v166, v165 - v167 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !194 - v168 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg80 - mem_copy_val v168, v167 - v169 = get_local __ptr slice, __ret_val50 - v170 = call as_raw_slice_22(v168, v169) - v171 = get_local __ptr slice, _result___, !195 - mem_copy_val v171, v169 - v172 = get_local __ptr slice, _result___, !196 - v173 = get_local __ptr slice, self_1, !199 - mem_copy_val v173, v172 - v174 = get_local __ptr slice, self_1, !200 - v175 = get_local __ptr slice, slice_1, !201 - mem_copy_val v175, v174 - v176 = get_local __ptr slice, slice_1, !202 - v177 = asm(ptr: v176) -> __ptr { ptr, u64 } ptr { - } - v178 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v178, v177 - v179 = get_local __ptr { ptr, u64 }, __anon_044, !199 - mem_copy_val v179, v178 - v180 = get_elem_ptr v179, __ptr ptr, v37, !203 - v181 = load v180, !199 - v182 = get_local __ptr slice, _result___, !204 - v183 = get_local __ptr slice, __tmp_arg101 - mem_copy_val v183, v182 - v184 = call len_30(v183) - retd v181 v184, !205 - - block4(): - v185 = get_local __ptr slice, _method_name, !206 - v186 = get_global __ptr string<11>, __const_global1 - v187 = cast_ptr v186 to ptr, !207 - v188 = get_local __ptr { ptr, u64 }, __anon_4, !207 - v189 = const u64 0 - v190 = get_elem_ptr v188, __ptr ptr, v189 - store v187 to v190, !207 - v191 = const u64 1 - v192 = get_elem_ptr v188, __ptr u64, v191 - v193 = const u64 11 - store v193 to v192, !207 - v194 = get_local __ptr slice, __anon_5, !207 - mem_copy_bytes v194, v188, 16 - v195 = get_local __ptr slice, __tmp_arg3 - mem_copy_val v195, v185 - v196 = get_local __ptr slice, __tmp_arg4 - mem_copy_val v196, v194 - v197 = call eq_11(v195, v196) - cbr v197, block6(), block7(), !208 - - block6(): - v198 = get_local __ptr { ptr }, _buffer, !209 - v199 = get_local __ptr [u64; 16], __ret_val71 - v200 = call abi_decode_40(v198, v199) - v201 = get_local __ptr { [u64; 16] }, __anon_04, !212 - v202 = const u64 0 - v203 = get_elem_ptr v201, __ptr [u64; 16], v202, !213 - mem_copy_val v203, v199 - v204 = get_local __ptr { [u64; 16] }, args__, !214 - mem_copy_val v204, v201 - v205 = get_local __ptr { [u64; 16] }, args__, !215 - v206 = const u64 0 - v207 = get_elem_ptr v205, __ptr [u64; 16], v206, !216 - v208 = get_local __ptr [u64; 16], v_1, !219 - mem_copy_val v208, v207 - v209 = get_local __ptr [u64; 16], v_1, !221 - v210 = get_local __ptr [u64; 16], _result____, !222 - mem_copy_val v210, v209 - v211 = get_local __ptr [u64; 16], _result____, !223 - v212 = get_local __ptr [u64; 16], item_1, !226 - mem_copy_val v212, v211 - v213 = get_local __ptr [u64; 16], item_1, !227 - v214 = get_local __ptr { { ptr, u64, u64 } }, __ret_val30 - v215 = call new_21(v214) - v216 = get_local __ptr [u64; 16], self_6, !228 - mem_copy_val v216, v213 - v217 = get_local __ptr { { ptr, u64, u64 } }, buffer_5, !229 - mem_copy_val v217, v214 - v218 = get_local __ptr { { ptr, u64, u64 } }, buffer_5, !230 - v219 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !231 - mem_copy_val v219, v218 - v220 = const u64 0, !119 - br encode_42_abi_encode_43_while(v220), !232 - - encode_42_abi_encode_43_while(v221: u64): - v222 = const u64 16 - v223 = cmp lt v221 v222, !233 - cbr v223, encode_42_abi_encode_43_while_body(), encode_42_abi_encode_43_end_while(), !234 - - encode_42_abi_encode_43_while_body(): - v224 = get_local __ptr [u64; 16], self_6, !235 - v225 = get_elem_ptr v224, __ptr u64, v221, !236 - v226 = load v225, !237 - v227 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !238 - v228 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg59 - mem_copy_val v228, v227 - v229 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v230 = call abi_encode_20(v226, v228, v229) - v231 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !239 - mem_copy_val v231, v229 - v232 = const u64 1, !134 - v233 = add v221, v232, !240 - br encode_42_abi_encode_43_while(v233), !241 - - encode_42_abi_encode_43_end_while(): - v234 = get_local __ptr { { ptr, u64, u64 } }, buffer__1, !242 - v235 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !243 - mem_copy_val v235, v234 - v236 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !244 - v237 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg81 - mem_copy_val v237, v236 - v238 = get_local __ptr slice, __ret_val51 - v239 = call as_raw_slice_22(v237, v238) - v240 = get_local __ptr slice, _result_____, !245 - mem_copy_val v240, v238 - v241 = get_local __ptr slice, _result_____, !246 - v242 = get_local __ptr slice, self_3, !249 - mem_copy_val v242, v241 - v243 = get_local __ptr slice, self_3, !250 - v244 = get_local __ptr slice, slice_2, !251 - mem_copy_val v244, v243 - v245 = get_local __ptr slice, slice_2, !252 - v246 = asm(ptr: v245) -> __ptr { ptr, u64 } ptr { - } - v247 = get_local __ptr { ptr, u64 }, __aggr_memcpy_03 - mem_copy_val v247, v246 - v248 = get_local __ptr { ptr, u64 }, __anon_045, !249 - mem_copy_val v248, v247 - v249 = get_elem_ptr v248, __ptr ptr, v37, !253 - v250 = load v249, !249 - v251 = get_local __ptr slice, _result_____, !254 - v252 = get_local __ptr slice, __tmp_arg102 - mem_copy_val v252, v251 - v253 = call len_30(v252) - retd v250 v253, !255 - - block7(): - v254 = get_local __ptr slice, _method_name, !256 - v255 = get_global __ptr string<11>, __const_global2 - v256 = cast_ptr v255 to ptr, !257 - v257 = get_local __ptr { ptr, u64 }, __anon_6, !257 - v258 = const u64 0 - v259 = get_elem_ptr v257, __ptr ptr, v258 - store v256 to v259, !257 - v260 = const u64 1 - v261 = get_elem_ptr v257, __ptr u64, v260 - v262 = const u64 11 - store v262 to v261, !257 - v263 = get_local __ptr slice, __anon_7, !257 - mem_copy_bytes v263, v257, 16 - v264 = get_local __ptr slice, __tmp_arg5 - mem_copy_val v264, v254 - v265 = get_local __ptr slice, __tmp_arg6 - mem_copy_val v265, v263 - v266 = call eq_11(v264, v265) - cbr v266, block9(), block10(), !258 - - block9(): - v267 = get_local __ptr { ptr }, _buffer, !259 - v268 = get_local __ptr [u64; 32], __ret_val72 - v269 = call abi_decode_46(v267, v268) - v270 = get_local __ptr { [u64; 32] }, __anon_05, !262 - v271 = const u64 0 - v272 = get_elem_ptr v270, __ptr [u64; 32], v271, !263 - mem_copy_val v272, v268 - v273 = get_local __ptr { [u64; 32] }, args___, !264 - mem_copy_val v273, v270 - v274 = get_local __ptr { [u64; 32] }, args___, !265 - v275 = const u64 0 - v276 = get_elem_ptr v274, __ptr [u64; 32], v275, !266 - v277 = get_local __ptr [u64; 32], v_2, !269 - mem_copy_val v277, v276 - v278 = get_local __ptr [u64; 32], v_2, !271 - v279 = get_local __ptr [u64; 32], _result______, !272 - mem_copy_val v279, v278 - v280 = get_local __ptr [u64; 32], _result______, !273 - v281 = get_local __ptr [u64; 32], item_2, !276 - mem_copy_val v281, v280 - v282 = get_local __ptr [u64; 32], item_2, !277 - v283 = get_local __ptr { { ptr, u64, u64 } }, __ret_val31 - v284 = call new_21(v283) - v285 = get_local __ptr [u64; 32], self_8, !278 - mem_copy_val v285, v282 - v286 = get_local __ptr { { ptr, u64, u64 } }, buffer_7, !279 - mem_copy_val v286, v283 - v287 = get_local __ptr { { ptr, u64, u64 } }, buffer_7, !280 - v288 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !281 - mem_copy_val v288, v287 - v289 = const u64 0, !119 - br encode_48_abi_encode_49_while(v289), !282 - - encode_48_abi_encode_49_while(v290: u64): - v291 = const u64 32 - v292 = cmp lt v290 v291, !283 - cbr v292, encode_48_abi_encode_49_while_body(), encode_48_abi_encode_49_end_while(), !284 - - encode_48_abi_encode_49_while_body(): - v293 = get_local __ptr [u64; 32], self_8, !285 - v294 = get_elem_ptr v293, __ptr u64, v290, !286 - v295 = load v294, !287 - v296 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !288 - v297 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg60 - mem_copy_val v297, v296 - v298 = get_local __ptr { { ptr, u64, u64 } }, __ret_val9 - v299 = call abi_encode_20(v295, v297, v298) - v300 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !289 - mem_copy_val v300, v298 - v301 = const u64 1, !134 - v302 = add v290, v301, !290 - br encode_48_abi_encode_49_while(v302), !291 - - encode_48_abi_encode_49_end_while(): - v303 = get_local __ptr { { ptr, u64, u64 } }, buffer__2, !292 - v304 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !293 - mem_copy_val v304, v303 - v305 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !294 - v306 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg82 - mem_copy_val v306, v305 - v307 = get_local __ptr slice, __ret_val52 - v308 = call as_raw_slice_22(v306, v307) - v309 = get_local __ptr slice, _result_______, !295 - mem_copy_val v309, v307 - v310 = get_local __ptr slice, _result_______, !296 - v311 = get_local __ptr slice, self_5, !299 - mem_copy_val v311, v310 - v312 = get_local __ptr slice, self_5, !300 - v313 = get_local __ptr slice, slice_3, !301 - mem_copy_val v313, v312 - v314 = get_local __ptr slice, slice_3, !302 - v315 = asm(ptr: v314) -> __ptr { ptr, u64 } ptr { - } - v316 = get_local __ptr { ptr, u64 }, __aggr_memcpy_04 - mem_copy_val v316, v315 - v317 = get_local __ptr { ptr, u64 }, __anon_046, !299 - mem_copy_val v317, v316 - v318 = get_elem_ptr v317, __ptr ptr, v37, !303 - v319 = load v318, !299 - v320 = get_local __ptr slice, _result_______, !304 - v321 = get_local __ptr slice, __tmp_arg103 - mem_copy_val v321, v320 - v322 = call len_30(v321) - retd v319 v322, !305 - - block10(): - v323 = get_local __ptr slice, _method_name, !306 - v324 = get_global __ptr string<11>, __const_global3 - v325 = cast_ptr v324 to ptr, !307 - v326 = get_local __ptr { ptr, u64 }, __anon_8, !307 - v327 = const u64 0 - v328 = get_elem_ptr v326, __ptr ptr, v327 - store v325 to v328, !307 - v329 = const u64 1 - v330 = get_elem_ptr v326, __ptr u64, v329 - v331 = const u64 11 - store v331 to v330, !307 - v332 = get_local __ptr slice, __anon_9, !307 - mem_copy_bytes v332, v326, 16 - v333 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v333, v323 - v334 = get_local __ptr slice, __tmp_arg8 - mem_copy_val v334, v332 - v335 = call eq_11(v333, v334) - cbr v335, block12(), block13(), !308 - - block12(): - v336 = get_local __ptr { ptr }, _buffer, !309 - v337 = get_local __ptr [u64; 64], __ret_val73 - v338 = call abi_decode_52(v336, v337) - v339 = get_local __ptr { [u64; 64] }, __anon_06, !312 - v340 = const u64 0 - v341 = get_elem_ptr v339, __ptr [u64; 64], v340, !313 - mem_copy_val v341, v337 - v342 = get_local __ptr { [u64; 64] }, args____, !314 - mem_copy_val v342, v339 - v343 = get_local __ptr { [u64; 64] }, args____, !315 - v344 = const u64 0 - v345 = get_elem_ptr v343, __ptr [u64; 64], v344, !316 - v346 = get_local __ptr [u64; 64], v_3, !319 - mem_copy_val v346, v345 - v347 = get_local __ptr [u64; 64], v_3, !321 - v348 = get_local __ptr [u64; 64], _result________, !322 - mem_copy_val v348, v347 - v349 = get_local __ptr [u64; 64], _result________, !323 - v350 = get_local __ptr [u64; 64], item_3, !326 - mem_copy_val v350, v349 - v351 = get_local __ptr [u64; 64], item_3, !327 - v352 = get_local __ptr { { ptr, u64, u64 } }, __ret_val32 - v353 = call new_21(v352) - v354 = get_local __ptr [u64; 64], self_14, !328 - mem_copy_val v354, v351 - v355 = get_local __ptr { { ptr, u64, u64 } }, buffer_9, !329 - mem_copy_val v355, v352 - v356 = get_local __ptr { { ptr, u64, u64 } }, buffer_9, !330 - v357 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !331 - mem_copy_val v357, v356 - v358 = const u64 0, !119 - br encode_54_abi_encode_55_while(v358), !332 - - encode_54_abi_encode_55_while(v359: u64): - v360 = const u64 64 - v361 = cmp lt v359 v360, !333 - cbr v361, encode_54_abi_encode_55_while_body(), encode_54_abi_encode_55_end_while(), !334 - - encode_54_abi_encode_55_while_body(): - v362 = get_local __ptr [u64; 64], self_14, !335 - v363 = get_elem_ptr v362, __ptr u64, v359, !336 - v364 = load v363, !337 - v365 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !338 - v366 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg61 - mem_copy_val v366, v365 - v367 = get_local __ptr { { ptr, u64, u64 } }, __ret_val10 - v368 = call abi_encode_20(v364, v366, v367) - v369 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !339 - mem_copy_val v369, v367 - v370 = const u64 1, !134 - v371 = add v359, v370, !340 - br encode_54_abi_encode_55_while(v371), !341 - - encode_54_abi_encode_55_end_while(): - v372 = get_local __ptr { { ptr, u64, u64 } }, buffer__3, !342 - v373 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !343 - mem_copy_val v373, v372 - v374 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !344 - v375 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg83 - mem_copy_val v375, v374 - v376 = get_local __ptr slice, __ret_val53 - v377 = call as_raw_slice_22(v375, v376) - v378 = get_local __ptr slice, _result_________, !345 - mem_copy_val v378, v376 - v379 = get_local __ptr slice, _result_________, !346 - v380 = get_local __ptr slice, self_7, !349 - mem_copy_val v380, v379 - v381 = get_local __ptr slice, self_7, !350 - v382 = get_local __ptr slice, slice_4, !351 - mem_copy_val v382, v381 - v383 = get_local __ptr slice, slice_4, !352 - v384 = asm(ptr: v383) -> __ptr { ptr, u64 } ptr { - } - v385 = get_local __ptr { ptr, u64 }, __aggr_memcpy_05 - mem_copy_val v385, v384 - v386 = get_local __ptr { ptr, u64 }, __anon_047, !349 - mem_copy_val v386, v385 - v387 = get_elem_ptr v386, __ptr ptr, v37, !353 - v388 = load v387, !349 - v389 = get_local __ptr slice, _result_________, !354 - v390 = get_local __ptr slice, __tmp_arg104 - mem_copy_val v390, v389 - v391 = call len_30(v390) - retd v388 v391, !355 - - block13(): - v392 = get_local __ptr slice, _method_name, !356 - v393 = get_global __ptr string<10>, __const_global4 - v394 = cast_ptr v393 to ptr, !357 - v395 = get_local __ptr { ptr, u64 }, __anon_10, !357 - v396 = const u64 0 - v397 = get_elem_ptr v395, __ptr ptr, v396 - store v394 to v397, !357 - v398 = const u64 1 - v399 = get_elem_ptr v395, __ptr u64, v398 - v400 = const u64 10 - store v400 to v399, !357 - v401 = get_local __ptr slice, __anon_11, !357 - mem_copy_bytes v401, v395, 16 - v402 = get_local __ptr slice, __tmp_arg9 - mem_copy_val v402, v392 - v403 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v403, v401 - v404 = call eq_11(v402, v403) - cbr v404, block15(), block16(), !358 - - block15(): - v405 = get_local __ptr { ptr }, _buffer, !359 - v406 = get_local __ptr [u64; 8], __ret_val74 - v407 = call abi_decode_58(v405, v406) - v408 = get_local __ptr { [u64; 8] }, __anon_07, !362 - v409 = const u64 0 - v410 = get_elem_ptr v408, __ptr [u64; 8], v409, !363 - mem_copy_val v410, v406 - v411 = get_local __ptr { [u64; 8] }, args_____, !364 - mem_copy_val v411, v408 - v412 = get_local __ptr { [u64; 8] }, args_____, !365 - v413 = const u64 0 - v414 = get_elem_ptr v412, __ptr [u64; 8], v413, !366 - v415 = get_local __ptr [u64; 8], v_4, !369 - mem_copy_val v415, v414 - v416 = get_local __ptr [u64; 8], v_4, !371 - v417 = get_local __ptr [u64; 8], __tmp_arg128 - mem_copy_val v417, v416 - v418 = get_local __ptr slice, __ret_val75 - v419 = call encode_60(v417, v418) - v420 = get_local __ptr slice, __log_arg - mem_copy_val v420, v418 - v421 = const u64 3565715504387854074 - log __ptr slice v420, v421 - v422 = get_local __ptr [u64; 8], v_4, !373 - v423 = get_local __ptr [u64; 8], _result__________, !374 - mem_copy_val v423, v422 - v424 = get_local __ptr [u64; 8], _result__________, !375 - v425 = get_local __ptr [u64; 8], __tmp_arg129 - mem_copy_val v425, v424 - v426 = get_local __ptr slice, __ret_val76 - v427 = call encode_60(v425, v426) - v428 = get_local __ptr slice, _result___________, !376 - mem_copy_val v428, v426 - v429 = get_local __ptr slice, _result___________, !377 - v430 = get_local __ptr slice, self_9, !380 - mem_copy_val v430, v429 - v431 = get_local __ptr slice, self_9, !381 - v432 = get_local __ptr slice, slice_5, !382 - mem_copy_val v432, v431 - v433 = get_local __ptr slice, slice_5, !383 - v434 = asm(ptr: v433) -> __ptr { ptr, u64 } ptr { - } - v435 = get_local __ptr { ptr, u64 }, __aggr_memcpy_06 - mem_copy_val v435, v434 - v436 = get_local __ptr { ptr, u64 }, __anon_048, !380 - mem_copy_val v436, v435 - v437 = get_elem_ptr v436, __ptr ptr, v37, !384 - v438 = load v437, !380 - v439 = get_local __ptr slice, _result___________, !385 - v440 = get_local __ptr slice, __tmp_arg105 - mem_copy_val v440, v439 - v441 = call len_30(v440) - retd v438 v441, !386 - - block16(): - v442 = get_local __ptr slice, _method_name, !387 - v443 = get_global __ptr string<7>, __const_global5 - v444 = cast_ptr v443 to ptr, !388 - v445 = get_local __ptr { ptr, u64 }, __anon_12, !388 - v446 = const u64 0 - v447 = get_elem_ptr v445, __ptr ptr, v446 - store v444 to v447, !388 - v448 = const u64 1 - v449 = get_elem_ptr v445, __ptr u64, v448 - v450 = const u64 7 - store v450 to v449, !388 - v451 = get_local __ptr slice, __anon_13, !388 - mem_copy_bytes v451, v445, 16 - v452 = get_local __ptr slice, __tmp_arg11 - mem_copy_val v452, v442 - v453 = get_local __ptr slice, __tmp_arg12 - mem_copy_val v453, v451 - v454 = call eq_11(v452, v453) - cbr v454, block18(), block19(), !389 - - block18(): - v455 = get_local __ptr { ptr }, _buffer, !390 - v456 = const u64 0 - v457 = get_elem_ptr v455, __ptr ptr, v456, !397 - v458 = load v457, !398 - v459 = asm(ptr: v458) -> __ptr b256 ptr { - } - v460 = get_local __ptr b256, __aggr_memcpy_07 - mem_copy_val v460, v459 - v461 = get_local __ptr b256, v, !400 - mem_copy_val v461, v460 - v462 = load v457, !401 - v463 = const u64 32, !402 - v464 = add v462, v463, !403 - store v464 to v457, !405 - v465 = get_local __ptr b256, v, !407 - v466 = get_local __ptr { b256 }, __anon_08, !408 - v467 = const u64 0 - v468 = get_elem_ptr v466, __ptr b256, v467, !409 - mem_copy_val v468, v465 - v469 = get_local __ptr { b256 }, args______, !410 - mem_copy_val v469, v466 - v470 = get_local __ptr { b256 }, args______, !411 - v471 = const u64 0 - v472 = get_elem_ptr v470, __ptr b256, v471, !412 - v473 = get_local __ptr b256, v_5, !415 - mem_copy_val v473, v472 - v474 = get_local __ptr b256, v_5, !417 - v475 = get_local __ptr b256, _result____________, !418 - mem_copy_val v475, v474 - v476 = get_local __ptr b256, _result____________, !419 - v477 = get_local __ptr b256, item_4, !422 - mem_copy_val v477, v476 - v478 = get_local __ptr b256, item_4, !423 - v479 = get_local __ptr { { ptr, u64, u64 } }, __ret_val33 - v480 = call new_21(v479) - v481 = get_local __ptr b256, self_18, !424 - mem_copy_val v481, v478 - v482 = get_local __ptr { { ptr, u64, u64 } }, buffer_12, !425 - mem_copy_val v482, v479 - v483 = get_local __ptr { { ptr, u64, u64 } }, buffer_12, !427 - v484 = const u64 0 - v485 = get_elem_ptr v483, __ptr { ptr, u64, u64 }, v484, !429 - v486 = asm(buffer: v485) -> __ptr { ptr, u64, u64 } buffer { - } - v487 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_08 - mem_copy_val v487, v486 - v488 = get_local __ptr { ptr, u64, u64 }, __anon_09, !430 - mem_copy_val v488, v487 - v489 = const u64 0 - v490 = get_elem_ptr v488, __ptr ptr, v489, !431 - v491 = load v490, !432 - v492 = const u64 1 - v493 = get_elem_ptr v488, __ptr u64, v492, !433 - v494 = load v493, !434 - v495 = const u64 2 - v496 = get_elem_ptr v488, __ptr u64, v495, !435 - v497 = load v496, !436 - v498 = get_local __ptr b256, self_18, !438 - v499 = const u64 32 - v500 = add v497, v499, !439 - v501 = cmp gt v500 v494, !440 - cbr v501, encode_67_abi_encode_68_block1(), encode_67_abi_encode_68_block0(v491, v494), !441 - - encode_67_abi_encode_68_block0(v502: ptr, v503: u64): - v504 = get_local __ptr b256, __anon_110, !442 - mem_copy_val v504, v498 - v505 = add v502, v497, !443 - v506 = cast_ptr v505 to __ptr u8, !444 - mem_copy_bytes v506, v504, 32, !445 - v507 = get_local __ptr { ptr, u64, u64 }, __anon_210, !446 - v508 = const u64 0 - v509 = get_elem_ptr v507, __ptr ptr, v508, !447 - store v502 to v509, !448 - v510 = const u64 1 - v511 = get_elem_ptr v507, __ptr u64, v510, !449 - store v503 to v511, !450 - v512 = const u64 2 - v513 = get_elem_ptr v507, __ptr u64, v512, !451 - store v500 to v513, !452 - v514 = asm(buffer: v507) -> __ptr { ptr, u64, u64 } buffer { - } - v515 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_09 - mem_copy_val v515, v514 - v516 = get_local __ptr { { ptr, u64, u64 } }, __anon_310, !454 - v517 = const u64 0 - v518 = get_elem_ptr v516, __ptr { ptr, u64, u64 }, v517, !455 - mem_copy_val v518, v515 - v519 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !456 - mem_copy_val v519, v516 - v520 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !457 - v521 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg84 - mem_copy_val v521, v520 - v522 = get_local __ptr slice, __ret_val54 - v523 = call as_raw_slice_22(v521, v522) - v524 = get_local __ptr slice, _result_____________, !458 - mem_copy_val v524, v522 - v525 = get_local __ptr slice, _result_____________, !459 - v526 = get_local __ptr slice, self_10, !462 - mem_copy_val v526, v525 - v527 = get_local __ptr slice, self_10, !463 - v528 = get_local __ptr slice, slice_6, !464 - mem_copy_val v528, v527 - v529 = get_local __ptr slice, slice_6, !465 - v530 = asm(ptr: v529) -> __ptr { ptr, u64 } ptr { - } - v531 = get_local __ptr { ptr, u64 }, __aggr_memcpy_010 - mem_copy_val v531, v530 - v532 = get_local __ptr { ptr, u64 }, __anon_049, !462 - mem_copy_val v532, v531 - v533 = get_elem_ptr v532, __ptr ptr, v37, !466 - v534 = load v533, !462 - v535 = get_local __ptr slice, _result_____________, !467 - v536 = get_local __ptr slice, __tmp_arg106 - mem_copy_val v536, v535 - v537 = call len_30(v536) - retd v534 v537, !468 - - encode_67_abi_encode_68_block1(): - v538 = const u64 2 - v539 = mul v494, v538, !469 - v540 = add v539, v499, !470 - v541 = asm(new_cap: v540, old_ptr: v491, len: v497) -> __ptr u8 hp, !471 { - aloc new_cap - mcp hp old_ptr len - } - br encode_67_abi_encode_68_block0(v541, v540), !472 - - block19(): - v542 = get_local __ptr slice, _method_name, !473 - v543 = get_global __ptr string<7>, __const_global6 - v544 = cast_ptr v543 to ptr, !474 - v545 = get_local __ptr { ptr, u64 }, __anon_14, !474 - v546 = const u64 0 - v547 = get_elem_ptr v545, __ptr ptr, v546 - store v544 to v547, !474 - v548 = const u64 1 - v549 = get_elem_ptr v545, __ptr u64, v548 - v550 = const u64 7 - store v550 to v549, !474 - v551 = get_local __ptr slice, __anon_15, !474 - mem_copy_bytes v551, v545, 16 - v552 = get_local __ptr slice, __tmp_arg13 - mem_copy_val v552, v542 - v553 = get_local __ptr slice, __tmp_arg14 - mem_copy_val v553, v551 - v554 = call eq_11(v552, v553) - cbr v554, block21(), block22(), !475 - - block21(): - v555 = get_local __ptr { ptr }, _buffer, !476 - v556 = call read_72(v555), !481 - v557 = const u8 0, !482 - v558 = cmp eq v556 v557, !485 - v559 = const bool false, !486 - cbr v558, decode_69_abi_decode_70_abi_decode_71_block5(v559), decode_69_abi_decode_70_abi_decode_71_block1(), !487 - - decode_69_abi_decode_70_abi_decode_71_block1(): - v560 = const u8 1, !488 - v561 = cmp eq v556 v560, !491 - v562 = const bool true, !492 - cbr v561, decode_69_abi_decode_70_abi_decode_71_block5(v562), decode_69_abi_decode_70_abi_decode_71_block3(), !493 - - decode_69_abi_decode_70_abi_decode_71_block3(): - v563 = const u64 0, !494 - revert v563, !496 - - decode_69_abi_decode_70_abi_decode_71_block5(v564: bool): - v565 = get_local __ptr { bool }, __anon_010, !497 - v566 = const u64 0 - v567 = get_elem_ptr v565, __ptr bool, v566, !498 - store v564 to v567, !499 - v568 = get_local __ptr { bool }, args_______, !500 - mem_copy_val v568, v565 - v569 = get_local __ptr { bool }, args_______, !501 - v570 = const u64 0 - v571 = get_elem_ptr v569, __ptr bool, v570, !502 - v572 = load v571 - v573 = get_local __ptr { { ptr, u64, u64 } }, __ret_val34 - v574 = call new_21(v573) - v575 = get_local __ptr { { ptr, u64, u64 } }, buffer_14, !505 - mem_copy_val v575, v573 - v576 = get_local __ptr { { ptr, u64, u64 } }, buffer_14, !507 - v577 = const u64 0 - v578 = get_elem_ptr v576, __ptr { ptr, u64, u64 }, v577, !508 - v579 = asm(buffer: v578) -> __ptr { ptr, u64, u64 } buffer { - } - v580 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_011 - mem_copy_val v580, v579 - v581 = get_local __ptr { ptr, u64, u64 }, __anon_011, !509 - mem_copy_val v581, v580 - v582 = const u64 0 - v583 = get_elem_ptr v581, __ptr ptr, v582, !510 - v584 = load v583, !511 - v585 = const u64 1 - v586 = get_elem_ptr v581, __ptr u64, v585, !512 - v587 = load v586, !513 - v588 = const u64 2 - v589 = get_elem_ptr v581, __ptr u64, v588, !514 - v590 = load v589, !515 - v591 = const u64 1 - v592 = add v590, v591, !516 - v593 = cmp gt v592 v587, !517 - cbr v593, encode_76_abi_encode_77_block1(), encode_76_abi_encode_77_block0(v584, v587), !518 - - encode_76_abi_encode_77_block0(v594: ptr, v595: u64): - v596 = add v594, v590, !519 - v597 = cast_ptr v596 to __ptr bool, !520 - store v572 to v597, !521 - v598 = get_local __ptr { ptr, u64, u64 }, __anon_111, !522 - v599 = const u64 0 - v600 = get_elem_ptr v598, __ptr ptr, v599, !523 - store v594 to v600, !524 - v601 = const u64 1 - v602 = get_elem_ptr v598, __ptr u64, v601, !525 - store v595 to v602, !526 - v603 = const u64 2 - v604 = get_elem_ptr v598, __ptr u64, v603, !527 - store v592 to v604, !528 - v605 = asm(buffer: v598) -> __ptr { ptr, u64, u64 } buffer { - } - v606 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_012 - mem_copy_val v606, v605 - v607 = get_local __ptr { { ptr, u64, u64 } }, __anon_211, !530 - v608 = const u64 0 - v609 = get_elem_ptr v607, __ptr { ptr, u64, u64 }, v608, !531 - mem_copy_val v609, v606 - v610 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !532 - mem_copy_val v610, v607 - v611 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !533 - v612 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg85 - mem_copy_val v612, v611 - v613 = get_local __ptr slice, __ret_val55 - v614 = call as_raw_slice_22(v612, v613) - v615 = get_local __ptr slice, _result_______________, !534 - mem_copy_val v615, v613 - v616 = get_local __ptr slice, _result_______________, !535 - v617 = get_local __ptr slice, self_11, !538 - mem_copy_val v617, v616 - v618 = get_local __ptr slice, self_11, !539 - v619 = get_local __ptr slice, slice_7, !540 - mem_copy_val v619, v618 - v620 = get_local __ptr slice, slice_7, !541 - v621 = asm(ptr: v620) -> __ptr { ptr, u64 } ptr { - } - v622 = get_local __ptr { ptr, u64 }, __aggr_memcpy_013 - mem_copy_val v622, v621 - v623 = get_local __ptr { ptr, u64 }, __anon_050, !538 - mem_copy_val v623, v622 - v624 = get_elem_ptr v623, __ptr ptr, v37, !542 - v625 = load v624, !538 - v626 = get_local __ptr slice, _result_______________, !543 - v627 = get_local __ptr slice, __tmp_arg107 - mem_copy_val v627, v626 - v628 = call len_30(v627) - retd v625 v628, !544 - - encode_76_abi_encode_77_block1(): - v629 = const u64 2 - v630 = mul v587, v629, !545 - v631 = add v630, v591, !546 - v632 = asm(new_cap: v631, old_ptr: v584, len: v590) -> __ptr u8 hp, !547 { - aloc new_cap - mcp hp old_ptr len - } - br encode_76_abi_encode_77_block0(v632, v631), !548 - - block22(): - v633 = get_local __ptr slice, _method_name, !549 - v634 = get_global __ptr string<11>, __const_global7 - v635 = cast_ptr v634 to ptr, !550 - v636 = get_local __ptr { ptr, u64 }, __anon_16, !550 - v637 = const u64 0 - v638 = get_elem_ptr v636, __ptr ptr, v637 - store v635 to v638, !550 - v639 = const u64 1 - v640 = get_elem_ptr v636, __ptr u64, v639 - v641 = const u64 11 - store v641 to v640, !550 - v642 = get_local __ptr slice, __anon_17, !550 - mem_copy_bytes v642, v636, 16 - v643 = get_local __ptr slice, __tmp_arg15 - mem_copy_val v643, v633 - v644 = get_local __ptr slice, __tmp_arg16 - mem_copy_val v644, v642 - v645 = call eq_11(v643, v644) - cbr v645, block24(), block25(), !551 - - block24(): - v646 = get_local __ptr { ptr }, _buffer, !552 - v647 = get_elem_ptr v646, __ptr ptr, v19, !559 - v648 = load v647, !560 - v649 = asm(ptr: v648, val) -> u64 val, !561 { - lw val ptr i0, !58 - } - v650 = load v647, !560 - v651 = const u64 8, !560 - v652 = add v650, v651, !560 - store v652 to v647, !562 - v653 = const u64 0, !563 - v654 = cmp eq v649 v653, !566 - cbr v654, decode_78_abi_decode_79_abi_decode_80_block0(), decode_78_abi_decode_79_abi_decode_80_block1(), !567 - - decode_78_abi_decode_79_abi_decode_80_block0(): - v655 = get_local __ptr { u64, ( u64 ) }, __anon_001, !569 - v656 = const u64 0 - v657 = get_elem_ptr v655, __ptr u64, v656, !570 - v658 = const u64 0, !568 - store v658 to v657, !571 - v659 = load v647, !574 - v660 = asm(ptr: v659, val) -> u64 val, !575 { - lw val ptr i0, !58 - } - v661 = load v647, !574 - v662 = const u64 8, !574 - v663 = add v661, v662, !574 - store v663 to v647, !576 - v664 = const u64 1 - v665 = const u64 0 - v666 = get_elem_ptr v655, __ptr u64, v664, v665, !577 - store v660 to v666, !578 - v667 = get_local __ptr { { u64, ( u64 ) } }, __anon_012, !579 - v668 = const u64 0 - v669 = get_elem_ptr v667, __ptr { u64, ( u64 ) }, v668, !580 - mem_copy_val v669, v655 - v670 = get_local __ptr { { u64, ( u64 ) } }, args________, !581 - mem_copy_val v670, v667 - v671 = get_local __ptr { { u64, ( u64 ) } }, args________, !582 - v672 = const u64 0 - v673 = get_elem_ptr v671, __ptr { u64, ( u64 ) }, v672, !583 - v674 = get_local __ptr { u64, ( u64 ) }, v_7, !586 - mem_copy_val v674, v673 - v675 = get_local __ptr { u64, ( u64 ) }, v_7, !588 - v676 = get_local __ptr { u64, ( u64 ) }, _result________________, !589 - mem_copy_val v676, v675 - v677 = get_local __ptr { u64, ( u64 ) }, _result________________, !590 - v678 = get_local __ptr { u64, ( u64 ) }, item_6, !593 - mem_copy_val v678, v677 - v679 = get_local __ptr { u64, ( u64 ) }, item_6, !594 - v680 = get_local __ptr { { ptr, u64, u64 } }, __ret_val35 - v681 = call new_21(v680) - v682 = get_local __ptr { u64, ( u64 ) }, self_22, !595 - mem_copy_val v682, v679 - v683 = get_local __ptr { { ptr, u64, u64 } }, buffer_17, !596 - mem_copy_val v683, v680 - v684 = get_local __ptr { u64, ( u64 ) }, self_22, !598 - v685 = get_local __ptr { u64, ( u64 ) }, __matched_value_10, !600 - mem_copy_val v685, v684 - v686 = get_local __ptr { u64, ( u64 ) }, __matched_value_10, !601 - v687 = const u64 0 - v688 = get_elem_ptr v686, __ptr u64, v687, !602 - v689 = load v688, !603 - v690 = const u64 0, !597 - v691 = cmp eq v689 v690, !606 - cbr v691, encode_82_abi_encode_83_block0(), encode_82_abi_encode_83_block1(), !607 - - decode_78_abi_decode_79_abi_decode_80_block1(): - v692 = const u64 0, !608 - revert v692, !610 - - encode_82_abi_encode_83_block0(): - v693 = get_local __ptr { u64, ( u64 ) }, __matched_value_10, !611 - v694 = const u64 1 - v695 = const u64 0 - v696 = get_elem_ptr v693, __ptr u64, v694, v695, !612 - v697 = load v696, !613 - v698 = get_local __ptr { { ptr, u64, u64 } }, buffer_17, !615 - v699 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg62 - mem_copy_val v699, v698 - v700 = get_local __ptr { { ptr, u64, u64 } }, __ret_val11 - v701 = const u64 0, !616 - v702 = call abi_encode_20(v701, v699, v700) - v703 = get_local __ptr { { ptr, u64, u64 } }, buffer__4, !618 - mem_copy_val v703, v700 - v704 = get_local __ptr { { ptr, u64, u64 } }, buffer__4, !620 - v705 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg63 - mem_copy_val v705, v704 - v706 = get_local __ptr { { ptr, u64, u64 } }, __ret_val12 - v707 = call abi_encode_20(v697, v705, v706) - v708 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !622 - mem_copy_val v708, v706 - v709 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !624 - v710 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !626 - mem_copy_val v710, v709 - v711 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !628 - v712 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !629 - mem_copy_val v712, v711 - v713 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !630 - v714 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg86 - mem_copy_val v714, v713 - v715 = get_local __ptr slice, __ret_val56 - v716 = call as_raw_slice_22(v714, v715) - v717 = get_local __ptr slice, _result_________________, !631 - mem_copy_val v717, v715 - v718 = get_local __ptr slice, _result_________________, !632 - v719 = get_local __ptr slice, self_12, !635 - mem_copy_val v719, v718 - v720 = get_local __ptr slice, self_12, !636 - v721 = get_local __ptr slice, slice_8, !637 - mem_copy_val v721, v720 - v722 = get_local __ptr slice, slice_8, !638 - v723 = asm(ptr: v722) -> __ptr { ptr, u64 } ptr { - } - v724 = get_local __ptr { ptr, u64 }, __aggr_memcpy_014 - mem_copy_val v724, v723 - v725 = get_local __ptr { ptr, u64 }, __anon_051, !635 - mem_copy_val v725, v724 - v726 = get_elem_ptr v725, __ptr ptr, v37, !639 - v727 = load v726, !635 - v728 = get_local __ptr slice, _result_________________, !640 - v729 = get_local __ptr slice, __tmp_arg108 - mem_copy_val v729, v728 - v730 = call len_30(v729) - retd v727 v730, !641 - - encode_82_abi_encode_83_block1(): - v731 = const u64 14757395258967588866, !599 - revert v731, !642 - - block25(): - v732 = get_local __ptr slice, _method_name, !643 - v733 = get_global __ptr string<15>, __const_global8 - v734 = cast_ptr v733 to ptr, !644 - v735 = get_local __ptr { ptr, u64 }, __anon_18, !644 - v736 = const u64 0 - v737 = get_elem_ptr v735, __ptr ptr, v736 - store v734 to v737, !644 - v738 = const u64 1 - v739 = get_elem_ptr v735, __ptr u64, v738 - v740 = const u64 15 - store v740 to v739, !644 - v741 = get_local __ptr slice, __anon_19, !644 - mem_copy_bytes v741, v735, 16 - v742 = get_local __ptr slice, __tmp_arg17 - mem_copy_val v742, v732 - v743 = get_local __ptr slice, __tmp_arg18 - mem_copy_val v743, v741 - v744 = call eq_11(v742, v743) - cbr v744, block27(), block28(), !645 - - block27(): - v745 = get_local __ptr { ptr }, _buffer, !646 - v746 = get_elem_ptr v745, __ptr ptr, v19, !651 - v747 = load v746, !652 - v748 = asm(ptr: v747, val) -> u64 val, !653 { - lw val ptr i0, !58 - } - v749 = load v746, !652 - v750 = const u64 8, !652 - v751 = add v749, v750, !652 - store v751 to v746, !654 - v752 = const u64 0, !655 - v753 = cmp eq v748 v752, !658 - cbr v753, decode_84_abi_decode_85_abi_decode_86_block0(), decode_84_abi_decode_85_abi_decode_86_block1(), !659 - - decode_84_abi_decode_85_abi_decode_86_block0(): - v754 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_002, !661 - v755 = const u64 0 - v756 = get_elem_ptr v754, __ptr u64, v755, !662 - v757 = const u64 0, !660 - store v757 to v756, !663 - v758 = load v746, !666 - v759 = asm(ptr: v758, val) -> u64 val, !667 { - lw val ptr i0, !58 - } - v760 = load v746, !666 - v761 = const u64 8, !666 - v762 = add v760, v761, !666 - store v762 to v746, !668 - v763 = const u64 1 - v764 = const u64 0 - v765 = get_elem_ptr v754, __ptr u64, v763, v764, !669 - store v759 to v765, !670 - v766 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg - mem_copy_val v766, v754 - br decode_84_abi_decode_85_abi_decode_86_block5(v766), !671 - - decode_84_abi_decode_85_abi_decode_86_block1(): - v767 = const u64 1, !672 - v768 = cmp eq v748 v767, !675 - cbr v768, decode_84_abi_decode_85_abi_decode_86_block2(), decode_84_abi_decode_85_abi_decode_86_block3(), !676 - - decode_84_abi_decode_85_abi_decode_86_block2(): - v769 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_112, !677 - v770 = const u64 0 - v771 = get_elem_ptr v769, __ptr u64, v770, !678 - v772 = const u64 1, !660 - store v772 to v771, !679 - v773 = load v746, !681 - v774 = asm(ptr: v773, val) -> u64 val, !682 { - lw val ptr i0, !58 - } - v775 = load v746, !681 - v776 = const u64 8, !681 - v777 = add v775, v776, !681 - store v777 to v746, !683 - v778 = const u64 1 - v779 = const u64 1 - v780 = get_elem_ptr v769, __ptr u64, v778, v779, !684 - store v774 to v780, !685 - v781 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg - mem_copy_val v781, v769 - br decode_84_abi_decode_85_abi_decode_86_block5(v781), !686 - - decode_84_abi_decode_85_abi_decode_86_block3(): - v782 = const u64 0, !687 - revert v782, !689 - - decode_84_abi_decode_85_abi_decode_86_block5(v783: __ptr { u64, ( u64 | u64 ) }): - v784 = get_local __ptr { { u64, ( u64 | u64 ) } }, __anon_013, !690 - v785 = const u64 0 - v786 = get_elem_ptr v784, __ptr { u64, ( u64 | u64 ) }, v785, !691 - mem_copy_val v786, v783 - v787 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !692 - mem_copy_val v787, v784 - v788 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !693 - v789 = const u64 0 - v790 = get_elem_ptr v788, __ptr { u64, ( u64 | u64 ) }, v789, !694 - v791 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !697 - mem_copy_val v791, v790 - v792 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !699 - v793 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !700 - mem_copy_val v793, v792 - v794 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !701 - v795 = get_local __ptr { u64, ( u64 | u64 ) }, item_7, !704 - mem_copy_val v795, v794 - v796 = get_local __ptr { u64, ( u64 | u64 ) }, item_7, !705 - v797 = get_local __ptr { { ptr, u64, u64 } }, __ret_val36 - v798 = call new_21(v797) - v799 = get_local __ptr { u64, ( u64 | u64 ) }, self_25, !706 - mem_copy_val v799, v796 - v800 = get_local __ptr { { ptr, u64, u64 } }, buffer_21, !707 - mem_copy_val v800, v797 - v801 = get_local __ptr { u64, ( u64 | u64 ) }, self_25, !709 - v802 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !711 - mem_copy_val v802, v801 - v803 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !712 - v804 = const u64 0 - v805 = get_elem_ptr v803, __ptr u64, v804, !713 - v806 = load v805, !714 - v807 = const u64 0, !708 - v808 = cmp eq v806 v807, !717 - cbr v808, encode_88_abi_encode_89_block0(), encode_88_abi_encode_89_block1(), !718 - - encode_88_abi_encode_89_block0(): - v809 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !719 - v810 = const u64 1 - v811 = const u64 0 - v812 = get_elem_ptr v809, __ptr u64, v810, v811, !720 - v813 = load v812, !721 - v814 = get_local __ptr { { ptr, u64, u64 } }, buffer_21, !723 - v815 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg64 - mem_copy_val v815, v814 - v816 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v817 = const u64 0, !724 - v818 = call abi_encode_20(v817, v815, v816) - v819 = get_local __ptr { { ptr, u64, u64 } }, buffer__5, !726 - mem_copy_val v819, v816 - v820 = get_local __ptr { { ptr, u64, u64 } }, buffer__5, !728 - v821 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg65 - mem_copy_val v821, v820 - v822 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v823 = call abi_encode_20(v813, v821, v822) - v824 = get_local __ptr { { ptr, u64, u64 } }, buffer___0, !730 - mem_copy_val v824, v822 - v825 = get_local __ptr { { ptr, u64, u64 } }, buffer___0, !732 - v826 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg0 - mem_copy_val v826, v825 - br encode_88_abi_encode_89_block5(v826), !733 - - encode_88_abi_encode_89_block1(): - v827 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !734 - v828 = const u64 0 - v829 = get_elem_ptr v827, __ptr u64, v828, !735 - v830 = load v829, !736 - v831 = const u64 1, !708 - v832 = cmp eq v830 v831, !739 - cbr v832, encode_88_abi_encode_89_block2(), encode_88_abi_encode_89_block3(), !740 - - encode_88_abi_encode_89_block2(): - v833 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_12, !741 - v834 = const u64 1 - v835 = const u64 1 - v836 = get_elem_ptr v833, __ptr u64, v834, v835, !742 - v837 = load v836, !743 - v838 = get_local __ptr { { ptr, u64, u64 } }, buffer_21, !745 - v839 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg66 - mem_copy_val v839, v838 - v840 = get_local __ptr { { ptr, u64, u64 } }, __ret_val15 - v841 = const u64 1, !746 - v842 = call abi_encode_20(v841, v839, v840) - v843 = get_local __ptr { { ptr, u64, u64 } }, buffer____0, !748 - mem_copy_val v843, v840 - v844 = get_local __ptr { { ptr, u64, u64 } }, buffer____0, !750 - v845 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg67 - mem_copy_val v845, v844 - v846 = get_local __ptr { { ptr, u64, u64 } }, __ret_val16 - v847 = call abi_encode_20(v837, v845, v846) - v848 = get_local __ptr { { ptr, u64, u64 } }, buffer_____, !752 - mem_copy_val v848, v846 - v849 = get_local __ptr { { ptr, u64, u64 } }, buffer_____, !754 - v850 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg0 - mem_copy_val v850, v849 - br encode_88_abi_encode_89_block5(v850), !755 - - encode_88_abi_encode_89_block3(): - v851 = const u64 14757395258967588866, !710 - revert v851, !756 - - encode_88_abi_encode_89_block5(v852: __ptr { { ptr, u64, u64 } }): - v853 = get_local __ptr { { ptr, u64, u64 } }, buffer______, !758 - mem_copy_val v853, v852 - v854 = get_local __ptr { { ptr, u64, u64 } }, buffer______, !760 - v855 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !761 - mem_copy_val v855, v854 - v856 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !762 - v857 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg87 - mem_copy_val v857, v856 - v858 = get_local __ptr slice, __ret_val57 - v859 = call as_raw_slice_22(v857, v858) - v860 = get_local __ptr slice, _result___________________, !763 - mem_copy_val v860, v858 - v861 = get_local __ptr slice, _result___________________, !764 - v862 = get_local __ptr slice, self_13, !767 - mem_copy_val v862, v861 - v863 = get_local __ptr slice, self_13, !768 - v864 = get_local __ptr slice, slice_9, !769 - mem_copy_val v864, v863 - v865 = get_local __ptr slice, slice_9, !770 - v866 = asm(ptr: v865) -> __ptr { ptr, u64 } ptr { - } - v867 = get_local __ptr { ptr, u64 }, __aggr_memcpy_015 - mem_copy_val v867, v866 - v868 = get_local __ptr { ptr, u64 }, __anon_052, !767 - mem_copy_val v868, v867 - v869 = get_elem_ptr v868, __ptr ptr, v37, !771 - v870 = load v869, !767 - v871 = get_local __ptr slice, _result___________________, !772 - v872 = get_local __ptr slice, __tmp_arg109 - mem_copy_val v872, v871 - v873 = call len_30(v872) - retd v870 v873, !773 - - block28(): - v874 = get_local __ptr slice, _method_name, !774 - v875 = get_global __ptr string<19>, __const_global9 - v876 = cast_ptr v875 to ptr, !775 - v877 = get_local __ptr { ptr, u64 }, __anon_20, !775 - v878 = const u64 0 - v879 = get_elem_ptr v877, __ptr ptr, v878 - store v876 to v879, !775 - v880 = const u64 1 - v881 = get_elem_ptr v877, __ptr u64, v880 - v882 = const u64 19 - store v882 to v881, !775 - v883 = get_local __ptr slice, __anon_21, !775 - mem_copy_bytes v883, v877, 16 - v884 = get_local __ptr slice, __tmp_arg19 - mem_copy_val v884, v874 - v885 = get_local __ptr slice, __tmp_arg20 - mem_copy_val v885, v883 - v886 = call eq_11(v884, v885) - cbr v886, block30(), block31(), !776 - - block30(): - v887 = get_local __ptr { ptr }, _buffer, !777 - v888 = get_elem_ptr v887, __ptr ptr, v19, !782 - v889 = load v888, !783 - v890 = asm(ptr: v889, val) -> u64 val, !784 { - lw val ptr i0, !58 - } - v891 = load v888, !783 - v892 = const u64 8, !783 - v893 = add v891, v892, !783 - store v893 to v888, !785 - v894 = const u64 0, !786 - v895 = cmp eq v890 v894, !789 - cbr v895, decode_90_abi_decode_91_abi_decode_92_block0(), decode_90_abi_decode_91_abi_decode_92_block1(), !790 - - decode_90_abi_decode_91_abi_decode_92_block0(): - v896 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_003, !792 - v897 = const u64 0 - v898 = get_elem_ptr v896, __ptr u64, v897, !793 - v899 = const u64 0, !791 - store v899 to v898, !794 - v900 = load v888, !797 - v901 = asm(ptr: v900, val) -> u64 val, !798 { - lw val ptr i0, !58 - } - v902 = load v888, !797 - v903 = const u64 8, !797 - v904 = add v902, v903, !797 - store v904 to v888, !799 - v905 = const u64 1 - v906 = const u64 0 - v907 = get_elem_ptr v896, __ptr u64, v905, v906, !800 - store v901 to v907, !801 - v908 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg2 - mem_copy_val v908, v896 - br decode_90_abi_decode_91_abi_decode_92_block8(v908), !802 - - decode_90_abi_decode_91_abi_decode_92_block1(): - v909 = const u64 1, !803 - v910 = cmp eq v890 v909, !806 - cbr v910, decode_90_abi_decode_91_abi_decode_92_block2(), decode_90_abi_decode_91_abi_decode_92_block3(), !807 - - decode_90_abi_decode_91_abi_decode_92_block2(): - v911 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_113, !808 - v912 = const u64 0 - v913 = get_elem_ptr v911, __ptr u64, v912, !809 - v914 = const u64 1, !791 - store v914 to v913, !810 - v915 = load v888, !813 - v916 = asm(ptr: v915, val) -> u64 val, !814 { - lw val ptr i0, !58 - } - v917 = load v888, !813 - v918 = const u64 8, !813 - v919 = add v917, v918, !813 - store v919 to v888, !815 - v920 = const u64 1 - v921 = const u64 1 - v922 = get_elem_ptr v911, __ptr u64, v920, v921, !816 - store v916 to v922, !817 - v923 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg1 - mem_copy_val v923, v911 - br decode_90_abi_decode_91_abi_decode_92_block7(v923), !818 - - decode_90_abi_decode_91_abi_decode_92_block3(): - v924 = const u64 2, !819 - v925 = cmp eq v890 v924, !822 - cbr v925, decode_90_abi_decode_91_abi_decode_92_block4(), decode_90_abi_decode_91_abi_decode_92_block5(), !823 - - decode_90_abi_decode_91_abi_decode_92_block4(): - v926 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_212, !824 - v927 = const u64 0 - v928 = get_elem_ptr v926, __ptr u64, v927, !825 - v929 = const u64 2, !791 - store v929 to v928, !826 - v930 = load v888, !829 - v931 = asm(ptr: v930, val) -> u64 val, !830 { - lw val ptr i0, !58 - } - v932 = load v888, !829 - v933 = const u64 8, !829 - v934 = add v932, v933, !829 - store v934 to v888, !831 - v935 = const u64 1 - v936 = const u64 2 - v937 = get_elem_ptr v926, __ptr u64, v935, v936, !832 - store v931 to v937, !833 - v938 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg1 - mem_copy_val v938, v926 - br decode_90_abi_decode_91_abi_decode_92_block7(v938), !834 - - decode_90_abi_decode_91_abi_decode_92_block5(): - v939 = const u64 0, !835 - revert v939, !837 - - decode_90_abi_decode_91_abi_decode_92_block7(v940: __ptr { u64, ( u64 | u64 | u64 ) }): - v941 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg2 - mem_copy_val v941, v940 - br decode_90_abi_decode_91_abi_decode_92_block8(v941), !838 - - decode_90_abi_decode_91_abi_decode_92_block8(v942: __ptr { u64, ( u64 | u64 | u64 ) }): - v943 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, __anon_014, !839 - v944 = const u64 0 - v945 = get_elem_ptr v943, __ptr { u64, ( u64 | u64 | u64 ) }, v944, !840 - mem_copy_val v945, v942 - v946 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !841 - mem_copy_val v946, v943 - v947 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !842 - v948 = const u64 0 - v949 = get_elem_ptr v947, __ptr { u64, ( u64 | u64 | u64 ) }, v948, !843 - v950 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !846 - mem_copy_val v950, v949 - v951 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !848 - v952 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !849 - mem_copy_val v952, v951 - v953 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !850 - v954 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_8, !853 - mem_copy_val v954, v953 - v955 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_8, !854 - v956 = get_local __ptr { { ptr, u64, u64 } }, __ret_val37 - v957 = call new_21(v956) - v958 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, self_28, !855 - mem_copy_val v958, v955 - v959 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !856 - mem_copy_val v959, v956 - v960 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, self_28, !858 - v961 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !860 - mem_copy_val v961, v960 - v962 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !861 - v963 = const u64 0 - v964 = get_elem_ptr v962, __ptr u64, v963, !862 - v965 = load v964, !863 - v966 = const u64 0, !857 - v967 = cmp eq v965 v966, !866 - cbr v967, encode_94_abi_encode_95_block0(), encode_94_abi_encode_95_block1(), !867 - - encode_94_abi_encode_95_block0(): - v968 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !868 - v969 = const u64 1 - v970 = const u64 0 - v971 = get_elem_ptr v968, __ptr u64, v969, v970, !869 - v972 = load v971, !870 - v973 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !872 - v974 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg68 - mem_copy_val v974, v973 - v975 = get_local __ptr { { ptr, u64, u64 } }, __ret_val17 - v976 = const u64 0, !873 - v977 = call abi_encode_20(v976, v974, v975) - v978 = get_local __ptr { { ptr, u64, u64 } }, buffer__6, !875 - mem_copy_val v978, v975 - v979 = get_local __ptr { { ptr, u64, u64 } }, buffer__6, !877 - v980 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg69 - mem_copy_val v980, v979 - v981 = get_local __ptr { { ptr, u64, u64 } }, __ret_val18 - v982 = call abi_encode_20(v972, v980, v981) - v983 = get_local __ptr { { ptr, u64, u64 } }, buffer___1, !879 - mem_copy_val v983, v981 - v984 = get_local __ptr { { ptr, u64, u64 } }, buffer___1, !881 - v985 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg4 - mem_copy_val v985, v984 - br encode_94_abi_encode_95_block8(v985), !882 - - encode_94_abi_encode_95_block1(): - v986 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !883 - v987 = const u64 0 - v988 = get_elem_ptr v986, __ptr u64, v987, !884 - v989 = load v988, !885 - v990 = const u64 1, !857 - v991 = cmp eq v989 v990, !888 - cbr v991, encode_94_abi_encode_95_block2(), encode_94_abi_encode_95_block3(), !889 - - encode_94_abi_encode_95_block2(): - v992 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !890 - v993 = const u64 1 - v994 = const u64 1 - v995 = get_elem_ptr v992, __ptr u64, v993, v994, !891 - v996 = load v995, !892 - v997 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !894 - v998 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg70 - mem_copy_val v998, v997 - v999 = get_local __ptr { { ptr, u64, u64 } }, __ret_val19 - v1000 = const u64 1, !895 - v1001 = call abi_encode_20(v1000, v998, v999) - v1002 = get_local __ptr { { ptr, u64, u64 } }, buffer____1, !897 - mem_copy_val v1002, v999 - v1003 = get_local __ptr { { ptr, u64, u64 } }, buffer____1, !899 - v1004 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg71 - mem_copy_val v1004, v1003 - v1005 = get_local __ptr { { ptr, u64, u64 } }, __ret_val20 - v1006 = call abi_encode_20(v996, v1004, v1005) - v1007 = get_local __ptr { { ptr, u64, u64 } }, buffer_____0, !901 - mem_copy_val v1007, v1005 - v1008 = get_local __ptr { { ptr, u64, u64 } }, buffer_____0, !903 - v1009 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg3 - mem_copy_val v1009, v1008 - br encode_94_abi_encode_95_block7(v1009), !904 - - encode_94_abi_encode_95_block3(): - v1010 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !905 - v1011 = const u64 0 - v1012 = get_elem_ptr v1010, __ptr u64, v1011, !906 - v1013 = load v1012, !907 - v1014 = const u64 2, !857 - v1015 = cmp eq v1013 v1014, !910 - cbr v1015, encode_94_abi_encode_95_block4(), encode_94_abi_encode_95_block5(), !911 - - encode_94_abi_encode_95_block4(): - v1016 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_14, !912 - v1017 = const u64 1 - v1018 = const u64 2 - v1019 = get_elem_ptr v1016, __ptr u64, v1017, v1018, !913 - v1020 = load v1019, !914 - v1021 = get_local __ptr { { ptr, u64, u64 } }, buffer_24, !916 - v1022 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg72 - mem_copy_val v1022, v1021 - v1023 = get_local __ptr { { ptr, u64, u64 } }, __ret_val21 - v1024 = const u64 2, !917 - v1025 = call abi_encode_20(v1024, v1022, v1023) - v1026 = get_local __ptr { { ptr, u64, u64 } }, buffer______0, !919 - mem_copy_val v1026, v1023 - v1027 = get_local __ptr { { ptr, u64, u64 } }, buffer______0, !921 - v1028 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg73 - mem_copy_val v1028, v1027 - v1029 = get_local __ptr { { ptr, u64, u64 } }, __ret_val22 - v1030 = call abi_encode_20(v1020, v1028, v1029) - v1031 = get_local __ptr { { ptr, u64, u64 } }, buffer_______, !923 - mem_copy_val v1031, v1029 - v1032 = get_local __ptr { { ptr, u64, u64 } }, buffer_______, !925 - v1033 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg3 - mem_copy_val v1033, v1032 - br encode_94_abi_encode_95_block7(v1033), !926 - - encode_94_abi_encode_95_block5(): - v1034 = const u64 14757395258967588866, !859 - revert v1034, !927 - - encode_94_abi_encode_95_block7(v1035: __ptr { { ptr, u64, u64 } }): - v1036 = get_local __ptr { { ptr, u64, u64 } }, __tmp_block_arg4 - mem_copy_val v1036, v1035 - br encode_94_abi_encode_95_block8(v1036), !928 - - encode_94_abi_encode_95_block8(v1037: __ptr { { ptr, u64, u64 } }): - v1038 = get_local __ptr { { ptr, u64, u64 } }, buffer________, !930 - mem_copy_val v1038, v1037 - v1039 = get_local __ptr { { ptr, u64, u64 } }, buffer________, !932 - v1040 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !933 - mem_copy_val v1040, v1039 - v1041 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !934 - v1042 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg88 - mem_copy_val v1042, v1041 - v1043 = get_local __ptr slice, __ret_val58 - v1044 = call as_raw_slice_22(v1042, v1043) - v1045 = get_local __ptr slice, _result_____________________, !935 - mem_copy_val v1045, v1043 - v1046 = get_local __ptr slice, _result_____________________, !936 - v1047 = get_local __ptr slice, self_15, !939 - mem_copy_val v1047, v1046 - v1048 = get_local __ptr slice, self_15, !940 - v1049 = get_local __ptr slice, slice_10, !941 - mem_copy_val v1049, v1048 - v1050 = get_local __ptr slice, slice_10, !942 - v1051 = asm(ptr: v1050) -> __ptr { ptr, u64 } ptr { - } - v1052 = get_local __ptr { ptr, u64 }, __aggr_memcpy_016 - mem_copy_val v1052, v1051 - v1053 = get_local __ptr { ptr, u64 }, __anon_053, !939 - mem_copy_val v1053, v1052 - v1054 = get_elem_ptr v1053, __ptr ptr, v37, !943 - v1055 = load v1054, !939 - v1056 = get_local __ptr slice, _result_____________________, !944 - v1057 = get_local __ptr slice, __tmp_arg110 - mem_copy_val v1057, v1056 - v1058 = call len_30(v1057) - retd v1055 v1058, !945 - - block31(): - v1059 = get_local __ptr slice, _method_name, !946 - v1060 = get_global __ptr string<8>, __const_global10 - v1061 = cast_ptr v1060 to ptr, !947 - v1062 = get_local __ptr { ptr, u64 }, __anon_22, !947 - v1063 = const u64 0 - v1064 = get_elem_ptr v1062, __ptr ptr, v1063 - store v1061 to v1064, !947 - v1065 = const u64 1 - v1066 = get_elem_ptr v1062, __ptr u64, v1065 - v1067 = const u64 8 - store v1067 to v1066, !947 - v1068 = get_local __ptr slice, __anon_23, !947 - mem_copy_bytes v1068, v1062, 16 - v1069 = get_local __ptr slice, __tmp_arg21 - mem_copy_val v1069, v1059 - v1070 = get_local __ptr slice, __tmp_arg22 - mem_copy_val v1070, v1068 - v1071 = call eq_11(v1069, v1070) - cbr v1071, block33(), block34(), !948 - - block33(): - v1072 = get_local __ptr { ptr }, _buffer, !949 - v1073 = get_local __ptr slice, __ret_val0 - v1074 = const u64 0 - v1075 = call read_bytes_8(v1072, v1074, v1073) - v1076 = get_local __ptr slice, data0, !953 - mem_copy_val v1076, v1073 - v1077 = get_local __ptr slice, data0, !955 - v1078 = get_local __ptr slice, self_16, !958 - mem_copy_val v1078, v1077 - v1079 = get_local __ptr slice, self_16, !959 - v1080 = get_local __ptr slice, slice_11, !960 - mem_copy_val v1080, v1079 - v1081 = get_local __ptr slice, slice_11, !961 - v1082 = asm(ptr: v1081) -> __ptr { ptr, u64 } ptr { - } - v1083 = get_local __ptr { ptr, u64 }, __aggr_memcpy_017 - mem_copy_val v1083, v1082 - v1084 = get_local __ptr { ptr, u64 }, __anon_054, !958 - mem_copy_val v1084, v1083 - v1085 = get_elem_ptr v1084, __ptr ptr, v37, !962 - v1086 = load v1085, !958 - v1087 = asm(s: v1086) -> __ptr string<0> s { - } - v1088 = get_local __ptr string<0>, __aggr_memcpy_018 - mem_copy_val v1088, v1087 - v1089 = get_local __ptr { string<0> }, __anon_015, !963 - v1090 = const u64 0 - v1091 = get_elem_ptr v1089, __ptr string<0>, v1090, !964 - mem_copy_val v1091, v1088 - v1092 = get_local __ptr { string<0> }, args___________, !965 - mem_copy_val v1092, v1089 - v1093 = get_local __ptr { string<0> }, args___________, !966 - v1094 = const u64 0 - v1095 = get_elem_ptr v1093, __ptr string<0>, v1094, !967 - v1096 = get_local __ptr string<0>, v_10, !970 - mem_copy_val v1096, v1095 - v1097 = get_local __ptr string<0>, v_10, !972 - v1098 = get_local __ptr string<0>, _result______________________, !973 - mem_copy_val v1098, v1097 - v1099 = get_local __ptr string<0>, _result______________________, !974 - v1100 = get_local __ptr string<0>, item_9, !977 - mem_copy_val v1100, v1099 - v1101 = get_local __ptr string<0>, item_9, !978 - v1102 = get_local __ptr { { ptr, u64, u64 } }, __ret_val38 - v1103 = call new_21(v1102) - v1104 = get_local __ptr string<0>, self_33, !979 - mem_copy_val v1104, v1101 - v1105 = get_local __ptr { { ptr, u64, u64 } }, buffer_26, !980 - mem_copy_val v1105, v1102 - v1106 = get_local __ptr { { ptr, u64, u64 } }, buffer_26, !982 - v1107 = const u64 0 - v1108 = get_elem_ptr v1106, __ptr { ptr, u64, u64 }, v1107, !983 - v1109 = asm(buffer: v1108) -> __ptr { ptr, u64, u64 } buffer { - } - v1110 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_019 - mem_copy_val v1110, v1109 - v1111 = get_local __ptr { ptr, u64, u64 }, __anon_016, !984 - mem_copy_val v1111, v1110 - v1112 = const u64 0 - v1113 = get_elem_ptr v1111, __ptr ptr, v1112, !985 - v1114 = load v1113, !986 - v1115 = const u64 1 - v1116 = get_elem_ptr v1111, __ptr u64, v1115, !987 - v1117 = load v1116, !988 - v1118 = const u64 2 - v1119 = get_elem_ptr v1111, __ptr u64, v1118, !989 - v1120 = load v1119, !990 - v1121 = get_local __ptr string<0>, self_33, !992 - v1122 = cmp gt v1120 v1117, !993 - cbr v1122, encode_100_abi_encode_101_block1(), encode_100_abi_encode_101_block0(v1114, v1117), !994 - - encode_100_abi_encode_101_block0(v1123: ptr, v1124: u64): - v1125 = get_local __ptr string<0>, __anon_114, !995 - mem_copy_val v1125, v1121 - v1126 = add v1123, v1120, !996 - v1127 = cast_ptr v1126 to __ptr u8, !997 - mem_copy_bytes v1127, v1125, 0, !998 - v1128 = get_local __ptr { ptr, u64, u64 }, __anon_213, !999 - v1129 = const u64 0 - v1130 = get_elem_ptr v1128, __ptr ptr, v1129, !1000 - store v1123 to v1130, !1001 - v1131 = const u64 1 - v1132 = get_elem_ptr v1128, __ptr u64, v1131, !1002 - store v1124 to v1132, !1003 - v1133 = const u64 2 - v1134 = get_elem_ptr v1128, __ptr u64, v1133, !1004 - store v1120 to v1134, !1005 - v1135 = asm(buffer: v1128) -> __ptr { ptr, u64, u64 } buffer { - } - v1136 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_020 - mem_copy_val v1136, v1135 - v1137 = get_local __ptr { { ptr, u64, u64 } }, __anon_311, !1007 - v1138 = const u64 0 - v1139 = get_elem_ptr v1137, __ptr { ptr, u64, u64 }, v1138, !1008 - mem_copy_val v1139, v1136 - v1140 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !1009 - mem_copy_val v1140, v1137 - v1141 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !1010 - v1142 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg89 - mem_copy_val v1142, v1141 - v1143 = get_local __ptr slice, __ret_val59 - v1144 = call as_raw_slice_22(v1142, v1143) - v1145 = get_local __ptr slice, _result_______________________, !1011 - mem_copy_val v1145, v1143 - v1146 = get_local __ptr slice, _result_______________________, !1012 - v1147 = get_local __ptr slice, self_17, !1015 - mem_copy_val v1147, v1146 - v1148 = get_local __ptr slice, self_17, !1016 - v1149 = get_local __ptr slice, slice_12, !1017 - mem_copy_val v1149, v1148 - v1150 = get_local __ptr slice, slice_12, !1018 - v1151 = asm(ptr: v1150) -> __ptr { ptr, u64 } ptr { - } - v1152 = get_local __ptr { ptr, u64 }, __aggr_memcpy_021 - mem_copy_val v1152, v1151 - v1153 = get_local __ptr { ptr, u64 }, __anon_055, !1015 - mem_copy_val v1153, v1152 - v1154 = get_elem_ptr v1153, __ptr ptr, v37, !1019 - v1155 = load v1154, !1015 - v1156 = get_local __ptr slice, _result_______________________, !1020 - v1157 = get_local __ptr slice, __tmp_arg111 - mem_copy_val v1157, v1156 - v1158 = call len_30(v1157) - retd v1155 v1158, !1021 - - encode_100_abi_encode_101_block1(): - v1159 = const u64 2 - v1160 = mul v1117, v1159, !1022 - v1161 = asm(new_cap: v1160, old_ptr: v1114, len: v1120) -> __ptr u8 hp, !1023 { - aloc new_cap - mcp hp old_ptr len - } - br encode_100_abi_encode_101_block0(v1161, v1160), !1024 - - block34(): - v1162 = get_local __ptr slice, _method_name, !1025 - v1163 = get_global __ptr string<8>, __const_global11 - v1164 = cast_ptr v1163 to ptr, !1026 - v1165 = get_local __ptr { ptr, u64 }, __anon_24, !1026 - v1166 = const u64 0 - v1167 = get_elem_ptr v1165, __ptr ptr, v1166 - store v1164 to v1167, !1026 - v1168 = const u64 1 - v1169 = get_elem_ptr v1165, __ptr u64, v1168 - v1170 = const u64 8 - store v1170 to v1169, !1026 - v1171 = get_local __ptr slice, __anon_25, !1026 - mem_copy_bytes v1171, v1165, 16 - v1172 = get_local __ptr slice, __tmp_arg23 - mem_copy_val v1172, v1162 - v1173 = get_local __ptr slice, __tmp_arg24 - mem_copy_val v1173, v1171 - v1174 = call eq_11(v1172, v1173) - cbr v1174, block36(), block37(), !1027 - - block36(): - v1175 = get_local __ptr { ptr }, _buffer, !1028 - v1176 = get_local __ptr slice, __ret_val1 - v1177 = const u64 1 - v1178 = call read_bytes_8(v1175, v1177, v1176) - v1179 = get_local __ptr slice, data1, !1031 - mem_copy_val v1179, v1176 - v1180 = get_local __ptr slice, data1, !1032 - v1181 = get_local __ptr slice, self_19, !1033 - mem_copy_val v1181, v1180 - v1182 = get_local __ptr slice, self_19, !1034 - v1183 = get_local __ptr slice, slice_13, !1035 - mem_copy_val v1183, v1182 - v1184 = get_local __ptr slice, slice_13, !1036 - v1185 = asm(ptr: v1184) -> __ptr { ptr, u64 } ptr { - } - v1186 = get_local __ptr { ptr, u64 }, __aggr_memcpy_022 - mem_copy_val v1186, v1185 - v1187 = get_local __ptr { ptr, u64 }, __anon_056, !1033 - mem_copy_val v1187, v1186 - v1188 = get_elem_ptr v1187, __ptr ptr, v37, !1037 - v1189 = load v1188, !1033 - v1190 = asm(s: v1189) -> __ptr string<1> s { - } - v1191 = get_local __ptr string<1>, __aggr_memcpy_023 - mem_copy_val v1191, v1190 - v1192 = get_local __ptr { string<1> }, __anon_017, !1038 - v1193 = const u64 0 - v1194 = get_elem_ptr v1192, __ptr string<1>, v1193, !1039 - mem_copy_val v1194, v1191 - v1195 = get_local __ptr { string<1> }, args____________, !1040 - mem_copy_val v1195, v1192 - v1196 = get_local __ptr { string<1> }, args____________, !1041 - v1197 = const u64 0 - v1198 = get_elem_ptr v1196, __ptr string<1>, v1197, !1042 - v1199 = get_local __ptr string<1>, v_11, !1045 - mem_copy_val v1199, v1198 - v1200 = get_local __ptr string<1>, v_11, !1047 - v1201 = get_local __ptr string<1>, _result________________________, !1048 - mem_copy_val v1201, v1200 - v1202 = get_local __ptr string<1>, _result________________________, !1049 - v1203 = get_local __ptr string<1>, item_10, !1052 - mem_copy_val v1203, v1202 - v1204 = get_local __ptr string<1>, item_10, !1053 - v1205 = get_local __ptr { { ptr, u64, u64 } }, __ret_val39 - v1206 = call new_21(v1205) - v1207 = get_local __ptr string<1>, self_35, !1054 - mem_copy_val v1207, v1204 - v1208 = get_local __ptr { { ptr, u64, u64 } }, buffer_28, !1055 - mem_copy_val v1208, v1205 - v1209 = get_local __ptr { { ptr, u64, u64 } }, buffer_28, !1056 - v1210 = const u64 0 - v1211 = get_elem_ptr v1209, __ptr { ptr, u64, u64 }, v1210, !1057 - v1212 = asm(buffer: v1211) -> __ptr { ptr, u64, u64 } buffer { - } - v1213 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_024 - mem_copy_val v1213, v1212 - v1214 = get_local __ptr { ptr, u64, u64 }, __anon_018, !1058 - mem_copy_val v1214, v1213 - v1215 = const u64 0 - v1216 = get_elem_ptr v1214, __ptr ptr, v1215, !1059 - v1217 = load v1216, !1060 - v1218 = const u64 1 - v1219 = get_elem_ptr v1214, __ptr u64, v1218, !1061 - v1220 = load v1219, !1062 - v1221 = const u64 2 - v1222 = get_elem_ptr v1214, __ptr u64, v1221, !1063 - v1223 = load v1222, !1064 - v1224 = get_local __ptr string<1>, self_35, !1065 - v1225 = const u64 1 - v1226 = add v1223, v1225, !1066 - v1227 = cmp gt v1226 v1220, !1067 - cbr v1227, encode_106_abi_encode_107_block1(), encode_106_abi_encode_107_block0(v1217, v1220), !1068 - - encode_106_abi_encode_107_block0(v1228: ptr, v1229: u64): - v1230 = get_local __ptr string<1>, __anon_115, !1069 - mem_copy_val v1230, v1224 - v1231 = add v1228, v1223, !1070 - v1232 = cast_ptr v1231 to __ptr u8, !1071 - mem_copy_bytes v1232, v1230, 1, !1072 - v1233 = get_local __ptr { ptr, u64, u64 }, __anon_214, !1073 - v1234 = const u64 0 - v1235 = get_elem_ptr v1233, __ptr ptr, v1234, !1074 - store v1228 to v1235, !1075 - v1236 = const u64 1 - v1237 = get_elem_ptr v1233, __ptr u64, v1236, !1076 - store v1229 to v1237, !1077 - v1238 = const u64 2 - v1239 = get_elem_ptr v1233, __ptr u64, v1238, !1078 - store v1226 to v1239, !1079 - v1240 = asm(buffer: v1233) -> __ptr { ptr, u64, u64 } buffer { - } - v1241 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_025 - mem_copy_val v1241, v1240 - v1242 = get_local __ptr { { ptr, u64, u64 } }, __anon_312, !1080 - v1243 = const u64 0 - v1244 = get_elem_ptr v1242, __ptr { ptr, u64, u64 }, v1243, !1081 - mem_copy_val v1244, v1241 - v1245 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !1082 - mem_copy_val v1245, v1242 - v1246 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !1083 - v1247 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg90 - mem_copy_val v1247, v1246 - v1248 = get_local __ptr slice, __ret_val60 - v1249 = call as_raw_slice_22(v1247, v1248) - v1250 = get_local __ptr slice, _result_________________________, !1084 - mem_copy_val v1250, v1248 - v1251 = get_local __ptr slice, _result_________________________, !1085 - v1252 = get_local __ptr slice, self_20, !1088 - mem_copy_val v1252, v1251 - v1253 = get_local __ptr slice, self_20, !1089 - v1254 = get_local __ptr slice, slice_14, !1090 - mem_copy_val v1254, v1253 - v1255 = get_local __ptr slice, slice_14, !1091 - v1256 = asm(ptr: v1255) -> __ptr { ptr, u64 } ptr { - } - v1257 = get_local __ptr { ptr, u64 }, __aggr_memcpy_026 - mem_copy_val v1257, v1256 - v1258 = get_local __ptr { ptr, u64 }, __anon_057, !1088 - mem_copy_val v1258, v1257 - v1259 = get_elem_ptr v1258, __ptr ptr, v37, !1092 - v1260 = load v1259, !1088 - v1261 = get_local __ptr slice, _result_________________________, !1093 - v1262 = get_local __ptr slice, __tmp_arg112 - mem_copy_val v1262, v1261 - v1263 = call len_30(v1262) - retd v1260 v1263, !1094 - - encode_106_abi_encode_107_block1(): - v1264 = const u64 2 - v1265 = mul v1220, v1264, !1095 - v1266 = add v1265, v1225, !1096 - v1267 = asm(new_cap: v1266, old_ptr: v1217, len: v1223) -> __ptr u8 hp, !1097 { - aloc new_cap - mcp hp old_ptr len - } - br encode_106_abi_encode_107_block0(v1267, v1266), !1098 - - block37(): - v1268 = get_local __ptr slice, _method_name, !1099 - v1269 = get_global __ptr string<9>, __const_global12 - v1270 = cast_ptr v1269 to ptr, !1100 - v1271 = get_local __ptr { ptr, u64 }, __anon_26, !1100 - v1272 = const u64 0 - v1273 = get_elem_ptr v1271, __ptr ptr, v1272 - store v1270 to v1273, !1100 - v1274 = const u64 1 - v1275 = get_elem_ptr v1271, __ptr u64, v1274 - v1276 = const u64 9 - store v1276 to v1275, !1100 - v1277 = get_local __ptr slice, __anon_27, !1100 - mem_copy_bytes v1277, v1271, 16 - v1278 = get_local __ptr slice, __tmp_arg25 - mem_copy_val v1278, v1268 - v1279 = get_local __ptr slice, __tmp_arg26 - mem_copy_val v1279, v1277 - v1280 = call eq_11(v1278, v1279) - cbr v1280, block39(), block40(), !1101 - - block39(): - v1281 = get_local __ptr { ptr }, _buffer, !1102 - v1282 = get_local __ptr slice, __ret_val2 - v1283 = const u64 16 - v1284 = call read_bytes_8(v1281, v1283, v1282) - v1285 = get_local __ptr slice, data2, !1105 - mem_copy_val v1285, v1282 - v1286 = get_local __ptr slice, data2, !1106 - v1287 = get_local __ptr slice, self_21, !1107 - mem_copy_val v1287, v1286 - v1288 = get_local __ptr slice, self_21, !1108 - v1289 = get_local __ptr slice, slice_15, !1109 - mem_copy_val v1289, v1288 - v1290 = get_local __ptr slice, slice_15, !1110 - v1291 = asm(ptr: v1290) -> __ptr { ptr, u64 } ptr { - } - v1292 = get_local __ptr { ptr, u64 }, __aggr_memcpy_027 - mem_copy_val v1292, v1291 - v1293 = get_local __ptr { ptr, u64 }, __anon_058, !1107 - mem_copy_val v1293, v1292 - v1294 = get_elem_ptr v1293, __ptr ptr, v37, !1111 - v1295 = load v1294, !1107 - v1296 = asm(s: v1295) -> __ptr string<16> s { - } - v1297 = get_local __ptr string<16>, __aggr_memcpy_028 - mem_copy_val v1297, v1296 - v1298 = get_local __ptr { string<16> }, __anon_019, !1112 - v1299 = const u64 0 - v1300 = get_elem_ptr v1298, __ptr string<16>, v1299, !1113 - mem_copy_val v1300, v1297 - v1301 = get_local __ptr { string<16> }, args_____________, !1114 - mem_copy_val v1301, v1298 - v1302 = get_local __ptr { string<16> }, args_____________, !1115 - v1303 = const u64 0 - v1304 = get_elem_ptr v1302, __ptr string<16>, v1303, !1116 - v1305 = get_local __ptr string<16>, v_12, !1119 - mem_copy_val v1305, v1304 - v1306 = get_local __ptr string<16>, v_12, !1121 - v1307 = get_local __ptr string<16>, _result__________________________, !1122 - mem_copy_val v1307, v1306 - v1308 = get_local __ptr string<16>, _result__________________________, !1123 - v1309 = get_local __ptr string<16>, item_11, !1126 - mem_copy_val v1309, v1308 - v1310 = get_local __ptr string<16>, item_11, !1127 - v1311 = get_local __ptr { { ptr, u64, u64 } }, __ret_val40 - v1312 = call new_21(v1311) - v1313 = get_local __ptr string<16>, self_37, !1128 - mem_copy_val v1313, v1310 - v1314 = get_local __ptr { { ptr, u64, u64 } }, buffer_31, !1129 - mem_copy_val v1314, v1311 - v1315 = get_local __ptr { { ptr, u64, u64 } }, buffer_31, !1130 - v1316 = const u64 0 - v1317 = get_elem_ptr v1315, __ptr { ptr, u64, u64 }, v1316, !1131 - v1318 = asm(buffer: v1317) -> __ptr { ptr, u64, u64 } buffer { - } - v1319 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_029 - mem_copy_val v1319, v1318 - v1320 = get_local __ptr { ptr, u64, u64 }, __anon_020, !1132 - mem_copy_val v1320, v1319 - v1321 = const u64 0 - v1322 = get_elem_ptr v1320, __ptr ptr, v1321, !1133 - v1323 = load v1322, !1134 - v1324 = const u64 1 - v1325 = get_elem_ptr v1320, __ptr u64, v1324, !1135 - v1326 = load v1325, !1136 - v1327 = const u64 2 - v1328 = get_elem_ptr v1320, __ptr u64, v1327, !1137 - v1329 = load v1328, !1138 - v1330 = get_local __ptr string<16>, self_37, !1139 - v1331 = const u64 16 - v1332 = add v1329, v1331, !1140 - v1333 = cmp gt v1332 v1326, !1141 - cbr v1333, encode_112_abi_encode_113_block1(), encode_112_abi_encode_113_block0(v1323, v1326), !1142 - - encode_112_abi_encode_113_block0(v1334: ptr, v1335: u64): - v1336 = get_local __ptr string<16>, __anon_116, !1143 - mem_copy_val v1336, v1330 - v1337 = add v1334, v1329, !1144 - v1338 = cast_ptr v1337 to __ptr u8, !1145 - mem_copy_bytes v1338, v1336, 16, !1146 - v1339 = get_local __ptr { ptr, u64, u64 }, __anon_215, !1147 - v1340 = const u64 0 - v1341 = get_elem_ptr v1339, __ptr ptr, v1340, !1148 - store v1334 to v1341, !1149 - v1342 = const u64 1 - v1343 = get_elem_ptr v1339, __ptr u64, v1342, !1150 - store v1335 to v1343, !1151 - v1344 = const u64 2 - v1345 = get_elem_ptr v1339, __ptr u64, v1344, !1152 - store v1332 to v1345, !1153 - v1346 = asm(buffer: v1339) -> __ptr { ptr, u64, u64 } buffer { - } - v1347 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_030 - mem_copy_val v1347, v1346 - v1348 = get_local __ptr { { ptr, u64, u64 } }, __anon_313, !1154 - v1349 = const u64 0 - v1350 = get_elem_ptr v1348, __ptr { ptr, u64, u64 }, v1349, !1155 - mem_copy_val v1350, v1347 - v1351 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !1156 - mem_copy_val v1351, v1348 - v1352 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !1157 - v1353 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg91 - mem_copy_val v1353, v1352 - v1354 = get_local __ptr slice, __ret_val61 - v1355 = call as_raw_slice_22(v1353, v1354) - v1356 = get_local __ptr slice, _result___________________________, !1158 - mem_copy_val v1356, v1354 - v1357 = get_local __ptr slice, _result___________________________, !1159 - v1358 = get_local __ptr slice, self_23, !1162 - mem_copy_val v1358, v1357 - v1359 = get_local __ptr slice, self_23, !1163 - v1360 = get_local __ptr slice, slice_16, !1164 - mem_copy_val v1360, v1359 - v1361 = get_local __ptr slice, slice_16, !1165 - v1362 = asm(ptr: v1361) -> __ptr { ptr, u64 } ptr { - } - v1363 = get_local __ptr { ptr, u64 }, __aggr_memcpy_031 - mem_copy_val v1363, v1362 - v1364 = get_local __ptr { ptr, u64 }, __anon_059, !1162 - mem_copy_val v1364, v1363 - v1365 = get_elem_ptr v1364, __ptr ptr, v37, !1166 - v1366 = load v1365, !1162 - v1367 = get_local __ptr slice, _result___________________________, !1167 - v1368 = get_local __ptr slice, __tmp_arg113 - mem_copy_val v1368, v1367 - v1369 = call len_30(v1368) - retd v1366 v1369, !1168 - - encode_112_abi_encode_113_block1(): - v1370 = const u64 2 - v1371 = mul v1326, v1370, !1169 - v1372 = add v1371, v1331, !1170 - v1373 = asm(new_cap: v1372, old_ptr: v1323, len: v1329) -> __ptr u8 hp, !1171 { - aloc new_cap - mcp hp old_ptr len - } - br encode_112_abi_encode_113_block0(v1373, v1372), !1172 - - block40(): - v1374 = get_local __ptr slice, _method_name, !1173 - v1375 = get_global __ptr string<9>, __const_global13 - v1376 = cast_ptr v1375 to ptr, !1174 - v1377 = get_local __ptr { ptr, u64 }, __anon_28, !1174 - v1378 = const u64 0 - v1379 = get_elem_ptr v1377, __ptr ptr, v1378 - store v1376 to v1379, !1174 - v1380 = const u64 1 - v1381 = get_elem_ptr v1377, __ptr u64, v1380 - v1382 = const u64 9 - store v1382 to v1381, !1174 - v1383 = get_local __ptr slice, __anon_29, !1174 - mem_copy_bytes v1383, v1377, 16 - v1384 = get_local __ptr slice, __tmp_arg27 - mem_copy_val v1384, v1374 - v1385 = get_local __ptr slice, __tmp_arg28 - mem_copy_val v1385, v1383 - v1386 = call eq_11(v1384, v1385) - cbr v1386, block42(), block43(), !1175 - - block42(): - v1387 = get_local __ptr { ptr }, _buffer, !1176 - v1388 = get_local __ptr slice, __ret_val3 - v1389 = const u64 32 - v1390 = call read_bytes_8(v1387, v1389, v1388) - v1391 = get_local __ptr slice, data3, !1179 - mem_copy_val v1391, v1388 - v1392 = get_local __ptr slice, data3, !1180 - v1393 = get_local __ptr slice, self_24, !1181 - mem_copy_val v1393, v1392 - v1394 = get_local __ptr slice, self_24, !1182 - v1395 = get_local __ptr slice, slice_17, !1183 - mem_copy_val v1395, v1394 - v1396 = get_local __ptr slice, slice_17, !1184 - v1397 = asm(ptr: v1396) -> __ptr { ptr, u64 } ptr { - } - v1398 = get_local __ptr { ptr, u64 }, __aggr_memcpy_032 - mem_copy_val v1398, v1397 - v1399 = get_local __ptr { ptr, u64 }, __anon_060, !1181 - mem_copy_val v1399, v1398 - v1400 = get_elem_ptr v1399, __ptr ptr, v37, !1185 - v1401 = load v1400, !1181 - v1402 = asm(s: v1401) -> __ptr string<32> s { - } - v1403 = get_local __ptr string<32>, __aggr_memcpy_033 - mem_copy_val v1403, v1402 - v1404 = get_local __ptr { string<32> }, __anon_021, !1186 - v1405 = const u64 0 - v1406 = get_elem_ptr v1404, __ptr string<32>, v1405, !1187 - mem_copy_val v1406, v1403 - v1407 = get_local __ptr { string<32> }, args______________, !1188 - mem_copy_val v1407, v1404 - v1408 = get_local __ptr { string<32> }, args______________, !1189 - v1409 = const u64 0 - v1410 = get_elem_ptr v1408, __ptr string<32>, v1409, !1190 - v1411 = get_local __ptr string<32>, v_13, !1193 - mem_copy_val v1411, v1410 - v1412 = get_local __ptr string<32>, v_13, !1195 - v1413 = get_local __ptr string<32>, _result____________________________, !1196 - mem_copy_val v1413, v1412 - v1414 = get_local __ptr string<32>, _result____________________________, !1197 - v1415 = get_local __ptr string<32>, item_12, !1200 - mem_copy_val v1415, v1414 - v1416 = get_local __ptr string<32>, item_12, !1201 - v1417 = get_local __ptr { { ptr, u64, u64 } }, __ret_val41 - v1418 = call new_21(v1417) - v1419 = get_local __ptr string<32>, self_39, !1202 - mem_copy_val v1419, v1416 - v1420 = get_local __ptr { { ptr, u64, u64 } }, buffer_33, !1203 - mem_copy_val v1420, v1417 - v1421 = get_local __ptr { { ptr, u64, u64 } }, buffer_33, !1204 - v1422 = const u64 0 - v1423 = get_elem_ptr v1421, __ptr { ptr, u64, u64 }, v1422, !1205 - v1424 = asm(buffer: v1423) -> __ptr { ptr, u64, u64 } buffer { - } - v1425 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_034 - mem_copy_val v1425, v1424 - v1426 = get_local __ptr { ptr, u64, u64 }, __anon_022, !1206 - mem_copy_val v1426, v1425 - v1427 = const u64 0 - v1428 = get_elem_ptr v1426, __ptr ptr, v1427, !1207 - v1429 = load v1428, !1208 - v1430 = const u64 1 - v1431 = get_elem_ptr v1426, __ptr u64, v1430, !1209 - v1432 = load v1431, !1210 - v1433 = const u64 2 - v1434 = get_elem_ptr v1426, __ptr u64, v1433, !1211 - v1435 = load v1434, !1212 - v1436 = get_local __ptr string<32>, self_39, !1213 - v1437 = const u64 32 - v1438 = add v1435, v1437, !1214 - v1439 = cmp gt v1438 v1432, !1215 - cbr v1439, encode_118_abi_encode_119_block1(), encode_118_abi_encode_119_block0(v1429, v1432), !1216 - - encode_118_abi_encode_119_block0(v1440: ptr, v1441: u64): - v1442 = get_local __ptr string<32>, __anon_117, !1217 - mem_copy_val v1442, v1436 - v1443 = add v1440, v1435, !1218 - v1444 = cast_ptr v1443 to __ptr u8, !1219 - mem_copy_bytes v1444, v1442, 32, !1220 - v1445 = get_local __ptr { ptr, u64, u64 }, __anon_216, !1221 - v1446 = const u64 0 - v1447 = get_elem_ptr v1445, __ptr ptr, v1446, !1222 - store v1440 to v1447, !1223 - v1448 = const u64 1 - v1449 = get_elem_ptr v1445, __ptr u64, v1448, !1224 - store v1441 to v1449, !1225 - v1450 = const u64 2 - v1451 = get_elem_ptr v1445, __ptr u64, v1450, !1226 - store v1438 to v1451, !1227 - v1452 = asm(buffer: v1445) -> __ptr { ptr, u64, u64 } buffer { - } - v1453 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_035 - mem_copy_val v1453, v1452 - v1454 = get_local __ptr { { ptr, u64, u64 } }, __anon_314, !1228 - v1455 = const u64 0 - v1456 = get_elem_ptr v1454, __ptr { ptr, u64, u64 }, v1455, !1229 - mem_copy_val v1456, v1453 - v1457 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !1230 - mem_copy_val v1457, v1454 - v1458 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !1231 - v1459 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg92 - mem_copy_val v1459, v1458 - v1460 = get_local __ptr slice, __ret_val62 - v1461 = call as_raw_slice_22(v1459, v1460) - v1462 = get_local __ptr slice, _result_____________________________, !1232 - mem_copy_val v1462, v1460 - v1463 = get_local __ptr slice, _result_____________________________, !1233 - v1464 = get_local __ptr slice, self_26, !1236 - mem_copy_val v1464, v1463 - v1465 = get_local __ptr slice, self_26, !1237 - v1466 = get_local __ptr slice, slice_18, !1238 - mem_copy_val v1466, v1465 - v1467 = get_local __ptr slice, slice_18, !1239 - v1468 = asm(ptr: v1467) -> __ptr { ptr, u64 } ptr { - } - v1469 = get_local __ptr { ptr, u64 }, __aggr_memcpy_036 - mem_copy_val v1469, v1468 - v1470 = get_local __ptr { ptr, u64 }, __anon_061, !1236 - mem_copy_val v1470, v1469 - v1471 = get_elem_ptr v1470, __ptr ptr, v37, !1240 - v1472 = load v1471, !1236 - v1473 = get_local __ptr slice, _result_____________________________, !1241 - v1474 = get_local __ptr slice, __tmp_arg114 - mem_copy_val v1474, v1473 - v1475 = call len_30(v1474) - retd v1472 v1475, !1242 - - encode_118_abi_encode_119_block1(): - v1476 = const u64 2 - v1477 = mul v1432, v1476, !1243 - v1478 = add v1477, v1437, !1244 - v1479 = asm(new_cap: v1478, old_ptr: v1429, len: v1435) -> __ptr u8 hp, !1245 { - aloc new_cap - mcp hp old_ptr len - } - br encode_118_abi_encode_119_block0(v1479, v1478), !1246 - - block43(): - v1480 = get_local __ptr slice, _method_name, !1247 - v1481 = get_global __ptr string<8>, __const_global14 - v1482 = cast_ptr v1481 to ptr, !1248 - v1483 = get_local __ptr { ptr, u64 }, __anon_30, !1248 - v1484 = const u64 0 - v1485 = get_elem_ptr v1483, __ptr ptr, v1484 - store v1482 to v1485, !1248 - v1486 = const u64 1 - v1487 = get_elem_ptr v1483, __ptr u64, v1486 - v1488 = const u64 8 - store v1488 to v1487, !1248 - v1489 = get_local __ptr slice, __anon_31, !1248 - mem_copy_bytes v1489, v1483, 16 - v1490 = get_local __ptr slice, __tmp_arg29 - mem_copy_val v1490, v1480 - v1491 = get_local __ptr slice, __tmp_arg30 - mem_copy_val v1491, v1489 - v1492 = call eq_11(v1490, v1491) - cbr v1492, block45(), block46(), !1249 - - block45(): - v1493 = get_local __ptr { ptr }, _buffer, !1250 - v1494 = get_local __ptr slice, __ret_val4 - v1495 = const u64 8 - v1496 = call read_bytes_8(v1493, v1495, v1494) - v1497 = get_local __ptr slice, data4, !1253 - mem_copy_val v1497, v1494 - v1498 = get_local __ptr slice, data4, !1254 - v1499 = get_local __ptr slice, self_27, !1255 - mem_copy_val v1499, v1498 - v1500 = get_local __ptr slice, self_27, !1256 - v1501 = get_local __ptr slice, slice_19, !1257 - mem_copy_val v1501, v1500 - v1502 = get_local __ptr slice, slice_19, !1258 - v1503 = asm(ptr: v1502) -> __ptr { ptr, u64 } ptr { - } - v1504 = get_local __ptr { ptr, u64 }, __aggr_memcpy_037 - mem_copy_val v1504, v1503 - v1505 = get_local __ptr { ptr, u64 }, __anon_062, !1255 - mem_copy_val v1505, v1504 - v1506 = get_elem_ptr v1505, __ptr ptr, v37, !1259 - v1507 = load v1506, !1255 - v1508 = asm(s: v1507) -> __ptr string<8> s { - } - v1509 = get_local __ptr string<8>, __aggr_memcpy_038 - mem_copy_val v1509, v1508 - v1510 = get_local __ptr { string<8> }, __anon_023, !1260 - v1511 = const u64 0 - v1512 = get_elem_ptr v1510, __ptr string<8>, v1511, !1261 - mem_copy_val v1512, v1509 - v1513 = get_local __ptr { string<8> }, args_______________, !1262 - mem_copy_val v1513, v1510 - v1514 = get_local __ptr { string<8> }, args_______________, !1263 - v1515 = const u64 0 - v1516 = get_elem_ptr v1514, __ptr string<8>, v1515, !1264 - v1517 = get_local __ptr string<8>, v_14, !1267 - mem_copy_val v1517, v1516 - v1518 = get_local __ptr string<8>, v_14, !1269 - v1519 = get_local __ptr string<8>, _result______________________________, !1270 - mem_copy_val v1519, v1518 - v1520 = get_local __ptr string<8>, _result______________________________, !1271 - v1521 = get_local __ptr string<8>, item_13, !1274 - mem_copy_val v1521, v1520 - v1522 = get_local __ptr string<8>, item_13, !1275 - v1523 = get_local __ptr { { ptr, u64, u64 } }, __ret_val42 - v1524 = call new_21(v1523) - v1525 = get_local __ptr string<8>, self_42, !1276 - mem_copy_val v1525, v1522 - v1526 = get_local __ptr { { ptr, u64, u64 } }, buffer_35, !1277 - mem_copy_val v1526, v1523 - v1527 = get_local __ptr { { ptr, u64, u64 } }, buffer_35, !1278 - v1528 = const u64 0 - v1529 = get_elem_ptr v1527, __ptr { ptr, u64, u64 }, v1528, !1279 - v1530 = asm(buffer: v1529) -> __ptr { ptr, u64, u64 } buffer { - } - v1531 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_039 - mem_copy_val v1531, v1530 - v1532 = get_local __ptr { ptr, u64, u64 }, __anon_024, !1280 - mem_copy_val v1532, v1531 - v1533 = const u64 0 - v1534 = get_elem_ptr v1532, __ptr ptr, v1533, !1281 - v1535 = load v1534, !1282 - v1536 = const u64 1 - v1537 = get_elem_ptr v1532, __ptr u64, v1536, !1283 - v1538 = load v1537, !1284 - v1539 = const u64 2 - v1540 = get_elem_ptr v1532, __ptr u64, v1539, !1285 - v1541 = load v1540, !1286 - v1542 = get_local __ptr string<8>, self_42, !1287 - v1543 = const u64 8 - v1544 = add v1541, v1543, !1288 - v1545 = cmp gt v1544 v1538, !1289 - cbr v1545, encode_124_abi_encode_125_block1(), encode_124_abi_encode_125_block0(v1535, v1538), !1290 - - encode_124_abi_encode_125_block0(v1546: ptr, v1547: u64): - v1548 = get_local __ptr string<8>, __anon_118, !1291 - mem_copy_val v1548, v1542 - v1549 = add v1546, v1541, !1292 - v1550 = cast_ptr v1549 to __ptr u8, !1293 - mem_copy_bytes v1550, v1548, 8, !1294 - v1551 = get_local __ptr { ptr, u64, u64 }, __anon_217, !1295 - v1552 = const u64 0 - v1553 = get_elem_ptr v1551, __ptr ptr, v1552, !1296 - store v1546 to v1553, !1297 - v1554 = const u64 1 - v1555 = get_elem_ptr v1551, __ptr u64, v1554, !1298 - store v1547 to v1555, !1299 - v1556 = const u64 2 - v1557 = get_elem_ptr v1551, __ptr u64, v1556, !1300 - store v1544 to v1557, !1301 - v1558 = asm(buffer: v1551) -> __ptr { ptr, u64, u64 } buffer { - } - v1559 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_040 - mem_copy_val v1559, v1558 - v1560 = get_local __ptr { { ptr, u64, u64 } }, __anon_315, !1302 - v1561 = const u64 0 - v1562 = get_elem_ptr v1560, __ptr { ptr, u64, u64 }, v1561, !1303 - mem_copy_val v1562, v1559 - v1563 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !1304 - mem_copy_val v1563, v1560 - v1564 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !1305 - v1565 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg93 - mem_copy_val v1565, v1564 - v1566 = get_local __ptr slice, __ret_val63 - v1567 = call as_raw_slice_22(v1565, v1566) - v1568 = get_local __ptr slice, _result_______________________________, !1306 - mem_copy_val v1568, v1566 - v1569 = get_local __ptr slice, _result_______________________________, !1307 - v1570 = get_local __ptr slice, self_29, !1310 - mem_copy_val v1570, v1569 - v1571 = get_local __ptr slice, self_29, !1311 - v1572 = get_local __ptr slice, slice_20, !1312 - mem_copy_val v1572, v1571 - v1573 = get_local __ptr slice, slice_20, !1313 - v1574 = asm(ptr: v1573) -> __ptr { ptr, u64 } ptr { - } - v1575 = get_local __ptr { ptr, u64 }, __aggr_memcpy_041 - mem_copy_val v1575, v1574 - v1576 = get_local __ptr { ptr, u64 }, __anon_063, !1310 - mem_copy_val v1576, v1575 - v1577 = get_elem_ptr v1576, __ptr ptr, v37, !1314 - v1578 = load v1577, !1310 - v1579 = get_local __ptr slice, _result_______________________________, !1315 - v1580 = get_local __ptr slice, __tmp_arg115 - mem_copy_val v1580, v1579 - v1581 = call len_30(v1580) - retd v1578 v1581, !1316 - - encode_124_abi_encode_125_block1(): - v1582 = const u64 2 - v1583 = mul v1538, v1582, !1317 - v1584 = add v1583, v1543, !1318 - v1585 = asm(new_cap: v1584, old_ptr: v1535, len: v1541) -> __ptr u8 hp, !1319 { - aloc new_cap - mcp hp old_ptr len - } - br encode_124_abi_encode_125_block0(v1585, v1584), !1320 - - block46(): - v1586 = get_local __ptr slice, _method_name, !1321 - v1587 = get_global __ptr string<13>, __const_global15 - v1588 = cast_ptr v1587 to ptr, !1322 - v1589 = get_local __ptr { ptr, u64 }, __anon_32, !1322 - v1590 = const u64 0 - v1591 = get_elem_ptr v1589, __ptr ptr, v1590 - store v1588 to v1591, !1322 - v1592 = const u64 1 - v1593 = get_elem_ptr v1589, __ptr u64, v1592 - v1594 = const u64 13 - store v1594 to v1593, !1322 - v1595 = get_local __ptr slice, __anon_33, !1322 - mem_copy_bytes v1595, v1589, 16 - v1596 = get_local __ptr slice, __tmp_arg31 - mem_copy_val v1596, v1586 - v1597 = get_local __ptr slice, __tmp_arg32 - mem_copy_val v1597, v1595 - v1598 = call eq_11(v1596, v1597) - cbr v1598, block48(), block49(), !1323 - - block48(): - v1599 = get_local __ptr { ptr }, _buffer, !1324 - v1600 = get_elem_ptr v1599, __ptr ptr, v19, !1329 - v1601 = load v1600, !1330 - v1602 = asm(ptr: v1601, val) -> u64 val, !1331 { - lw val ptr i0, !58 - } - v1603 = load v1600, !1330 - v1604 = const u64 8, !1330 - v1605 = add v1603, v1604, !1330 - store v1605 to v1600, !1332 - v1606 = get_local __ptr { u64 }, __anon_004, !1334 - v1607 = const u64 0 - v1608 = get_elem_ptr v1606, __ptr u64, v1607, !1335 - store v1602 to v1608, !1336 - v1609 = get_local __ptr { { u64 } }, __anon_025, !1337 - v1610 = const u64 0 - v1611 = get_elem_ptr v1609, __ptr { u64 }, v1610, !1338 - mem_copy_val v1611, v1606 - v1612 = get_local __ptr { { u64 } }, args________________, !1339 - mem_copy_val v1612, v1609 - v1613 = get_local __ptr { { u64 } }, args________________, !1340 - v1614 = const u64 0 - v1615 = get_elem_ptr v1613, __ptr { u64 }, v1614, !1341 - v1616 = get_local __ptr { u64 }, v_15, !1344 - mem_copy_val v1616, v1615 - v1617 = get_local __ptr { u64 }, v_15, !1346 - v1618 = get_local __ptr { u64 }, _result________________________________, !1347 - mem_copy_val v1618, v1617 - v1619 = get_local __ptr { u64 }, _result________________________________, !1348 - v1620 = get_local __ptr { u64 }, __tmp_arg130 - mem_copy_val v1620, v1619 - v1621 = get_local __ptr slice, __ret_val77 - v1622 = call encode_130(v1620, v1621) - v1623 = get_local __ptr slice, _result_________________________________, !1349 - mem_copy_val v1623, v1621 - v1624 = get_local __ptr slice, _result_________________________________, !1350 - v1625 = get_local __ptr slice, self_30, !1353 - mem_copy_val v1625, v1624 - v1626 = get_local __ptr slice, self_30, !1354 - v1627 = get_local __ptr slice, slice_21, !1355 - mem_copy_val v1627, v1626 - v1628 = get_local __ptr slice, slice_21, !1356 - v1629 = asm(ptr: v1628) -> __ptr { ptr, u64 } ptr { - } - v1630 = get_local __ptr { ptr, u64 }, __aggr_memcpy_042 - mem_copy_val v1630, v1629 - v1631 = get_local __ptr { ptr, u64 }, __anon_064, !1353 - mem_copy_val v1631, v1630 - v1632 = get_elem_ptr v1631, __ptr ptr, v37, !1357 - v1633 = load v1632, !1353 - v1634 = get_local __ptr slice, _result_________________________________, !1358 - v1635 = get_local __ptr slice, __tmp_arg116 - mem_copy_val v1635, v1634 - v1636 = call len_30(v1635) - retd v1633 v1636, !1359 - - block49(): - v1637 = get_local __ptr slice, _method_name, !1360 - v1638 = get_global __ptr string<17>, __const_global16 - v1639 = cast_ptr v1638 to ptr, !1361 - v1640 = get_local __ptr { ptr, u64 }, __anon_34, !1361 - v1641 = const u64 0 - v1642 = get_elem_ptr v1640, __ptr ptr, v1641 - store v1639 to v1642, !1361 - v1643 = const u64 1 - v1644 = get_elem_ptr v1640, __ptr u64, v1643 - v1645 = const u64 17 - store v1645 to v1644, !1361 - v1646 = get_local __ptr slice, __anon_35, !1361 - mem_copy_bytes v1646, v1640, 16 - v1647 = get_local __ptr slice, __tmp_arg33 - mem_copy_val v1647, v1637 - v1648 = get_local __ptr slice, __tmp_arg34 - mem_copy_val v1648, v1646 - v1649 = call eq_11(v1647, v1648) - cbr v1649, block51(), block52(), !1362 - - block51(): - v1650 = get_local __ptr { ptr }, _buffer, !1363 - v1651 = get_elem_ptr v1650, __ptr ptr, v19, !1368 - v1652 = load v1651, !1369 - v1653 = asm(ptr: v1652, val) -> u64 val, !1370 { - lw val ptr i0, !58 - } - v1654 = load v1651, !1369 - v1655 = const u64 8, !1369 - v1656 = add v1654, v1655, !1369 - store v1656 to v1651, !1371 - v1657 = load v1651, !1374 - v1658 = asm(ptr: v1657, val) -> u64 val, !1375 { - lw val ptr i0, !58 - } - v1659 = load v1651, !1374 - v1660 = const u64 8, !1374 - v1661 = add v1659, v1660, !1374 - store v1661 to v1651, !1376 - v1662 = get_local __ptr { u64, u64 }, __anon_005, !1378 - v1663 = const u64 0 - v1664 = get_elem_ptr v1662, __ptr u64, v1663, !1379 - store v1653 to v1664, !1380 - v1665 = const u64 1 - v1666 = get_elem_ptr v1662, __ptr u64, v1665, !1381 - store v1658 to v1666, !1382 - v1667 = get_local __ptr { { u64, u64 } }, __anon_026, !1383 - v1668 = const u64 0 - v1669 = get_elem_ptr v1667, __ptr { u64, u64 }, v1668, !1384 - mem_copy_val v1669, v1662 - v1670 = get_local __ptr { { u64, u64 } }, args_________________, !1385 - mem_copy_val v1670, v1667 - v1671 = get_local __ptr { { u64, u64 } }, args_________________, !1386 - v1672 = const u64 0 - v1673 = get_elem_ptr v1671, __ptr { u64, u64 }, v1672, !1387 - v1674 = get_local __ptr { u64, u64 }, v_16, !1390 - mem_copy_val v1674, v1673 - v1675 = get_local __ptr { u64, u64 }, v_16, !1392 - v1676 = get_local __ptr { u64, u64 }, _result__________________________________, !1393 - mem_copy_val v1676, v1675 - v1677 = get_local __ptr { u64, u64 }, _result__________________________________, !1394 - v1678 = get_local __ptr { u64, u64 }, __tmp_arg134 - mem_copy_val v1678, v1677 - v1679 = get_local __ptr slice, __ret_val81 - v1680 = call encode_158(v1678, v1679) - v1681 = get_local __ptr slice, _result___________________________________, !1395 - mem_copy_val v1681, v1679 - v1682 = get_local __ptr slice, _result___________________________________, !1396 - v1683 = get_local __ptr slice, self_31, !1399 - mem_copy_val v1683, v1682 - v1684 = get_local __ptr slice, self_31, !1400 - v1685 = get_local __ptr slice, slice_22, !1401 - mem_copy_val v1685, v1684 - v1686 = get_local __ptr slice, slice_22, !1402 - v1687 = asm(ptr: v1686) -> __ptr { ptr, u64 } ptr { - } - v1688 = get_local __ptr { ptr, u64 }, __aggr_memcpy_043 - mem_copy_val v1688, v1687 - v1689 = get_local __ptr { ptr, u64 }, __anon_065, !1399 - mem_copy_val v1689, v1688 - v1690 = get_elem_ptr v1689, __ptr ptr, v37, !1403 - v1691 = load v1690, !1399 - v1692 = get_local __ptr slice, _result___________________________________, !1404 - v1693 = get_local __ptr slice, __tmp_arg117 - mem_copy_val v1693, v1692 - v1694 = call len_30(v1693) - retd v1691 v1694, !1405 - - block52(): - v1695 = get_local __ptr slice, _method_name, !1406 - v1696 = get_global __ptr string<21>, __const_global17 - v1697 = cast_ptr v1696 to ptr, !1407 - v1698 = get_local __ptr { ptr, u64 }, __anon_36, !1407 - v1699 = const u64 0 - v1700 = get_elem_ptr v1698, __ptr ptr, v1699 - store v1697 to v1700, !1407 - v1701 = const u64 1 - v1702 = get_elem_ptr v1698, __ptr u64, v1701 - v1703 = const u64 21 - store v1703 to v1702, !1407 - v1704 = get_local __ptr slice, __anon_37, !1407 - mem_copy_bytes v1704, v1698, 16 - v1705 = get_local __ptr slice, __tmp_arg35 - mem_copy_val v1705, v1695 - v1706 = get_local __ptr slice, __tmp_arg36 - mem_copy_val v1706, v1704 - v1707 = call eq_11(v1705, v1706) - cbr v1707, block54(), block55(), !1408 - - block54(): - v1708 = get_local __ptr { ptr }, _buffer, !1409 - v1709 = get_elem_ptr v1708, __ptr ptr, v19, !1414 - v1710 = load v1709, !1415 - v1711 = asm(ptr: v1710, val) -> u64 val, !1416 { - lw val ptr i0, !58 - } - v1712 = load v1709, !1415 - v1713 = const u64 8, !1415 - v1714 = add v1712, v1713, !1415 - store v1714 to v1709, !1417 - v1715 = load v1709, !1420 - v1716 = asm(ptr: v1715, val) -> u64 val, !1421 { - lw val ptr i0, !58 - } - v1717 = load v1709, !1420 - v1718 = const u64 8, !1420 - v1719 = add v1717, v1718, !1420 - store v1719 to v1709, !1422 - v1720 = load v1709, !1425 - v1721 = asm(ptr: v1720, val) -> u64 val, !1426 { - lw val ptr i0, !58 - } - v1722 = load v1709, !1425 - v1723 = const u64 8, !1425 - v1724 = add v1722, v1723, !1425 - store v1724 to v1709, !1427 - v1725 = get_local __ptr { u64, u64, u64 }, __anon_006, !1429 - v1726 = const u64 0 - v1727 = get_elem_ptr v1725, __ptr u64, v1726, !1430 - store v1711 to v1727, !1431 - v1728 = const u64 1 - v1729 = get_elem_ptr v1725, __ptr u64, v1728, !1432 - store v1716 to v1729, !1433 - v1730 = const u64 2 - v1731 = get_elem_ptr v1725, __ptr u64, v1730, !1434 - store v1721 to v1731, !1435 - v1732 = get_local __ptr { { u64, u64, u64 } }, __anon_027, !1436 - v1733 = const u64 0 - v1734 = get_elem_ptr v1732, __ptr { u64, u64, u64 }, v1733, !1437 - mem_copy_val v1734, v1725 - v1735 = get_local __ptr { { u64, u64, u64 } }, args__________________, !1438 - mem_copy_val v1735, v1732 - v1736 = get_local __ptr { { u64, u64, u64 } }, args__________________, !1439 - v1737 = const u64 0 - v1738 = get_elem_ptr v1736, __ptr { u64, u64, u64 }, v1737, !1440 - v1739 = get_local __ptr { u64, u64, u64 }, v_17, !1443 - mem_copy_val v1739, v1738 - v1740 = get_local __ptr { u64, u64, u64 }, v_17, !1445 - v1741 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !1446 - mem_copy_val v1741, v1740 - v1742 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !1447 - v1743 = get_local __ptr { u64, u64, u64 }, __tmp_arg132 - mem_copy_val v1743, v1742 - v1744 = get_local __ptr slice, __ret_val79 - v1745 = call encode_142(v1743, v1744) - v1746 = get_local __ptr slice, _result_____________________________________, !1448 - mem_copy_val v1746, v1744 - v1747 = get_local __ptr slice, _result_____________________________________, !1449 - v1748 = get_local __ptr slice, self_32, !1452 - mem_copy_val v1748, v1747 - v1749 = get_local __ptr slice, self_32, !1453 - v1750 = get_local __ptr slice, slice_23, !1454 - mem_copy_val v1750, v1749 - v1751 = get_local __ptr slice, slice_23, !1455 - v1752 = asm(ptr: v1751) -> __ptr { ptr, u64 } ptr { - } - v1753 = get_local __ptr { ptr, u64 }, __aggr_memcpy_044 - mem_copy_val v1753, v1752 - v1754 = get_local __ptr { ptr, u64 }, __anon_066, !1452 - mem_copy_val v1754, v1753 - v1755 = get_elem_ptr v1754, __ptr ptr, v37, !1456 - v1756 = load v1755, !1452 - v1757 = get_local __ptr slice, _result_____________________________________, !1457 - v1758 = get_local __ptr slice, __tmp_arg118 - mem_copy_val v1758, v1757 - v1759 = call len_30(v1758) - retd v1756 v1759, !1458 - - block55(): - v1760 = get_local __ptr slice, _method_name, !1459 - v1761 = get_global __ptr string<10>, __const_global18 - v1762 = cast_ptr v1761 to ptr, !1460 - v1763 = get_local __ptr { ptr, u64 }, __anon_38, !1460 - v1764 = const u64 0 - v1765 = get_elem_ptr v1763, __ptr ptr, v1764 - store v1762 to v1765, !1460 - v1766 = const u64 1 - v1767 = get_elem_ptr v1763, __ptr u64, v1766 - v1768 = const u64 10 - store v1768 to v1767, !1460 - v1769 = get_local __ptr slice, __anon_39, !1460 - mem_copy_bytes v1769, v1763, 16 - v1770 = get_local __ptr slice, __tmp_arg37 - mem_copy_val v1770, v1760 - v1771 = get_local __ptr slice, __tmp_arg38 - mem_copy_val v1771, v1769 - v1772 = call eq_11(v1770, v1771) - cbr v1772, block57(), block58(), !1461 - - block57(): - v1773 = get_local __ptr { () }, __anon_028, !1464 - v1774 = const u64 0 - v1775 = get_elem_ptr v1773, __ptr (), v1774, !1465 - v1776 = const unit () - store v1776 to v1775, !1466 - v1777 = get_local __ptr { () }, args___________________, !1467 - mem_copy_val v1777, v1773 - v1778 = asm() -> ptr zero, !1468 { - } - v1779 = const u64 0, !1469 - retd v1778 v1779, !1470 - - block58(): - v1780 = get_local __ptr slice, _method_name, !1471 - v1781 = get_global __ptr string<10>, __const_global19 - v1782 = cast_ptr v1781 to ptr, !1472 - v1783 = get_local __ptr { ptr, u64 }, __anon_40, !1472 - v1784 = const u64 0 - v1785 = get_elem_ptr v1783, __ptr ptr, v1784 - store v1782 to v1785, !1472 - v1786 = const u64 1 - v1787 = get_elem_ptr v1783, __ptr u64, v1786 - v1788 = const u64 10 - store v1788 to v1787, !1472 - v1789 = get_local __ptr slice, __anon_41, !1472 - mem_copy_bytes v1789, v1783, 16 - v1790 = get_local __ptr slice, __tmp_arg39 - mem_copy_val v1790, v1780 - v1791 = get_local __ptr slice, __tmp_arg40 - mem_copy_val v1791, v1789 - v1792 = call eq_11(v1790, v1791) - cbr v1792, block60(), block61(), !1473 - - block60(): - v1793 = get_local __ptr { ptr }, _buffer, !1474 - v1794 = get_elem_ptr v1793, __ptr ptr, v19, !1477 - v1795 = load v1794, !1478 - v1796 = asm(ptr: v1795, val) -> u64 val, !1479 { - lw val ptr i0, !58 - } - v1797 = load v1794, !1478 - v1798 = const u64 8, !1478 - v1799 = add v1797, v1798, !1478 - store v1799 to v1794, !1480 - v1800 = get_local __ptr { u64 }, __anon_007, !1481 - v1801 = const u64 0 - v1802 = get_elem_ptr v1800, __ptr u64, v1801, !1482 - store v1796 to v1802, !1483 - v1803 = get_local __ptr { { u64 } }, __anon_029, !1484 - v1804 = const u64 0 - v1805 = get_elem_ptr v1803, __ptr { u64 }, v1804, !1485 - mem_copy_val v1805, v1800 - v1806 = get_local __ptr { { u64 } }, args____________________, !1486 - mem_copy_val v1806, v1803 - v1807 = get_local __ptr { { u64 } }, args____________________, !1487 - v1808 = const u64 0 - v1809 = get_elem_ptr v1807, __ptr { u64 }, v1808, !1488 - v1810 = get_local __ptr { u64 }, v_19, !1491 - mem_copy_val v1810, v1809 - v1811 = get_local __ptr { u64 }, v_19, !1492 - v1812 = get_local __ptr { u64 }, _result_______________________________________, !1493 - mem_copy_val v1812, v1811 - v1813 = get_local __ptr { u64 }, _result_______________________________________, !1494 - v1814 = get_local __ptr { u64 }, __tmp_arg131 - mem_copy_val v1814, v1813 - v1815 = get_local __ptr slice, __ret_val78 - v1816 = call encode_130(v1814, v1815) - v1817 = get_local __ptr slice, _result________________________________________, !1495 - mem_copy_val v1817, v1815 - v1818 = get_local __ptr slice, _result________________________________________, !1496 - v1819 = get_local __ptr slice, self_34, !1499 - mem_copy_val v1819, v1818 - v1820 = get_local __ptr slice, self_34, !1500 - v1821 = get_local __ptr slice, slice_24, !1501 - mem_copy_val v1821, v1820 - v1822 = get_local __ptr slice, slice_24, !1502 - v1823 = asm(ptr: v1822) -> __ptr { ptr, u64 } ptr { - } - v1824 = get_local __ptr { ptr, u64 }, __aggr_memcpy_045 - mem_copy_val v1824, v1823 - v1825 = get_local __ptr { ptr, u64 }, __anon_067, !1499 - mem_copy_val v1825, v1824 - v1826 = get_elem_ptr v1825, __ptr ptr, v37, !1503 - v1827 = load v1826, !1499 - v1828 = get_local __ptr slice, _result________________________________________, !1504 - v1829 = get_local __ptr slice, __tmp_arg119 - mem_copy_val v1829, v1828 - v1830 = call len_30(v1829) - retd v1827 v1830, !1505 - - block61(): - v1831 = get_local __ptr slice, _method_name, !1506 - v1832 = get_global __ptr string<10>, __const_global20 - v1833 = cast_ptr v1832 to ptr, !1507 - v1834 = get_local __ptr { ptr, u64 }, __anon_42, !1507 - v1835 = const u64 0 - v1836 = get_elem_ptr v1834, __ptr ptr, v1835 - store v1833 to v1836, !1507 - v1837 = const u64 1 - v1838 = get_elem_ptr v1834, __ptr u64, v1837 - v1839 = const u64 10 - store v1839 to v1838, !1507 - v1840 = get_local __ptr slice, __anon_43, !1507 - mem_copy_bytes v1840, v1834, 16 - v1841 = get_local __ptr slice, __tmp_arg41 - mem_copy_val v1841, v1831 - v1842 = get_local __ptr slice, __tmp_arg42 - mem_copy_val v1842, v1840 - v1843 = call eq_11(v1841, v1842) - cbr v1843, block63(), block64(), !1508 - - block63(): - v1844 = get_local __ptr { ptr }, _buffer, !1509 - v1845 = get_elem_ptr v1844, __ptr ptr, v19, !1514 - v1846 = load v1845, !1515 - v1847 = asm(ptr: v1846, val) -> u64 val, !1516 { - lw val ptr i0, !58 - } - v1848 = load v1845, !1515 - v1849 = const u64 8, !1515 - v1850 = add v1848, v1849, !1515 - store v1850 to v1845, !1517 - v1851 = load v1845, !1520 - v1852 = asm(ptr: v1851, val) -> u64 val, !1521 { - lw val ptr i0, !58 - } - v1853 = load v1845, !1520 - v1854 = const u64 8, !1520 - v1855 = add v1853, v1854, !1520 - store v1855 to v1845, !1522 - v1856 = get_local __ptr { u64, u64 }, __anon_008, !1524 - v1857 = const u64 0 - v1858 = get_elem_ptr v1856, __ptr u64, v1857, !1525 - store v1847 to v1858, !1526 - v1859 = const u64 1 - v1860 = get_elem_ptr v1856, __ptr u64, v1859, !1527 - store v1852 to v1860, !1528 - v1861 = get_local __ptr { { u64, u64 } }, __anon_030, !1529 - v1862 = const u64 0 - v1863 = get_elem_ptr v1861, __ptr { u64, u64 }, v1862, !1530 - mem_copy_val v1863, v1856 - v1864 = get_local __ptr { { u64, u64 } }, args_____________________, !1531 - mem_copy_val v1864, v1861 - v1865 = get_local __ptr { { u64, u64 } }, args_____________________, !1532 - v1866 = const u64 0 - v1867 = get_elem_ptr v1865, __ptr { u64, u64 }, v1866, !1533 - v1868 = get_local __ptr { u64, u64 }, v_20, !1536 - mem_copy_val v1868, v1867 - v1869 = get_local __ptr { u64, u64 }, v_20, !1537 - v1870 = get_local __ptr { u64, u64 }, _result_________________________________________, !1538 - mem_copy_val v1870, v1869 - v1871 = get_local __ptr { u64, u64 }, _result_________________________________________, !1539 - v1872 = get_local __ptr { u64, u64 }, __tmp_arg135 - mem_copy_val v1872, v1871 - v1873 = get_local __ptr slice, __ret_val82 - v1874 = call encode_158(v1872, v1873) - v1875 = get_local __ptr slice, _result__________________________________________, !1540 - mem_copy_val v1875, v1873 - v1876 = get_local __ptr slice, _result__________________________________________, !1541 - v1877 = get_local __ptr slice, self_36, !1544 - mem_copy_val v1877, v1876 - v1878 = get_local __ptr slice, self_36, !1545 - v1879 = get_local __ptr slice, slice_25, !1546 - mem_copy_val v1879, v1878 - v1880 = get_local __ptr slice, slice_25, !1547 - v1881 = asm(ptr: v1880) -> __ptr { ptr, u64 } ptr { - } - v1882 = get_local __ptr { ptr, u64 }, __aggr_memcpy_046 - mem_copy_val v1882, v1881 - v1883 = get_local __ptr { ptr, u64 }, __anon_068, !1544 - mem_copy_val v1883, v1882 - v1884 = get_elem_ptr v1883, __ptr ptr, v37, !1548 - v1885 = load v1884, !1544 - v1886 = get_local __ptr slice, _result__________________________________________, !1549 - v1887 = get_local __ptr slice, __tmp_arg120 - mem_copy_val v1887, v1886 - v1888 = call len_30(v1887) - retd v1885 v1888, !1550 - - block64(): - v1889 = get_local __ptr slice, _method_name, !1551 - v1890 = get_global __ptr string<10>, __const_global21 - v1891 = cast_ptr v1890 to ptr, !1552 - v1892 = get_local __ptr { ptr, u64 }, __anon_44, !1552 - v1893 = const u64 0 - v1894 = get_elem_ptr v1892, __ptr ptr, v1893 - store v1891 to v1894, !1552 - v1895 = const u64 1 - v1896 = get_elem_ptr v1892, __ptr u64, v1895 - v1897 = const u64 10 - store v1897 to v1896, !1552 - v1898 = get_local __ptr slice, __anon_45, !1552 - mem_copy_bytes v1898, v1892, 16 - v1899 = get_local __ptr slice, __tmp_arg43 - mem_copy_val v1899, v1889 - v1900 = get_local __ptr slice, __tmp_arg44 - mem_copy_val v1900, v1898 - v1901 = call eq_11(v1899, v1900) - cbr v1901, block66(), block67(), !1553 - - block66(): - v1902 = get_local __ptr { ptr }, _buffer, !1554 - v1903 = get_elem_ptr v1902, __ptr ptr, v19, !1559 - v1904 = load v1903, !1560 - v1905 = asm(ptr: v1904, val) -> u64 val, !1561 { - lw val ptr i0, !58 - } - v1906 = load v1903, !1560 - v1907 = const u64 8, !1560 - v1908 = add v1906, v1907, !1560 - store v1908 to v1903, !1562 - v1909 = load v1903, !1565 - v1910 = asm(ptr: v1909, val) -> u64 val, !1566 { - lw val ptr i0, !58 - } - v1911 = load v1903, !1565 - v1912 = const u64 8, !1565 - v1913 = add v1911, v1912, !1565 - store v1913 to v1903, !1567 - v1914 = load v1903, !1570 - v1915 = asm(ptr: v1914, val) -> u64 val, !1571 { - lw val ptr i0, !58 - } - v1916 = load v1903, !1570 - v1917 = const u64 8, !1570 - v1918 = add v1916, v1917, !1570 - store v1918 to v1903, !1572 - v1919 = get_local __ptr { u64, u64, u64 }, __anon_009, !1574 - v1920 = const u64 0 - v1921 = get_elem_ptr v1919, __ptr u64, v1920, !1575 - store v1905 to v1921, !1576 - v1922 = const u64 1 - v1923 = get_elem_ptr v1919, __ptr u64, v1922, !1577 - store v1910 to v1923, !1578 - v1924 = const u64 2 - v1925 = get_elem_ptr v1919, __ptr u64, v1924, !1579 - store v1915 to v1925, !1580 - v1926 = get_local __ptr { { u64, u64, u64 } }, __anon_031, !1581 - v1927 = const u64 0 - v1928 = get_elem_ptr v1926, __ptr { u64, u64, u64 }, v1927, !1582 - mem_copy_val v1928, v1919 - v1929 = get_local __ptr { { u64, u64, u64 } }, args______________________, !1583 - mem_copy_val v1929, v1926 - v1930 = get_local __ptr { { u64, u64, u64 } }, args______________________, !1584 - v1931 = const u64 0 - v1932 = get_elem_ptr v1930, __ptr { u64, u64, u64 }, v1931, !1585 - v1933 = get_local __ptr { u64, u64, u64 }, v_21, !1588 - mem_copy_val v1933, v1932 - v1934 = get_local __ptr { u64, u64, u64 }, v_21, !1589 - v1935 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !1590 - mem_copy_val v1935, v1934 - v1936 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !1591 - v1937 = get_local __ptr { u64, u64, u64 }, __tmp_arg133 - mem_copy_val v1937, v1936 - v1938 = get_local __ptr slice, __ret_val80 - v1939 = call encode_142(v1937, v1938) - v1940 = get_local __ptr slice, _result____________________________________________, !1592 - mem_copy_val v1940, v1938 - v1941 = get_local __ptr slice, _result____________________________________________, !1593 - v1942 = get_local __ptr slice, self_38, !1596 - mem_copy_val v1942, v1941 - v1943 = get_local __ptr slice, self_38, !1597 - v1944 = get_local __ptr slice, slice_26, !1598 - mem_copy_val v1944, v1943 - v1945 = get_local __ptr slice, slice_26, !1599 - v1946 = asm(ptr: v1945) -> __ptr { ptr, u64 } ptr { - } - v1947 = get_local __ptr { ptr, u64 }, __aggr_memcpy_047 - mem_copy_val v1947, v1946 - v1948 = get_local __ptr { ptr, u64 }, __anon_069, !1596 - mem_copy_val v1948, v1947 - v1949 = get_elem_ptr v1948, __ptr ptr, v37, !1600 - v1950 = load v1949, !1596 - v1951 = get_local __ptr slice, _result____________________________________________, !1601 - v1952 = get_local __ptr slice, __tmp_arg121 - mem_copy_val v1952, v1951 - v1953 = call len_30(v1952) - retd v1950 v1953, !1602 - - block67(): - v1954 = get_local __ptr slice, _method_name, !1603 - v1955 = get_global __ptr string<10>, __const_global22 - v1956 = cast_ptr v1955 to ptr, !1604 - v1957 = get_local __ptr { ptr, u64 }, __anon_46, !1604 - v1958 = const u64 0 - v1959 = get_elem_ptr v1957, __ptr ptr, v1958 - store v1956 to v1959, !1604 - v1960 = const u64 1 - v1961 = get_elem_ptr v1957, __ptr u64, v1960 - v1962 = const u64 10 - store v1962 to v1961, !1604 - v1963 = get_local __ptr slice, __anon_47, !1604 - mem_copy_bytes v1963, v1957, 16 - v1964 = get_local __ptr slice, __tmp_arg45 - mem_copy_val v1964, v1954 - v1965 = get_local __ptr slice, __tmp_arg46 - mem_copy_val v1965, v1963 - v1966 = call eq_11(v1964, v1965) - cbr v1966, block69(), block70(), !1605 - - block69(): - v1967 = get_local __ptr { ptr }, _buffer, !1606 - v1968 = get_elem_ptr v1967, __ptr ptr, v19, !1611 - v1969 = load v1968, !1612 - v1970 = asm(ptr: v1969, val) -> u64 val, !1613 { - lw val ptr i0, !58 - } - v1971 = load v1968, !1612 - v1972 = const u64 8, !1612 - v1973 = add v1971, v1972, !1612 - store v1973 to v1968, !1614 - v1974 = load v1968, !1617 - v1975 = asm(ptr: v1974, val) -> u64 val, !1618 { - lw val ptr i0, !58 - } - v1976 = load v1968, !1617 - v1977 = const u64 8, !1617 - v1978 = add v1976, v1977, !1617 - store v1978 to v1968, !1619 - v1979 = load v1968, !1622 - v1980 = asm(ptr: v1979, val) -> u64 val, !1623 { - lw val ptr i0, !58 - } - v1981 = load v1968, !1622 - v1982 = const u64 8, !1622 - v1983 = add v1981, v1982, !1622 - store v1983 to v1968, !1624 - v1984 = load v1968, !1627 - v1985 = asm(ptr: v1984, val) -> u64 val, !1628 { - lw val ptr i0, !58 - } - v1986 = load v1968, !1627 - v1987 = const u64 8, !1627 - v1988 = add v1986, v1987, !1627 - store v1988 to v1968, !1629 - v1989 = get_local __ptr { u64, u64, u64, u64 }, __anon_0010, !1631 - v1990 = const u64 0 - v1991 = get_elem_ptr v1989, __ptr u64, v1990, !1632 - store v1970 to v1991, !1633 - v1992 = const u64 1 - v1993 = get_elem_ptr v1989, __ptr u64, v1992, !1634 - store v1975 to v1993, !1635 - v1994 = const u64 2 - v1995 = get_elem_ptr v1989, __ptr u64, v1994, !1636 - store v1980 to v1995, !1637 - v1996 = const u64 3 - v1997 = get_elem_ptr v1989, __ptr u64, v1996, !1638 - store v1985 to v1997, !1639 - v1998 = get_local __ptr { { u64, u64, u64, u64 } }, __anon_032, !1640 - v1999 = const u64 0 - v2000 = get_elem_ptr v1998, __ptr { u64, u64, u64, u64 }, v1999, !1641 - mem_copy_val v2000, v1989 - v2001 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !1642 - mem_copy_val v2001, v1998 - v2002 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !1643 - v2003 = const u64 0 - v2004 = get_elem_ptr v2002, __ptr { u64, u64, u64, u64 }, v2003, !1644 - v2005 = get_local __ptr { u64, u64, u64, u64 }, v_22, !1647 - mem_copy_val v2005, v2004 - v2006 = get_local __ptr { u64, u64, u64, u64 }, v_22, !1649 - v2007 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !1650 - mem_copy_val v2007, v2006 - v2008 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !1651 - v2009 = get_local __ptr { u64, u64, u64, u64 }, item_14, !1654 - mem_copy_val v2009, v2008 - v2010 = get_local __ptr { u64, u64, u64, u64 }, item_14, !1655 - v2011 = get_local __ptr { { ptr, u64, u64 } }, __ret_val43 - v2012 = call new_21(v2011) - v2013 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1656 - mem_copy_val v2013, v2010 - v2014 = get_local __ptr { { ptr, u64, u64 } }, buffer_44, !1657 - mem_copy_val v2014, v2011 - v2015 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1659 - v2016 = const u64 0 - v2017 = get_elem_ptr v2015, __ptr u64, v2016, !1661 - v2018 = load v2017, !1662 - v2019 = get_local __ptr { { ptr, u64, u64 } }, buffer_44, !1664 - v2020 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg74 - mem_copy_val v2020, v2019 - v2021 = get_local __ptr { { ptr, u64, u64 } }, __ret_val23 - v2022 = call abi_encode_20(v2018, v2020, v2021) - v2023 = get_local __ptr { { ptr, u64, u64 } }, buffer__7, !1666 - mem_copy_val v2023, v2021 - v2024 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1668 - v2025 = const u64 1 - v2026 = get_elem_ptr v2024, __ptr u64, v2025, !1670 - v2027 = load v2026, !1671 - v2028 = get_local __ptr { { ptr, u64, u64 } }, buffer__7, !1673 - v2029 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg75 - mem_copy_val v2029, v2028 - v2030 = get_local __ptr { { ptr, u64, u64 } }, __ret_val24 - v2031 = call abi_encode_20(v2027, v2029, v2030) - v2032 = get_local __ptr { { ptr, u64, u64 } }, buffer___2, !1675 - mem_copy_val v2032, v2030 - v2033 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1677 - v2034 = const u64 2 - v2035 = get_elem_ptr v2033, __ptr u64, v2034, !1679 - v2036 = load v2035, !1680 - v2037 = get_local __ptr { { ptr, u64, u64 } }, buffer___2, !1682 - v2038 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg76 - mem_copy_val v2038, v2037 - v2039 = get_local __ptr { { ptr, u64, u64 } }, __ret_val25 - v2040 = call abi_encode_20(v2036, v2038, v2039) - v2041 = get_local __ptr { { ptr, u64, u64 } }, buffer____2, !1684 - mem_copy_val v2041, v2039 - v2042 = get_local __ptr { u64, u64, u64, u64 }, self_52, !1686 - v2043 = const u64 3 - v2044 = get_elem_ptr v2042, __ptr u64, v2043, !1688 - v2045 = load v2044, !1689 - v2046 = get_local __ptr { { ptr, u64, u64 } }, buffer____2, !1691 - v2047 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg77 - mem_copy_val v2047, v2046 - v2048 = get_local __ptr { { ptr, u64, u64 } }, __ret_val26 - v2049 = call abi_encode_20(v2045, v2047, v2048) - v2050 = get_local __ptr { { ptr, u64, u64 } }, buffer_____1, !1693 - mem_copy_val v2050, v2048 - v2051 = get_local __ptr { { ptr, u64, u64 } }, buffer_____1, !1695 - v2052 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !1696 - mem_copy_val v2052, v2051 - v2053 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !1697 - v2054 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg94 - mem_copy_val v2054, v2053 - v2055 = get_local __ptr slice, __ret_val64 - v2056 = call as_raw_slice_22(v2054, v2055) - v2057 = get_local __ptr slice, _result______________________________________________, !1698 - mem_copy_val v2057, v2055 - v2058 = get_local __ptr slice, _result______________________________________________, !1699 - v2059 = get_local __ptr slice, self_40, !1702 - mem_copy_val v2059, v2058 - v2060 = get_local __ptr slice, self_40, !1703 - v2061 = get_local __ptr slice, slice_27, !1704 - mem_copy_val v2061, v2060 - v2062 = get_local __ptr slice, slice_27, !1705 - v2063 = asm(ptr: v2062) -> __ptr { ptr, u64 } ptr { - } - v2064 = get_local __ptr { ptr, u64 }, __aggr_memcpy_048 - mem_copy_val v2064, v2063 - v2065 = get_local __ptr { ptr, u64 }, __anon_070, !1702 - mem_copy_val v2065, v2064 - v2066 = get_elem_ptr v2065, __ptr ptr, v37, !1706 - v2067 = load v2066, !1702 - v2068 = get_local __ptr slice, _result______________________________________________, !1707 - v2069 = get_local __ptr slice, __tmp_arg122 - mem_copy_val v2069, v2068 - v2070 = call len_30(v2069) - retd v2067 v2070, !1708 - - block70(): - v2071 = get_local __ptr slice, _method_name, !1709 - v2072 = get_global __ptr string<6>, __const_global23 - v2073 = cast_ptr v2072 to ptr, !1710 - v2074 = get_local __ptr { ptr, u64 }, __anon_48, !1710 - v2075 = const u64 0 - v2076 = get_elem_ptr v2074, __ptr ptr, v2075 - store v2073 to v2076, !1710 - v2077 = const u64 1 - v2078 = get_elem_ptr v2074, __ptr u64, v2077 - v2079 = const u64 6 - store v2079 to v2078, !1710 - v2080 = get_local __ptr slice, __anon_49, !1710 - mem_copy_bytes v2080, v2074, 16 - v2081 = get_local __ptr slice, __tmp_arg47 - mem_copy_val v2081, v2071 - v2082 = get_local __ptr slice, __tmp_arg48 - mem_copy_val v2082, v2080 - v2083 = call eq_11(v2081, v2082) - cbr v2083, block72(), block73(), !1711 - - block72(): - v2084 = get_local __ptr { ptr }, _buffer, !1712 - v2085 = call read_72(v2084), !1717 - v2086 = asm(input: v2085) -> u64 input, !1721 { - } - v2087 = call read_72(v2084), !1724 - v2088 = asm(input: v2087) -> u64 input, !1727 { - } - v2089 = const u64 8, !1728 - v2090 = lsh v2086, v2089, !1731 - v2091 = const u64 65535, !1733 - v2092 = and v2090, v2091, !1734 - v2093 = or v2092, v2088, !1737 - v2094 = get_local __ptr { u64 }, __anon_033, !1738 - v2095 = const u64 0 - v2096 = get_elem_ptr v2094, __ptr u64, v2095, !1739 - store v2093 to v2096, !1740 - v2097 = get_local __ptr { u64 }, args________________________, !1741 - mem_copy_val v2097, v2094 - v2098 = get_local __ptr { u64 }, args________________________, !1742 - v2099 = const u64 0 - v2100 = get_elem_ptr v2098, __ptr u64, v2099, !1743 - v2101 = get_local __ptr { { ptr, u64, u64 } }, __ret_val44 - v2102 = call new_21(v2101) - v2103 = get_local __ptr { { ptr, u64, u64 } }, buffer_46, !1746 - mem_copy_val v2103, v2101 - v2104 = get_local __ptr { { ptr, u64, u64 } }, buffer_46, !1748 - v2105 = const u64 0 - v2106 = get_elem_ptr v2104, __ptr { ptr, u64, u64 }, v2105, !1749 - v2107 = asm(buffer: v2106) -> __ptr { ptr, u64, u64 } buffer { - } - v2108 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_049 - mem_copy_val v2108, v2107 - v2109 = get_local __ptr { ptr, u64, u64 }, __anon_034, !1750 - mem_copy_val v2109, v2108 - v2110 = const u64 0 - v2111 = get_elem_ptr v2109, __ptr ptr, v2110, !1751 - v2112 = load v2111, !1752 - v2113 = const u64 1 - v2114 = get_elem_ptr v2109, __ptr u64, v2113, !1753 - v2115 = load v2114, !1754 - v2116 = const u64 2 - v2117 = get_elem_ptr v2109, __ptr u64, v2116, !1755 - v2118 = load v2117, !1756 - v2119 = const u64 2 - v2120 = add v2118, v2119, !1757 - v2121 = cmp gt v2120 v2115, !1758 - cbr v2121, encode_180_abi_encode_181_block1(), encode_180_abi_encode_181_block0(v2112, v2115), !1759 - - encode_180_abi_encode_181_block0(v2122: ptr, v2123: u64): - v2124 = get_local __ptr u64, __anon_119, !1760 - mem_copy_val v2124, v2100 - v2125 = const u64 6 - v2126 = add v2124, v2125, !1761 - v2127 = cast_ptr v2126 to __ptr u8, !1762 - v2128 = add v2122, v2118, !1763 - v2129 = cast_ptr v2128 to __ptr u8, !1764 - mem_copy_bytes v2129, v2127, 2, !1765 - v2130 = get_local __ptr { ptr, u64, u64 }, __anon_218, !1766 - v2131 = const u64 0 - v2132 = get_elem_ptr v2130, __ptr ptr, v2131, !1767 - store v2122 to v2132, !1768 - v2133 = const u64 1 - v2134 = get_elem_ptr v2130, __ptr u64, v2133, !1769 - store v2123 to v2134, !1770 - v2135 = const u64 2 - v2136 = get_elem_ptr v2130, __ptr u64, v2135, !1771 - store v2120 to v2136, !1772 - v2137 = asm(buffer: v2130) -> __ptr { ptr, u64, u64 } buffer { - } - v2138 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_050 - mem_copy_val v2138, v2137 - v2139 = get_local __ptr { { ptr, u64, u64 } }, __anon_316, !1774 - v2140 = const u64 0 - v2141 = get_elem_ptr v2139, __ptr { ptr, u64, u64 }, v2140, !1775 - mem_copy_val v2141, v2138 - v2142 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !1776 - mem_copy_val v2142, v2139 - v2143 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !1777 - v2144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg95 - mem_copy_val v2144, v2143 - v2145 = get_local __ptr slice, __ret_val65 - v2146 = call as_raw_slice_22(v2144, v2145) - v2147 = get_local __ptr slice, _result________________________________________________, !1778 - mem_copy_val v2147, v2145 - v2148 = get_local __ptr slice, _result________________________________________________, !1779 - v2149 = get_local __ptr slice, self_41, !1782 - mem_copy_val v2149, v2148 - v2150 = get_local __ptr slice, self_41, !1783 - v2151 = get_local __ptr slice, slice_28, !1784 - mem_copy_val v2151, v2150 - v2152 = get_local __ptr slice, slice_28, !1785 - v2153 = asm(ptr: v2152) -> __ptr { ptr, u64 } ptr { - } - v2154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_051 - mem_copy_val v2154, v2153 - v2155 = get_local __ptr { ptr, u64 }, __anon_071, !1782 - mem_copy_val v2155, v2154 - v2156 = get_elem_ptr v2155, __ptr ptr, v37, !1786 - v2157 = load v2156, !1782 - v2158 = get_local __ptr slice, _result________________________________________________, !1787 - v2159 = get_local __ptr slice, __tmp_arg123 - mem_copy_val v2159, v2158 - v2160 = call len_30(v2159) - retd v2157 v2160, !1788 - - encode_180_abi_encode_181_block1(): - v2161 = const u64 2 - v2162 = mul v2115, v2161, !1789 - v2163 = add v2162, v2119, !1790 - v2164 = asm(new_cap: v2163, old_ptr: v2112, len: v2118) -> __ptr u8 hp, !1791 { - aloc new_cap - mcp hp old_ptr len - } - br encode_180_abi_encode_181_block0(v2164, v2163), !1792 - - block73(): - v2165 = get_local __ptr slice, _method_name, !1793 - v2166 = get_global __ptr string<7>, __const_global24 - v2167 = cast_ptr v2166 to ptr, !1794 - v2168 = get_local __ptr { ptr, u64 }, __anon_50, !1794 - v2169 = const u64 0 - v2170 = get_elem_ptr v2168, __ptr ptr, v2169 - store v2167 to v2170, !1794 - v2171 = const u64 1 - v2172 = get_elem_ptr v2168, __ptr u64, v2171 - v2173 = const u64 7 - store v2173 to v2172, !1794 - v2174 = get_local __ptr slice, __anon_51, !1794 - mem_copy_bytes v2174, v2168, 16 - v2175 = get_local __ptr slice, __tmp_arg49 - mem_copy_val v2175, v2165 - v2176 = get_local __ptr slice, __tmp_arg50 - mem_copy_val v2176, v2174 - v2177 = call eq_11(v2175, v2176) - cbr v2177, block75(), block76(), !1795 - - block75(): - v2178 = get_local __ptr { ptr }, _buffer, !1796 - v2179 = const u64 0 - v2180 = get_elem_ptr v2178, __ptr ptr, v2179, !1801 - v2181 = load v2180, !1802 - v2182 = asm(ptr: v2181) -> __ptr u256 ptr { - } - v2183 = get_local __ptr u256, __aggr_memcpy_052 - mem_copy_val v2183, v2182 - v2184 = get_local __ptr u256, v0, !1803 - mem_copy_val v2184, v2183 - v2185 = load v2180, !1804 - v2186 = const u64 32, !1805 - v2187 = add v2185, v2186, !1806 - store v2187 to v2180, !1807 - v2188 = get_local __ptr u256, v0, !1808 - v2189 = get_local __ptr { u256 }, __anon_035, !1809 - v2190 = const u64 0 - v2191 = get_elem_ptr v2189, __ptr u256, v2190, !1810 - mem_copy_val v2191, v2188 - v2192 = get_local __ptr { u256 }, args_________________________, !1811 - mem_copy_val v2192, v2189 - v2193 = get_local __ptr { u256 }, args_________________________, !1812 - v2194 = const u64 0 - v2195 = get_elem_ptr v2193, __ptr u256, v2194, !1813 - v2196 = get_local __ptr u256, v_24, !1816 - mem_copy_val v2196, v2195 - v2197 = get_local __ptr u256, v_24, !1818 - v2198 = get_local __ptr u256, _result_________________________________________________, !1819 - mem_copy_val v2198, v2197 - v2199 = get_local __ptr u256, _result_________________________________________________, !1820 - v2200 = get_local __ptr u256, item_16, !1823 - mem_copy_val v2200, v2199 - v2201 = get_local __ptr u256, item_16, !1824 - v2202 = get_local __ptr { { ptr, u64, u64 } }, __ret_val45 - v2203 = call new_21(v2202) - v2204 = get_local __ptr u256, self_56, !1825 - mem_copy_val v2204, v2201 - v2205 = get_local __ptr { { ptr, u64, u64 } }, buffer_48, !1826 - mem_copy_val v2205, v2202 - v2206 = get_local __ptr { { ptr, u64, u64 } }, buffer_48, !1828 - v2207 = const u64 0 - v2208 = get_elem_ptr v2206, __ptr { ptr, u64, u64 }, v2207, !1829 - v2209 = asm(buffer: v2208) -> __ptr { ptr, u64, u64 } buffer { - } - v2210 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_053 - mem_copy_val v2210, v2209 - v2211 = get_local __ptr { ptr, u64, u64 }, __anon_036, !1830 - mem_copy_val v2211, v2210 - v2212 = const u64 0 - v2213 = get_elem_ptr v2211, __ptr ptr, v2212, !1831 - v2214 = load v2213, !1832 - v2215 = const u64 1 - v2216 = get_elem_ptr v2211, __ptr u64, v2215, !1833 - v2217 = load v2216, !1834 - v2218 = const u64 2 - v2219 = get_elem_ptr v2211, __ptr u64, v2218, !1835 - v2220 = load v2219, !1836 - v2221 = get_local __ptr u256, self_56, !1838 - v2222 = const u64 32 - v2223 = add v2220, v2222, !1839 - v2224 = cmp gt v2223 v2217, !1840 - cbr v2224, encode_187_abi_encode_188_block1(), encode_187_abi_encode_188_block0(v2214, v2217), !1841 - - encode_187_abi_encode_188_block0(v2225: ptr, v2226: u64): - v2227 = get_local __ptr u256, __anon_120, !1842 - mem_copy_val v2227, v2221 - v2228 = add v2225, v2220, !1843 - v2229 = cast_ptr v2228 to __ptr u8, !1844 - mem_copy_bytes v2229, v2227, 32, !1845 - v2230 = get_local __ptr { ptr, u64, u64 }, __anon_219, !1846 - v2231 = const u64 0 - v2232 = get_elem_ptr v2230, __ptr ptr, v2231, !1847 - store v2225 to v2232, !1848 - v2233 = const u64 1 - v2234 = get_elem_ptr v2230, __ptr u64, v2233, !1849 - store v2226 to v2234, !1850 - v2235 = const u64 2 - v2236 = get_elem_ptr v2230, __ptr u64, v2235, !1851 - store v2223 to v2236, !1852 - v2237 = asm(buffer: v2230) -> __ptr { ptr, u64, u64 } buffer { - } - v2238 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_054 - mem_copy_val v2238, v2237 - v2239 = get_local __ptr { { ptr, u64, u64 } }, __anon_317, !1854 - v2240 = const u64 0 - v2241 = get_elem_ptr v2239, __ptr { ptr, u64, u64 }, v2240, !1855 - mem_copy_val v2241, v2238 - v2242 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !1856 - mem_copy_val v2242, v2239 - v2243 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !1857 - v2244 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg96 - mem_copy_val v2244, v2243 - v2245 = get_local __ptr slice, __ret_val66 - v2246 = call as_raw_slice_22(v2244, v2245) - v2247 = get_local __ptr slice, _result__________________________________________________, !1858 - mem_copy_val v2247, v2245 - v2248 = get_local __ptr slice, _result__________________________________________________, !1859 - v2249 = get_local __ptr slice, self_43, !1862 - mem_copy_val v2249, v2248 - v2250 = get_local __ptr slice, self_43, !1863 - v2251 = get_local __ptr slice, slice_29, !1864 - mem_copy_val v2251, v2250 - v2252 = get_local __ptr slice, slice_29, !1865 - v2253 = asm(ptr: v2252) -> __ptr { ptr, u64 } ptr { - } - v2254 = get_local __ptr { ptr, u64 }, __aggr_memcpy_055 - mem_copy_val v2254, v2253 - v2255 = get_local __ptr { ptr, u64 }, __anon_072, !1862 - mem_copy_val v2255, v2254 - v2256 = get_elem_ptr v2255, __ptr ptr, v37, !1866 - v2257 = load v2256, !1862 - v2258 = get_local __ptr slice, _result__________________________________________________, !1867 - v2259 = get_local __ptr slice, __tmp_arg124 - mem_copy_val v2259, v2258 - v2260 = call len_30(v2259) - retd v2257 v2260, !1868 - - encode_187_abi_encode_188_block1(): - v2261 = const u64 2 - v2262 = mul v2217, v2261, !1869 - v2263 = add v2262, v2222, !1870 - v2264 = asm(new_cap: v2263, old_ptr: v2214, len: v2220) -> __ptr u8 hp, !1871 { - aloc new_cap - mcp hp old_ptr len - } - br encode_187_abi_encode_188_block0(v2264, v2263), !1872 - - block76(): - v2265 = get_local __ptr slice, _method_name, !1873 - v2266 = get_global __ptr string<6>, __const_global25 - v2267 = cast_ptr v2266 to ptr, !1874 - v2268 = get_local __ptr { ptr, u64 }, __anon_52, !1874 - v2269 = const u64 0 - v2270 = get_elem_ptr v2268, __ptr ptr, v2269 - store v2267 to v2270, !1874 - v2271 = const u64 1 - v2272 = get_elem_ptr v2268, __ptr u64, v2271 - v2273 = const u64 6 - store v2273 to v2272, !1874 - v2274 = get_local __ptr slice, __anon_53, !1874 - mem_copy_bytes v2274, v2268, 16 - v2275 = get_local __ptr slice, __tmp_arg51 - mem_copy_val v2275, v2265 - v2276 = get_local __ptr slice, __tmp_arg52 - mem_copy_val v2276, v2274 - v2277 = call eq_11(v2275, v2276) - cbr v2277, block78(), block79(), !1875 - - block78(): - v2278 = get_local __ptr { ptr }, _buffer, !1876 - v2279 = call read_72(v2278), !1881 - v2280 = asm(input: v2279) -> u64 input, !1884 { - } - v2281 = call read_72(v2278), !1887 - v2282 = asm(input: v2281) -> u64 input, !1890 { - } - v2283 = call read_72(v2278), !1893 - v2284 = asm(input: v2283) -> u64 input, !1896 { - } - v2285 = call read_72(v2278), !1899 - v2286 = asm(input: v2285) -> u64 input, !1902 { - } - v2287 = const u64 24, !1903 - v2288 = lsh v2280, v2287, !1906 - v2289 = const u64 4294967295, !1907 - v2290 = and v2288, v2289, !1908 - v2291 = const u64 16, !1909 - v2292 = lsh v2282, v2291, !1912 - v2293 = and v2292, v2289, !1913 - v2294 = or v2290, v2293, !1916 - v2295 = const u64 8, !1917 - v2296 = lsh v2284, v2295, !1920 - v2297 = and v2296, v2289, !1921 - v2298 = or v2294, v2297, !1924 - v2299 = or v2298, v2286, !1927 - v2300 = get_local __ptr { u64 }, __anon_037, !1928 - v2301 = const u64 0 - v2302 = get_elem_ptr v2300, __ptr u64, v2301, !1929 - store v2299 to v2302, !1930 - v2303 = get_local __ptr { u64 }, args__________________________, !1931 - mem_copy_val v2303, v2300 - v2304 = get_local __ptr { u64 }, args__________________________, !1932 - v2305 = const u64 0 - v2306 = get_elem_ptr v2304, __ptr u64, v2305, !1933 - v2307 = get_local __ptr { { ptr, u64, u64 } }, __ret_val46 - v2308 = call new_21(v2307) - v2309 = get_local __ptr { { ptr, u64, u64 } }, buffer_50, !1936 - mem_copy_val v2309, v2307 - v2310 = get_local __ptr { { ptr, u64, u64 } }, buffer_50, !1938 - v2311 = const u64 0 - v2312 = get_elem_ptr v2310, __ptr { ptr, u64, u64 }, v2311, !1939 - v2313 = asm(buffer: v2312) -> __ptr { ptr, u64, u64 } buffer { - } - v2314 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_056 - mem_copy_val v2314, v2313 - v2315 = get_local __ptr { ptr, u64, u64 }, __anon_038, !1940 - mem_copy_val v2315, v2314 - v2316 = const u64 0 - v2317 = get_elem_ptr v2315, __ptr ptr, v2316, !1941 - v2318 = load v2317, !1942 - v2319 = const u64 1 - v2320 = get_elem_ptr v2315, __ptr u64, v2319, !1943 - v2321 = load v2320, !1944 - v2322 = const u64 2 - v2323 = get_elem_ptr v2315, __ptr u64, v2322, !1945 - v2324 = load v2323, !1946 - v2325 = const u64 4 - v2326 = add v2324, v2325, !1947 - v2327 = cmp gt v2326 v2321, !1948 - cbr v2327, encode_197_abi_encode_198_block1(), encode_197_abi_encode_198_block0(v2318, v2321), !1949 - - encode_197_abi_encode_198_block0(v2328: ptr, v2329: u64): - v2330 = get_local __ptr u64, __anon_121, !1950 - mem_copy_val v2330, v2306 - v2331 = const u64 4 - v2332 = add v2330, v2331, !1951 - v2333 = cast_ptr v2332 to __ptr u8, !1952 - v2334 = add v2328, v2324, !1953 - v2335 = cast_ptr v2334 to __ptr u8, !1954 - mem_copy_bytes v2335, v2333, 4, !1955 - v2336 = get_local __ptr { ptr, u64, u64 }, __anon_220, !1956 - v2337 = const u64 0 - v2338 = get_elem_ptr v2336, __ptr ptr, v2337, !1957 - store v2328 to v2338, !1958 - v2339 = const u64 1 - v2340 = get_elem_ptr v2336, __ptr u64, v2339, !1959 - store v2329 to v2340, !1960 - v2341 = const u64 2 - v2342 = get_elem_ptr v2336, __ptr u64, v2341, !1961 - store v2326 to v2342, !1962 - v2343 = asm(buffer: v2336) -> __ptr { ptr, u64, u64 } buffer { - } - v2344 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_057 - mem_copy_val v2344, v2343 - v2345 = get_local __ptr { { ptr, u64, u64 } }, __anon_318, !1964 - v2346 = const u64 0 - v2347 = get_elem_ptr v2345, __ptr { ptr, u64, u64 }, v2346, !1965 - mem_copy_val v2347, v2344 - v2348 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !1966 - mem_copy_val v2348, v2345 - v2349 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !1967 - v2350 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg97 - mem_copy_val v2350, v2349 - v2351 = get_local __ptr slice, __ret_val67 - v2352 = call as_raw_slice_22(v2350, v2351) - v2353 = get_local __ptr slice, _result____________________________________________________, !1968 - mem_copy_val v2353, v2351 - v2354 = get_local __ptr slice, _result____________________________________________________, !1969 - v2355 = get_local __ptr slice, self_44, !1972 - mem_copy_val v2355, v2354 - v2356 = get_local __ptr slice, self_44, !1973 - v2357 = get_local __ptr slice, slice_30, !1974 - mem_copy_val v2357, v2356 - v2358 = get_local __ptr slice, slice_30, !1975 - v2359 = asm(ptr: v2358) -> __ptr { ptr, u64 } ptr { - } - v2360 = get_local __ptr { ptr, u64 }, __aggr_memcpy_058 - mem_copy_val v2360, v2359 - v2361 = get_local __ptr { ptr, u64 }, __anon_073, !1972 - mem_copy_val v2361, v2360 - v2362 = get_elem_ptr v2361, __ptr ptr, v37, !1976 - v2363 = load v2362, !1972 - v2364 = get_local __ptr slice, _result____________________________________________________, !1977 - v2365 = get_local __ptr slice, __tmp_arg125 - mem_copy_val v2365, v2364 - v2366 = call len_30(v2365) - retd v2363 v2366, !1978 - - encode_197_abi_encode_198_block1(): - v2367 = const u64 2 - v2368 = mul v2321, v2367, !1979 - v2369 = add v2368, v2325, !1980 - v2370 = asm(new_cap: v2369, old_ptr: v2318, len: v2324) -> __ptr u8 hp, !1981 { - aloc new_cap - mcp hp old_ptr len - } - br encode_197_abi_encode_198_block0(v2370, v2369), !1982 - - block79(): - v2371 = get_local __ptr slice, _method_name, !1983 - v2372 = get_global __ptr string<6>, __const_global26 - v2373 = cast_ptr v2372 to ptr, !1984 - v2374 = get_local __ptr { ptr, u64 }, __anon_54, !1984 - v2375 = const u64 0 - v2376 = get_elem_ptr v2374, __ptr ptr, v2375 - store v2373 to v2376, !1984 - v2377 = const u64 1 - v2378 = get_elem_ptr v2374, __ptr u64, v2377 - v2379 = const u64 6 - store v2379 to v2378, !1984 - v2380 = get_local __ptr slice, __anon_55, !1984 - mem_copy_bytes v2380, v2374, 16 - v2381 = get_local __ptr slice, __tmp_arg53 - mem_copy_val v2381, v2371 - v2382 = get_local __ptr slice, __tmp_arg54 - mem_copy_val v2382, v2380 - v2383 = call eq_11(v2381, v2382) - cbr v2383, block81(), block82(), !1985 - - block81(): - v2384 = get_local __ptr { ptr }, _buffer, !1986 - v2385 = get_elem_ptr v2384, __ptr ptr, v19, !1989 - v2386 = load v2385, !1990 - v2387 = asm(ptr: v2386, val) -> u64 val, !1991 { - lw val ptr i0, !58 - } - v2388 = load v2385, !1990 - v2389 = const u64 8, !1990 - v2390 = add v2388, v2389, !1990 - store v2390 to v2385, !1992 - v2391 = get_local __ptr { u64 }, __anon_039, !1993 - v2392 = get_elem_ptr v2391, __ptr u64, v1801, !1994 - store v2387 to v2392, !1995 - v2393 = get_local __ptr { u64 }, args___________________________, !1996 - mem_copy_val v2393, v2391 - v2394 = get_local __ptr { u64 }, args___________________________, !1997 - v2395 = const u64 0 - v2396 = get_elem_ptr v2394, __ptr u64, v2395, !1998 - v2397 = load v2396 - v2398 = get_local __ptr { { ptr, u64, u64 } }, __ret_val47 - v2399 = call new_21(v2398) - v2400 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg78 - mem_copy_val v2400, v2398 - v2401 = get_local __ptr { { ptr, u64, u64 } }, __ret_val27 - v2402 = call abi_encode_20(v2397, v2400, v2401) - v2403 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !2001 - mem_copy_val v2403, v2401 - v2404 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !2002 - v2405 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg98 - mem_copy_val v2405, v2404 - v2406 = get_local __ptr slice, __ret_val68 - v2407 = call as_raw_slice_22(v2405, v2406) - v2408 = get_local __ptr slice, _result______________________________________________________, !2003 - mem_copy_val v2408, v2406 - v2409 = get_local __ptr slice, _result______________________________________________________, !2004 - v2410 = get_local __ptr slice, self_45, !2007 - mem_copy_val v2410, v2409 - v2411 = get_local __ptr slice, self_45, !2008 - v2412 = get_local __ptr slice, slice_31, !2009 - mem_copy_val v2412, v2411 - v2413 = get_local __ptr slice, slice_31, !2010 - v2414 = asm(ptr: v2413) -> __ptr { ptr, u64 } ptr { - } - v2415 = get_local __ptr { ptr, u64 }, __aggr_memcpy_059 - mem_copy_val v2415, v2414 - v2416 = get_local __ptr { ptr, u64 }, __anon_074, !2007 - mem_copy_val v2416, v2415 - v2417 = get_elem_ptr v2416, __ptr ptr, v37, !2011 - v2418 = load v2417, !2007 - v2419 = get_local __ptr slice, _result______________________________________________________, !2012 - v2420 = get_local __ptr slice, __tmp_arg126 - mem_copy_val v2420, v2419 - v2421 = call len_30(v2420) - retd v2418 v2421, !2013 - - block82(): - v2422 = get_local __ptr slice, _method_name, !2014 - v2423 = get_global __ptr string<5>, __const_global27 - v2424 = cast_ptr v2423 to ptr, !2015 - v2425 = get_local __ptr { ptr, u64 }, __anon_56, !2015 - v2426 = const u64 0 - v2427 = get_elem_ptr v2425, __ptr ptr, v2426 - store v2424 to v2427, !2015 - v2428 = const u64 1 - v2429 = get_elem_ptr v2425, __ptr u64, v2428 - v2430 = const u64 5 - store v2430 to v2429, !2015 - v2431 = get_local __ptr slice, __anon_57, !2015 - mem_copy_bytes v2431, v2425, 16 - v2432 = get_local __ptr slice, __tmp_arg55 - mem_copy_val v2432, v2422 - v2433 = get_local __ptr slice, __tmp_arg56 - mem_copy_val v2433, v2431 - v2434 = call eq_11(v2432, v2433) - cbr v2434, block84(), block85(), !2016 - - block84(): - v2435 = get_local __ptr { ptr }, _buffer, !2017 - v2436 = call read_72(v2435), !2022 - v2437 = get_local __ptr { u8 }, __anon_040, !2023 - v2438 = const u64 0 - v2439 = get_elem_ptr v2437, __ptr u8, v2438, !2024 - store v2436 to v2439, !2025 - v2440 = get_local __ptr { u8 }, args____________________________, !2026 - mem_copy_val v2440, v2437 - v2441 = get_local __ptr { u8 }, args____________________________, !2027 - v2442 = const u64 0 - v2443 = get_elem_ptr v2441, __ptr u8, v2442, !2028 - v2444 = load v2443 - v2445 = get_local __ptr { { ptr, u64, u64 } }, __ret_val48 - v2446 = call new_21(v2445) - v2447 = get_local __ptr { { ptr, u64, u64 } }, buffer_53, !2031 - mem_copy_val v2447, v2445 - v2448 = get_local __ptr { { ptr, u64, u64 } }, buffer_53, !2033 - v2449 = const u64 0 - v2450 = get_elem_ptr v2448, __ptr { ptr, u64, u64 }, v2449, !2034 - v2451 = asm(buffer: v2450) -> __ptr { ptr, u64, u64 } buffer { - } - v2452 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_060 - mem_copy_val v2452, v2451 - v2453 = get_local __ptr { ptr, u64, u64 }, __anon_041, !2035 - mem_copy_val v2453, v2452 - v2454 = const u64 0 - v2455 = get_elem_ptr v2453, __ptr ptr, v2454, !2036 - v2456 = load v2455, !2037 - v2457 = const u64 1 - v2458 = get_elem_ptr v2453, __ptr u64, v2457, !2038 - v2459 = load v2458, !2039 - v2460 = const u64 2 - v2461 = get_elem_ptr v2453, __ptr u64, v2460, !2040 - v2462 = load v2461, !2041 - v2463 = const u64 1 - v2464 = add v2462, v2463, !2042 - v2465 = cmp gt v2464 v2459, !2043 - cbr v2465, encode_205_abi_encode_206_block1(), encode_205_abi_encode_206_block0(v2456, v2459), !2044 - - encode_205_abi_encode_206_block0(v2466: ptr, v2467: u64): - v2468 = add v2466, v2462, !2045 - v2469 = cast_ptr v2468 to __ptr u8, !2046 - store v2444 to v2469, !2047 - v2470 = get_local __ptr { ptr, u64, u64 }, __anon_122, !2048 - v2471 = const u64 0 - v2472 = get_elem_ptr v2470, __ptr ptr, v2471, !2049 - store v2466 to v2472, !2050 - v2473 = const u64 1 - v2474 = get_elem_ptr v2470, __ptr u64, v2473, !2051 - store v2467 to v2474, !2052 - v2475 = const u64 2 - v2476 = get_elem_ptr v2470, __ptr u64, v2475, !2053 - store v2464 to v2476, !2054 - v2477 = asm(buffer: v2470) -> __ptr { ptr, u64, u64 } buffer { - } - v2478 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_061 - mem_copy_val v2478, v2477 - v2479 = get_local __ptr { { ptr, u64, u64 } }, __anon_221, !2056 - v2480 = const u64 0 - v2481 = get_elem_ptr v2479, __ptr { ptr, u64, u64 }, v2480, !2057 - mem_copy_val v2481, v2478 - v2482 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !2058 - mem_copy_val v2482, v2479 - v2483 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !2059 - v2484 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg99 - mem_copy_val v2484, v2483 - v2485 = get_local __ptr slice, __ret_val69 - v2486 = call as_raw_slice_22(v2484, v2485) - v2487 = get_local __ptr slice, _result________________________________________________________, !2060 - mem_copy_val v2487, v2485 - v2488 = get_local __ptr slice, _result________________________________________________________, !2061 - v2489 = get_local __ptr slice, self_46, !2064 - mem_copy_val v2489, v2488 - v2490 = get_local __ptr slice, self_46, !2065 - v2491 = get_local __ptr slice, slice_32, !2066 - mem_copy_val v2491, v2490 - v2492 = get_local __ptr slice, slice_32, !2067 - v2493 = asm(ptr: v2492) -> __ptr { ptr, u64 } ptr { - } - v2494 = get_local __ptr { ptr, u64 }, __aggr_memcpy_062 - mem_copy_val v2494, v2493 - v2495 = get_local __ptr { ptr, u64 }, __anon_075, !2064 - mem_copy_val v2495, v2494 - v2496 = get_elem_ptr v2495, __ptr ptr, v37, !2068 - v2497 = load v2496, !2064 - v2498 = get_local __ptr slice, _result________________________________________________________, !2069 - v2499 = get_local __ptr slice, __tmp_arg127 - mem_copy_val v2499, v2498 - v2500 = call len_30(v2499) - retd v2497 v2500, !2070 - - encode_205_abi_encode_206_block1(): - v2501 = const u64 2 - v2502 = mul v2459, v2501, !2071 - v2503 = add v2502, v2463, !2072 - v2504 = asm(new_cap: v2503, old_ptr: v2456, len: v2462) -> __ptr u8 hp, !2073 { - aloc new_cap - mcp hp old_ptr len - } - br encode_205_abi_encode_206_block0(v2504, v2503), !2074 - - block85(): - v2505 = const u64 123, !2075 - revert v2505, !2076 - } - - pub fn read_bytes_8(self !2077: __ptr { ptr }, count !2078: u64, __ret_value: __ptr slice) -> (), !2081 { - local mut slice __aggr_memcpy_0 - local { ptr, u64 } __anon_0 - local slice slice - - entry(self: __ptr { ptr }, count: u64, __ret_value: __ptr slice): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr ptr, v0, !53 - v2 = get_local __ptr { ptr, u64 }, __anon_0, !2082 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr ptr, v3, !2082 - mem_copy_val v4, v1 - v5 = const u64 1 - v6 = get_elem_ptr v2, __ptr u64, v5, !2082 - store count to v6, !2082 - v7 = asm(ptr: v2) -> __ptr slice ptr { - } - v8 = get_local __ptr slice, __aggr_memcpy_0 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, slice, !2083 - mem_copy_val v9, v8 - v10 = load v1 - v11 = add v10, count - store v11 to v1, !2084 - v12 = get_local __ptr slice, slice, !2085 - mem_copy_val __ret_value, v12 - v13 = const unit () - ret () v13 - } - - pub fn eq_11(self: __ptr slice, other: __ptr slice) -> bool, !2089 { - local slice __tmp_arg - local slice __tmp_arg0 - local slice __tmp_arg1 - local slice __tmp_arg2 - local slice __tmp_arg3 - local slice other_ - local slice self_ - - entry(self: __ptr slice, other: __ptr slice): - v0 = get_local __ptr slice, self_ - mem_copy_val v0, self - v1 = get_local __ptr slice, other_ - mem_copy_val v1, other - v2 = get_local __ptr slice, self_, !2090 - v3 = get_local __ptr slice, __tmp_arg - mem_copy_val v3, v2 - v4 = call len_14(v3) - v5 = get_local __ptr slice, other_, !2091 - v6 = get_local __ptr slice, __tmp_arg0 - mem_copy_val v6, v5 - v7 = call len_14(v6) - v8 = cmp eq v4 v7, !2096 - v9 = const bool false, !2097 - v10 = cmp eq v8 v9, !2100 - v11 = const bool false, !2101 - cbr v10, block2(v11), block1(), !2092 - - block1(): - v12 = get_local __ptr slice, self_, !2102 - v13 = get_local __ptr slice, __tmp_arg2 - mem_copy_val v13, v12 - v14 = call as_ptr_15(v13) - v15 = get_local __ptr slice, other_, !2103 - v16 = get_local __ptr slice, __tmp_arg3 - mem_copy_val v16, v15 - v17 = call as_ptr_15(v16) - v18 = get_local __ptr slice, self_, !2104 - v19 = get_local __ptr slice, __tmp_arg1 - mem_copy_val v19, v18 - v20 = call len_14(v19) - v21 = asm(r1: v14, r2: v17, r3: v20, r4) -> bool r4, !2105 { - meq r4 r1 r2 r3, !2106 - } - br block2(v21) - - block2(v22: bool): - ret bool v22 - } - - pub fn len_14(self: __ptr slice) -> u64, !2110 { - local slice self_ - - entry(self: __ptr slice): - v0 = get_local __ptr slice, self_ - mem_copy_val v0, self - v1 = get_local __ptr slice, self_, !2111 - v2 = asm(s: v1) -> __ptr { ptr, u64 } s { - } - v3 = const u64 1 - v4 = get_elem_ptr v2, __ptr u64, v3 - v5 = load v4 - ret u64 v5 - } - - pub fn as_ptr_15(self: __ptr slice) -> ptr, !2114 { - local slice self_ - - entry(self: __ptr slice): - v0 = get_local __ptr slice, self_ - mem_copy_val v0, self - v1 = get_local __ptr slice, self_, !2115 - v2 = asm(s: v1) -> __ptr { ptr, u64 } s { - } - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr ptr, v3 - v5 = load v4 - ret ptr v5 - } - - pub fn abi_decode_18(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 0]) -> (), !2120 { - local [u8; 0] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 0] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 0]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 0, !2121 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2123 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2124 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 0], __anon_0, !2125 - mem_clear_val v13 - v14 = get_local __ptr [u8; 0], array, !2126 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 0], array, !2127 - v16 = cast_ptr v15 to __ptr [u64; 0] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 0 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2129 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2130 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !2131 - br while(v30) - - while(v31: u64): - v32 = const u64 0 - v33 = cmp lt v31 v32, !2134 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !2135 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2136 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2137 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !2140 - v51 = load v50, !2141 - v52 = asm(ptr: v51, val) -> u64 val, !2142 { - lw val ptr i0, !58 - } - v53 = load v50, !2141 - v54 = const u64 8, !2141 - v55 = add v53, v54, !2141 - store v55 to v50, !2143 - store v52 to v48, !2144 - v56 = const u64 1, !2145 - v57 = add v31, v56, !2148 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_20(self !2149: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !2152 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local { ptr, u64, u64 } __anon_1 - local { { ptr, u64, u64 } } __anon_2 - local { { ptr, u64, u64 } } buffer_ - - entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2153 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !428 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v5, v4 - v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v6, v5 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr ptr, v7 - v9 = load v8 - v10 = const u64 1 - v11 = get_elem_ptr v6, __ptr u64, v10 - v12 = load v11 - v13 = const u64 2 - v14 = get_elem_ptr v6, __ptr u64, v13 - v15 = load v14 - v16 = const u64 8 - v17 = add v15, v16 - v18 = cmp gt v17 v12 - cbr v18, block1(), block0(v9, v12) - - block0(v19: ptr, v20: u64): - v21 = add v19, v15 - v22 = cast_ptr v21 to __ptr u64 - store self to v22 - v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 - v24 = const u64 0 - v25 = get_elem_ptr v23, __ptr ptr, v24 - store v19 to v25 - v26 = const u64 1 - v27 = get_elem_ptr v23, __ptr u64, v26 - store v20 to v27 - v28 = const u64 2 - v29 = get_elem_ptr v23, __ptr u64, v28 - store v17 to v29 - v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { - } - v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v31, v30 - v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !2154 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 - mem_copy_val v34, v31 - mem_copy_val __ret_value, v32 - v35 = const unit () - ret () v35 - - block1(): - v36 = const u64 2 - v37 = mul v12, v36 - v38 = add v37, v16 - v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v39, v38) - } - - pub fn new_21(__ret_value: __ptr { { ptr, u64, u64 } }) -> (), !2157 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local { ptr, u64, u64 } __anon_0 - local { { ptr, u64, u64 } } __anon_1 - - entry(__ret_value: __ptr { { ptr, u64, u64 } }): - v0 = const u64 1024 - v1 = asm(cap: v0) -> ptr hp { - aloc cap - } - v2 = get_local __ptr { ptr, u64, u64 }, __anon_0 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr ptr, v3 - store v1 to v4 - v5 = const u64 1 - v6 = get_elem_ptr v2, __ptr u64, v5 - store v0 to v6 - v7 = const u64 2 - v8 = get_elem_ptr v2, __ptr u64, v7 - v9 = const u64 0 - store v9 to v8 - v10 = asm(buffer: v2) -> __ptr { ptr, u64, u64 } buffer { - } - v11 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v11, v10 - v12 = get_local __ptr { { ptr, u64, u64 } }, __anon_1, !2158 - v13 = const u64 0 - v14 = get_elem_ptr v12, __ptr { ptr, u64, u64 }, v13 - mem_copy_val v14, v11 - mem_copy_val __ret_value, v12 - v15 = const unit () - ret () v15 - } - - pub fn as_raw_slice_22(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice) -> (), !2161 { - local mut slice __aggr_memcpy_00 - local { ptr, u64 } __anon_1 - local { { ptr, u64, u64 } } self_ - - entry(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, self_, !2162 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !428 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - v7 = load v6 - v8 = const u64 2 - v9 = get_elem_ptr v4, __ptr u64, v8 - v10 = load v9 - v11 = get_local __ptr { ptr, u64 }, __anon_1 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr ptr, v12 - v14 = get_elem_ptr v13, __ptr ptr, - store v7 to v14 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15 - v17 = get_elem_ptr v16, __ptr u64, - store v10 to v17 - v18 = asm(s: v11) -> __ptr slice s { - } - v19 = get_local __ptr slice, __aggr_memcpy_00 - mem_copy_val v19, v18 - mem_copy_val __ret_value, v19 - v20 = const unit () - ret () v20 - } - - pub fn len_30(self: __ptr slice) -> u64, !2165 { - local slice slice_ - - entry(self: __ptr slice): - v0 = get_local __ptr slice, slice_, !2168 - mem_copy_val v0, self - v1 = get_local __ptr slice, slice_, !2169 - v2 = asm(ptr: v1) -> __ptr { ptr, u64 } ptr { - } - v3 = const u64 1 - v4 = get_elem_ptr v2, __ptr u64, v3 - v5 = load v4 - ret u64 v5 - } - - pub fn abi_decode_34(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 1]) -> (), !2170 { - local [u8; 1] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 1] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 1]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 1, !2121 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2171 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2172 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 1], __anon_0, !2125 - mem_clear_val v13 - v14 = get_local __ptr [u8; 1], array, !2126 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 1], array, !2127 - v16 = cast_ptr v15 to __ptr [u64; 1] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 1 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2173 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2174 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !2131 - br while(v30) - - while(v31: u64): - v32 = const u64 1 - v33 = cmp lt v31 v32, !2175 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !2135 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2176 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2177 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !2178 - v51 = load v50, !2179 - v52 = asm(ptr: v51, val) -> u64 val, !2180 { - lw val ptr i0, !58 - } - v53 = load v50, !2179 - v54 = const u64 8, !2179 - v55 = add v53, v54, !2179 - store v55 to v50, !2181 - store v52 to v48, !2144 - v56 = const u64 1, !2145 - v57 = add v31, v56, !2182 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_decode_40(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 16]) -> (), !2183 { - local [u8; 16] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 16] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 16]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 16, !2121 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2184 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2185 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 16], __anon_0, !2125 - mem_clear_val v13 - v14 = get_local __ptr [u8; 16], array, !2126 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 16], array, !2127 - v16 = cast_ptr v15 to __ptr [u64; 16] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 16 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2186 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2187 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !2131 - br while(v30) - - while(v31: u64): - v32 = const u64 16 - v33 = cmp lt v31 v32, !2188 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !2135 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2189 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2190 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !2191 - v51 = load v50, !2192 - v52 = asm(ptr: v51, val) -> u64 val, !2193 { - lw val ptr i0, !58 - } - v53 = load v50, !2192 - v54 = const u64 8, !2192 - v55 = add v53, v54, !2192 - store v55 to v50, !2194 - store v52 to v48, !2144 - v56 = const u64 1, !2145 - v57 = add v31, v56, !2195 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_decode_46(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 32]) -> (), !2196 { - local [u8; 32] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 32] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 32]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 32, !2121 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2197 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2198 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 32], __anon_0, !2125 - mem_clear_val v13 - v14 = get_local __ptr [u8; 32], array, !2126 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 32], array, !2127 - v16 = cast_ptr v15 to __ptr [u64; 32] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 32 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2199 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2200 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !2131 - br while(v30) - - while(v31: u64): - v32 = const u64 32 - v33 = cmp lt v31 v32, !2201 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !2135 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2202 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2203 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !2204 - v51 = load v50, !2205 - v52 = asm(ptr: v51, val) -> u64 val, !2206 { - lw val ptr i0, !58 - } - v53 = load v50, !2205 - v54 = const u64 8, !2205 - v55 = add v53, v54, !2205 - store v55 to v50, !2207 - store v52 to v48, !2144 - v56 = const u64 1, !2145 - v57 = add v31, v56, !2208 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_decode_52(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 64]) -> (), !2209 { - local [u8; 64] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 64] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 64]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 64, !2121 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2210 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2211 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 64], __anon_0, !2125 - mem_clear_val v13 - v14 = get_local __ptr [u8; 64], array, !2126 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 64], array, !2127 - v16 = cast_ptr v15 to __ptr [u64; 64] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 64 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2212 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2213 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !2131 - br while(v30) - - while(v31: u64): - v32 = const u64 64 - v33 = cmp lt v31 v32, !2214 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !2135 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2215 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2216 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !2217 - v51 = load v50, !2218 - v52 = asm(ptr: v51, val) -> u64 val, !2219 { - lw val ptr i0, !58 - } - v53 = load v50, !2218 - v54 = const u64 8, !2218 - v55 = add v53, v54, !2218 - store v55 to v50, !2220 - store v52 to v48, !2144 - v56 = const u64 1, !2145 - v57 = add v31, v56, !2221 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_decode_58(buffer !2116: __ptr { ptr }, __ret_value: __ptr [u64; 8]) -> (), !2222 { - local [u8; 8] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 8] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 8]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 8, !2121 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2223 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !2224 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 8], __anon_0, !2125 - mem_clear_val v13 - v14 = get_local __ptr [u8; 8], array, !2126 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 8], array, !2127 - v16 = cast_ptr v15 to __ptr [u64; 8] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 8 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2225 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2226 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !2131 - br while(v30) - - while(v31: u64): - v32 = const u64 8 - v33 = cmp lt v31 v32, !2227 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !2135 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2228 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2229 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !2230 - v51 = load v50, !2231 - v52 = asm(ptr: v51, val) -> u64 val, !2232 { - lw val ptr i0, !58 - } - v53 = load v50, !2231 - v54 = const u64 8, !2231 - v55 = add v53, v54, !2231 - store v55 to v50, !2233 - store v52 to v48, !2144 - v56 = const u64 1, !2145 - v57 = add v31, v56, !2234 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn encode_60(item: __ptr [u64; 8], __ret_value: __ptr slice) -> (), !2237 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local slice __ret_val1 - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 8] self_ - - entry(item: __ptr [u64; 8], __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v1 = call new_21(v0) - v2 = get_local __ptr [u64; 8], self_, !2238 - mem_copy_val v2, item - v3 = const u64 0 - v4 = const u64 0 - v5 = get_elem_ptr v0, __ptr ptr, v3, v4 - v6 = load v5 - v7 = const u64 0 - v8 = const u64 1 - v9 = get_elem_ptr v0, __ptr u64, v7, v8 - v10 = load v9 - v11 = const u64 0 - v12 = const u64 2 - v13 = get_elem_ptr v0, __ptr u64, v11, v12 - v14 = load v13 - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2239 - v16 = const u64 0 - v17 = const u64 0 - v18 = get_elem_ptr v15, __ptr ptr, v16, v17 - store v6 to v18 - v19 = const u64 0 - v20 = const u64 1 - v21 = get_elem_ptr v15, __ptr u64, v19, v20 - store v10 to v21 - v22 = const u64 0 - v23 = const u64 2 - v24 = get_elem_ptr v15, __ptr u64, v22, v23 - store v14 to v24 - v25 = const u64 0, !119 - br abi_encode_61_while(v25), !2238 - - abi_encode_61_while(v26: u64): - v27 = const u64 8 - v28 = cmp lt v26 v27, !2240 - cbr v28, abi_encode_61_while_body(), abi_encode_61_end_while(), !2238 - - abi_encode_61_while_body(): - v29 = get_local __ptr [u64; 8], self_, !2241 - v30 = get_elem_ptr v29, __ptr u64, v26, !2242 - v31 = load v30, !2238 - v32 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2243 - v33 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v34 = call abi_encode_20(v31, v32, v33) - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2244 - mem_copy_val v35, v33 - v36 = const u64 1, !134 - v37 = add v26, v36, !2245 - br abi_encode_61_while(v37), !2238 - - abi_encode_61_end_while(): - v38 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2246 - v39 = get_local __ptr slice, __ret_val1 - v40 = call as_raw_slice_22(v38, v39) - mem_copy_val __ret_value, v39 - v41 = const unit () - ret () v41 - } - - pub fn read_72(self !2247: __ptr { ptr }) -> u8, !2250 { - entry(self: __ptr { ptr }): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr ptr, v0, !53 - v2 = load v1 - v3 = asm(ptr: v2, val) -> u8 val, !2251 { - lb val ptr i0, !2252 - } - v4 = load v1 - v5 = const u64 1 - v6 = add v4, v5 - store v6 to v1, !2253 - ret u8 v3 - } - - pub fn encode_130(item: __ptr { u64 }, __ret_value: __ptr slice) -> (), !2254 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local slice __ret_val1 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - - entry(item: __ptr { u64 }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2255 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr u64, v3, !2257 - v5 = load v4, !2255 - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v7 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v8 = call abi_encode_20(v5, v6, v7) - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2259 - mem_copy_val v9, v7 - v10 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v11 = get_local __ptr slice, __ret_val1 - v12 = call as_raw_slice_22(v10, v11) - mem_copy_val __ret_value, v11 - v13 = const unit () - ret () v13 - } - - pub fn encode_142(item: __ptr { u64, u64, u64 }, __ret_value: __ptr slice) -> (), !2260 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local slice __ret_val3 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer___ - local { { ptr, u64, u64 } } buffer____ - - entry(item: __ptr { u64, u64, u64 }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2261 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr u64, v3, !2263 - v5 = load v4, !2261 - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v7 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v8 = call abi_encode_20(v5, v6, v7) - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2265 - mem_copy_val v9, v7 - v10 = const u64 1 - v11 = get_elem_ptr item, __ptr u64, v10, !2267 - v12 = load v11, !2261 - v13 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v14 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v15 = call abi_encode_20(v12, v13, v14) - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !2269 - mem_copy_val v16, v14 - v17 = const u64 2 - v18 = get_elem_ptr item, __ptr u64, v17, !2271 - v19 = load v18, !2261 - v20 = get_local __ptr { { ptr, u64, u64 } }, buffer___ - v21 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v22 = call abi_encode_20(v19, v20, v21) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !2273 - mem_copy_val v23, v21 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer____ - v25 = get_local __ptr slice, __ret_val3 - v26 = call as_raw_slice_22(v24, v25) - mem_copy_val __ret_value, v25 - v27 = const unit () - ret () v27 - } - - pub fn encode_158(item: __ptr { u64, u64 }, __ret_value: __ptr slice) -> (), !2274 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val2 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer___ - - entry(item: __ptr { u64, u64 }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2275 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr u64, v3, !2277 - v5 = load v4, !2275 - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v7 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v8 = call abi_encode_20(v5, v6, v7) - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2279 - mem_copy_val v9, v7 - v10 = const u64 1 - v11 = get_elem_ptr item, __ptr u64, v10, !2281 - v12 = load v11, !2275 - v13 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v14 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v15 = call abi_encode_20(v12, v13, v14) - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !2283 - mem_copy_val v16, v14 - v17 = get_local __ptr { { ptr, u64, u64 } }, buffer___ - v18 = get_local __ptr slice, __ret_val2 - v19 = call as_raw_slice_22(v17, v18) - mem_copy_val __ret_value, v18 - v20 = const unit () - ret () v20 - } -} - -!0 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main..sw" -!1 = span !0 1 8828 -!2 = fn_name_span !0 8 15 -!3 = (!1 !2) -!4 = span !0 50 87 -!5 = fn_call_path_span !0 50 85 -!6 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/codec.sw" -!7 = span !6 1259 1300 -!8 = (!4 !5 !7) -!9 = span !6 1320 1359 -!10 = fn_call_path_span !6 1324 1327 -!11 = (!4 !5 !9 !10) -!12 = (!4 !5 !9 !10) -!13 = span !6 1379 1396 -!14 = fn_call_path_span !6 1383 1387 -!15 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_ptr.sw" -!16 = span !15 2650 2739 -!17 = (!4 !5 !13 !14 !16) -!18 = span !15 2688 2701 -!19 = span !6 1439 1497 -!20 = (!4 !5 !19) -!21 = span !6 1407 1508 -!22 = (!4 !5 !21) -!23 = (!4 !5) -!24 = (!4 !5 !21) -!25 = span !0 32 88 -!26 = span !0 120 147 -!27 = fn_call_path_span !0 120 138 -!28 = span !6 140299 140335 -!29 = fn_call_path_span !6 140299 140333 -!30 = span !6 882 923 -!31 = (!26 !27 !28 !29 !30) -!32 = span !6 943 981 -!33 = fn_call_path_span !6 947 950 -!34 = (!26 !27 !28 !29 !32 !33) -!35 = (!26 !27 !28 !29 !32 !33) -!36 = span !6 1001 1018 -!37 = fn_call_path_span !6 1005 1009 -!38 = (!26 !27 !28 !29 !36 !37 !16) -!39 = span !6 1061 1119 -!40 = (!26 !27 !28 !29 !39) -!41 = span !6 1029 1130 -!42 = (!26 !27 !28 !29 !41) -!43 = (!26 !27 !28 !29) -!44 = (!26 !27 !28 !29 !41) -!45 = span !6 140282 140336 -!46 = (!26 !27 !45) -!47 = span !6 140355 140361 -!48 = (!26 !27 !47) -!49 = span !6 140341 140362 -!50 = fn_call_path_span !6 140341 140354 -!51 = span !6 73247 73275 -!52 = fn_call_path_span !6 73254 73266 -!53 = span !6 625 637 -!54 = (!26 !27 !49 !50 !51 !52 !53) -!55 = (!26 !27 !49 !50 !51 !52) -!56 = span !6 2766 2847 -!57 = (!26 !27 !49 !50 !51 !52 !56) -!58 = span !6 2804 2817 -!59 = span !6 2857 2896 -!60 = (!26 !27 !49 !50 !51 !52 !59) -!61 = span !6 73285 73319 -!62 = (!26 !27 !49 !50 !61) -!63 = span !6 73336 73340 -!64 = (!26 !27 !49 !50 !63) -!65 = span !6 73336 73346 -!66 = fn_call_path_span !6 73341 73344 -!67 = (!26 !27 !49 !50 !65 !66) -!68 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_slice.sw" -!69 = span !68 2922 2926 -!70 = (!26 !27 !49 !50 !65 !66 !69) -!71 = span !68 2911 2927 -!72 = fn_call_path_span !68 2911 2921 -!73 = (!26 !27 !49 !50 !65 !66 !71 !72) -!74 = span !68 1633 1638 -!75 = (!26 !27 !49 !50 !65 !66 !71 !72 !74) -!76 = span !68 2928 2929 -!77 = (!26 !27 !49 !50 !65 !66 !76) -!78 = span !6 73335 73352 -!79 = (!26 !27 !49 !50 !78) -!80 = (!26 !27 !49 !50 !78) -!81 = (!26 !27 !49 !50 !78) -!82 = (!26 !27 !49 !50 !78) -!83 = span !0 101 148 -!84 = span !0 164 176 -!85 = span !0 180 192 -!86 = span !0 164 192 -!87 = span !0 219 226 -!88 = span !0 219 250 -!89 = fn_call_path_span !0 227 233 -!90 = span !6 3959 3978 -!91 = fn_call_path_span !6 3959 3972 -!92 = span !6 115441 115466 -!93 = (!88 !89 !90 !91 !92) -!94 = (!88 !89 !90 !91 !92) -!95 = span !0 195 251 -!96 = span !0 324 328 -!97 = span !0 329 330 -!98 = span !0 296 331 -!99 = fn_call_path_span !0 296 323 -!100 = (!98 !99) -!101 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw" -!102 = span !101 4062 4063 -!103 = (!98 !99 !102) -!104 = span !0 272 332 -!105 = span !0 377 384 -!106 = span !0 358 385 -!107 = fn_call_path_span !0 358 364 -!108 = (!106 !107) -!109 = span !6 70852 70856 -!110 = (!106 !107 !109) -!111 = span !6 70852 70882 -!112 = fn_call_path_span !6 70857 70867 -!113 = (!106 !107 !111 !112) -!114 = (!106 !107 !111 !112) -!115 = span !6 20784 20790 -!116 = (!106 !107 !111 !112 !115) -!117 = span !6 20767 20791 -!118 = (!106 !107 !111 !112 !117) -!119 = span !6 20812 20813 -!120 = (!106 !107 !111 !112) -!121 = span !6 20830 20835 -!122 = fn_call_path_span !6 20832 20833 -!123 = (!106 !107 !111 !112 !121 !122) -!124 = (!106 !107 !111 !112) -!125 = span !6 20859 20863 -!126 = (!106 !107 !111 !112 !125) -!127 = span !6 20859 20866 -!128 = (!106 !107 !111 !112 !127) -!129 = (!106 !107 !111 !112) -!130 = span !6 20878 20884 -!131 = (!106 !107 !111 !112 !130) -!132 = span !6 20850 20885 -!133 = (!106 !107 !111 !112 !132) -!134 = span !6 20904 20905 -!135 = span !6 20899 20905 -!136 = fn_call_path_span !6 20901 20903 -!137 = (!106 !107 !111 !112 !135 !136) -!138 = (!106 !107 !111 !112) -!139 = span !6 20927 20933 -!140 = (!106 !107 !111 !112 !139) -!141 = span !6 70839 70883 -!142 = (!106 !107 !141) -!143 = span !6 70888 70894 -!144 = (!106 !107 !143) -!145 = span !0 333 386 -!146 = span !0 422 429 -!147 = span !0 422 435 -!148 = fn_call_path_span !0 430 433 -!149 = (!147 !148) -!150 = (!147 !148 !69) -!151 = (!147 !148 !71 !72) -!152 = (!147 !148 !71 !72 !74) -!153 = (!147 !148 !76) -!154 = span !0 437 444 -!155 = span !0 407 457 -!156 = span !0 464 476 -!157 = span !0 480 492 -!158 = span !0 464 492 -!159 = span !0 519 526 -!160 = span !0 519 550 -!161 = fn_call_path_span !0 527 533 -!162 = (!160 !161 !90 !91 !92) -!163 = (!160 !161 !90 !91 !92) -!164 = span !0 495 551 -!165 = span !0 624 628 -!166 = span !0 629 630 -!167 = span !0 596 631 -!168 = fn_call_path_span !0 596 623 -!169 = (!167 !168) -!170 = span !101 4156 4157 -!171 = (!167 !168 !170) -!172 = span !0 572 632 -!173 = span !0 677 684 -!174 = span !0 658 685 -!175 = fn_call_path_span !0 658 664 -!176 = (!174 !175) -!177 = (!174 !175 !109) -!178 = (!174 !175 !111 !112) -!179 = (!174 !175 !111 !112) -!180 = (!174 !175 !111 !112 !115) -!181 = (!174 !175 !111 !112 !117) -!182 = (!174 !175 !111 !112) -!183 = (!174 !175 !111 !112 !121 !122) -!184 = (!174 !175 !111 !112) -!185 = (!174 !175 !111 !112 !125) -!186 = (!174 !175 !111 !112 !127) -!187 = (!174 !175 !111 !112) -!188 = (!174 !175 !111 !112 !130) -!189 = (!174 !175 !111 !112 !132) -!190 = (!174 !175 !111 !112 !135 !136) -!191 = (!174 !175 !111 !112) -!192 = (!174 !175 !111 !112 !139) -!193 = (!174 !175 !141) -!194 = (!174 !175 !143) -!195 = span !0 633 686 -!196 = span !0 722 729 -!197 = span !0 722 735 -!198 = fn_call_path_span !0 730 733 -!199 = (!197 !198) -!200 = (!197 !198 !69) -!201 = (!197 !198 !71 !72) -!202 = (!197 !198 !71 !72 !74) -!203 = (!197 !198 !76) -!204 = span !0 737 744 -!205 = span !0 707 757 -!206 = span !0 764 776 -!207 = span !0 780 793 -!208 = span !0 764 793 -!209 = span !0 821 828 -!210 = span !0 821 853 -!211 = fn_call_path_span !0 829 835 -!212 = (!210 !211 !90 !91 !92) -!213 = (!210 !211 !90 !91 !92) -!214 = span !0 796 854 -!215 = span !0 929 933 -!216 = span !0 934 935 -!217 = span !0 900 936 -!218 = fn_call_path_span !0 900 928 -!219 = (!217 !218) -!220 = span !101 4359 4360 -!221 = (!217 !218 !220) -!222 = span !0 875 937 -!223 = span !0 983 990 -!224 = span !0 963 991 -!225 = fn_call_path_span !0 963 969 -!226 = (!224 !225) -!227 = (!224 !225 !109) -!228 = (!224 !225 !111 !112) -!229 = (!224 !225 !111 !112) -!230 = (!224 !225 !111 !112 !115) -!231 = (!224 !225 !111 !112 !117) -!232 = (!224 !225 !111 !112) -!233 = (!224 !225 !111 !112 !121 !122) -!234 = (!224 !225 !111 !112) -!235 = (!224 !225 !111 !112 !125) -!236 = (!224 !225 !111 !112 !127) -!237 = (!224 !225 !111 !112) -!238 = (!224 !225 !111 !112 !130) -!239 = (!224 !225 !111 !112 !132) -!240 = (!224 !225 !111 !112 !135 !136) -!241 = (!224 !225 !111 !112) -!242 = (!224 !225 !111 !112 !139) -!243 = (!224 !225 !141) -!244 = (!224 !225 !143) -!245 = span !0 938 992 -!246 = span !0 1028 1035 -!247 = span !0 1028 1041 -!248 = fn_call_path_span !0 1036 1039 -!249 = (!247 !248) -!250 = (!247 !248 !69) -!251 = (!247 !248 !71 !72) -!252 = (!247 !248 !71 !72 !74) -!253 = (!247 !248 !76) -!254 = span !0 1043 1050 -!255 = span !0 1013 1063 -!256 = span !0 1070 1082 -!257 = span !0 1086 1099 -!258 = span !0 1070 1099 -!259 = span !0 1127 1134 -!260 = span !0 1127 1159 -!261 = fn_call_path_span !0 1135 1141 -!262 = (!260 !261 !90 !91 !92) -!263 = (!260 !261 !90 !91 !92) -!264 = span !0 1102 1160 -!265 = span !0 1235 1239 -!266 = span !0 1240 1241 -!267 = span !0 1206 1242 -!268 = fn_call_path_span !0 1206 1234 -!269 = (!267 !268) -!270 = span !101 4458 4459 -!271 = (!267 !268 !270) -!272 = span !0 1181 1243 -!273 = span !0 1289 1296 -!274 = span !0 1269 1297 -!275 = fn_call_path_span !0 1269 1275 -!276 = (!274 !275) -!277 = (!274 !275 !109) -!278 = (!274 !275 !111 !112) -!279 = (!274 !275 !111 !112) -!280 = (!274 !275 !111 !112 !115) -!281 = (!274 !275 !111 !112 !117) -!282 = (!274 !275 !111 !112) -!283 = (!274 !275 !111 !112 !121 !122) -!284 = (!274 !275 !111 !112) -!285 = (!274 !275 !111 !112 !125) -!286 = (!274 !275 !111 !112 !127) -!287 = (!274 !275 !111 !112) -!288 = (!274 !275 !111 !112 !130) -!289 = (!274 !275 !111 !112 !132) -!290 = (!274 !275 !111 !112 !135 !136) -!291 = (!274 !275 !111 !112) -!292 = (!274 !275 !111 !112 !139) -!293 = (!274 !275 !141) -!294 = (!274 !275 !143) -!295 = span !0 1244 1298 -!296 = span !0 1334 1341 -!297 = span !0 1334 1347 -!298 = fn_call_path_span !0 1342 1345 -!299 = (!297 !298) -!300 = (!297 !298 !69) -!301 = (!297 !298 !71 !72) -!302 = (!297 !298 !71 !72 !74) -!303 = (!297 !298 !76) -!304 = span !0 1349 1356 -!305 = span !0 1319 1369 -!306 = span !0 1376 1388 -!307 = span !0 1392 1405 -!308 = span !0 1376 1405 -!309 = span !0 1433 1440 -!310 = span !0 1433 1465 -!311 = fn_call_path_span !0 1441 1447 -!312 = (!310 !311 !90 !91 !92) -!313 = (!310 !311 !90 !91 !92) -!314 = span !0 1408 1466 -!315 = span !0 1541 1545 -!316 = span !0 1546 1547 -!317 = span !0 1512 1548 -!318 = fn_call_path_span !0 1512 1540 -!319 = (!317 !318) -!320 = span !101 4557 4558 -!321 = (!317 !318 !320) -!322 = span !0 1487 1549 -!323 = span !0 1595 1602 -!324 = span !0 1575 1603 -!325 = fn_call_path_span !0 1575 1581 -!326 = (!324 !325) -!327 = (!324 !325 !109) -!328 = (!324 !325 !111 !112) -!329 = (!324 !325 !111 !112) -!330 = (!324 !325 !111 !112 !115) -!331 = (!324 !325 !111 !112 !117) -!332 = (!324 !325 !111 !112) -!333 = (!324 !325 !111 !112 !121 !122) -!334 = (!324 !325 !111 !112) -!335 = (!324 !325 !111 !112 !125) -!336 = (!324 !325 !111 !112 !127) -!337 = (!324 !325 !111 !112) -!338 = (!324 !325 !111 !112 !130) -!339 = (!324 !325 !111 !112 !132) -!340 = (!324 !325 !111 !112 !135 !136) -!341 = (!324 !325 !111 !112) -!342 = (!324 !325 !111 !112 !139) -!343 = (!324 !325 !141) -!344 = (!324 !325 !143) -!345 = span !0 1550 1604 -!346 = span !0 1640 1647 -!347 = span !0 1640 1653 -!348 = fn_call_path_span !0 1648 1651 -!349 = (!347 !348) -!350 = (!347 !348 !69) -!351 = (!347 !348 !71 !72) -!352 = (!347 !348 !71 !72 !74) -!353 = (!347 !348 !76) -!354 = span !0 1655 1662 -!355 = span !0 1625 1675 -!356 = span !0 1682 1694 -!357 = span !0 1698 1710 -!358 = span !0 1682 1710 -!359 = span !0 1737 1744 -!360 = span !0 1737 1768 -!361 = fn_call_path_span !0 1745 1751 -!362 = (!360 !361 !90 !91 !92) -!363 = (!360 !361 !90 !91 !92) -!364 = span !0 1713 1769 -!365 = span !0 1842 1846 -!366 = span !0 1847 1848 -!367 = span !0 1814 1849 -!368 = fn_call_path_span !0 1814 1841 -!369 = (!367 !368) -!370 = span !101 4257 4258 -!371 = (!367 !368 !370) -!372 = span !101 4261 4262 -!373 = (!367 !368 !372) -!374 = span !0 1790 1850 -!375 = span !0 1895 1902 -!376 = span !0 1851 1904 -!377 = span !0 1940 1947 -!378 = span !0 1940 1953 -!379 = fn_call_path_span !0 1948 1951 -!380 = (!378 !379) -!381 = (!378 !379 !69) -!382 = (!378 !379 !71 !72) -!383 = (!378 !379 !71 !72 !74) -!384 = (!378 !379 !76) -!385 = span !0 1955 1962 -!386 = span !0 1925 1975 -!387 = span !0 1982 1994 -!388 = span !0 1998 2007 -!389 = span !0 1982 2007 -!390 = span !0 2030 2037 -!391 = span !0 2030 2057 -!392 = fn_call_path_span !0 2038 2044 -!393 = span !6 115442 115463 -!394 = fn_call_path_span !6 115442 115455 -!395 = span !6 71642 71672 -!396 = fn_call_path_span !6 71649 71662 -!397 = (!391 !392 !90 !91 !393 !394 !395 !396 !53) -!398 = (!391 !392 !90 !91 !393 !394 !395 !396) -!399 = span !6 2972 3030 -!400 = (!391 !392 !90 !91 !393 !394 !395 !396 !399) -!401 = (!391 !392 !90 !91 !393 !394 !395 !396) -!402 = (!391 !392 !90 !91 !393 !394 !395 !396) -!403 = (!391 !392 !90 !91 !393 !394 !395 !396) -!404 = span !6 3039 3079 -!405 = (!391 !392 !90 !91 !393 !394 !395 !396 !404) -!406 = span !6 3089 3090 -!407 = (!391 !392 !90 !91 !393 !394 !395 !396 !406) -!408 = (!391 !392 !90 !91 !92) -!409 = (!391 !392 !90 !91 !92) -!410 = span !0 2010 2058 -!411 = span !0 2124 2128 -!412 = span !0 2129 2130 -!413 = span !0 2099 2131 -!414 = fn_call_path_span !0 2099 2123 -!415 = (!413 !414) -!416 = span !101 3540 3541 -!417 = (!413 !414 !416) -!418 = span !0 2079 2132 -!419 = span !0 2173 2180 -!420 = span !0 2158 2181 -!421 = fn_call_path_span !0 2158 2164 -!422 = (!420 !421) -!423 = (!420 !421 !109) -!424 = (!420 !421 !111 !112) -!425 = (!420 !421 !111 !112) -!426 = span !6 4411 4417 -!427 = (!420 !421 !111 !112 !426) -!428 = span !6 87 114 -!429 = (!420 !421 !111 !112 !428) -!430 = (!420 !421 !111 !112) -!431 = (!420 !421 !111 !112) -!432 = (!420 !421 !111 !112) -!433 = (!420 !421 !111 !112) -!434 = (!420 !421 !111 !112) -!435 = (!420 !421 !111 !112) -!436 = (!420 !421 !111 !112) -!437 = span !6 4426 4430 -!438 = (!420 !421 !111 !112 !437) -!439 = (!420 !421 !111 !112) -!440 = (!420 !421 !111 !112) -!441 = (!420 !421 !111 !112) -!442 = (!420 !421 !111 !112) -!443 = (!420 !421 !111 !112) -!444 = (!420 !421 !111 !112) -!445 = (!420 !421 !111 !112) -!446 = (!420 !421 !111 !112) -!447 = (!420 !421 !111 !112) -!448 = (!420 !421 !111 !112) -!449 = (!420 !421 !111 !112) -!450 = (!420 !421 !111 !112) -!451 = (!420 !421 !111 !112) -!452 = (!420 !421 !111 !112) -!453 = span !6 4359 4442 -!454 = (!420 !421 !111 !112 !453) -!455 = (!420 !421 !111 !112) -!456 = (!420 !421 !141) -!457 = (!420 !421 !143) -!458 = span !0 2133 2182 -!459 = span !0 2218 2225 -!460 = span !0 2218 2231 -!461 = fn_call_path_span !0 2226 2229 -!462 = (!460 !461) -!463 = (!460 !461 !69) -!464 = (!460 !461 !71 !72) -!465 = (!460 !461 !71 !72 !74) -!466 = (!460 !461 !76) -!467 = span !0 2233 2240 -!468 = span !0 2203 2253 -!469 = (!420 !421 !111 !112) -!470 = (!420 !421 !111 !112) -!471 = (!420 !421 !111 !112) -!472 = (!420 !421 !111 !112) -!473 = span !0 2260 2272 -!474 = span !0 2276 2285 -!475 = span !0 2260 2285 -!476 = span !0 2308 2315 -!477 = span !0 2308 2335 -!478 = fn_call_path_span !0 2316 2322 -!479 = span !6 72847 72866 -!480 = fn_call_path_span !6 72854 72858 -!481 = (!477 !478 !90 !91 !393 !394 !479 !480) -!482 = span !6 72881 72882 -!483 = span !6 72881 72892 -!484 = fn_call_path_span !6 72881 72892 -!485 = (!477 !478 !90 !91 !393 !394 !483 !484) -!486 = span !6 72886 72891 -!487 = (!477 !478 !90 !91 !393 !394 !483) -!488 = span !6 72905 72906 -!489 = span !6 72905 72915 -!490 = fn_call_path_span !6 72905 72915 -!491 = (!477 !478 !90 !91 !393 !394 !489 !490) -!492 = span !6 72910 72914 -!493 = (!477 !478 !90 !91 !393 !394 !489) -!494 = span !6 72942 72943 -!495 = span !6 72933 72944 -!496 = (!477 !478 !90 !91 !393 !394 !495) -!497 = (!477 !478 !90 !91 !92) -!498 = (!477 !478 !90 !91 !92) -!499 = (!477 !478 !90 !91 !92) -!500 = span !0 2288 2336 -!501 = span !0 2402 2406 -!502 = span !0 2407 2408 -!503 = span !0 2436 2459 -!504 = fn_call_path_span !0 2436 2442 -!505 = (!503 !504 !111 !112) -!506 = span !6 4213 4219 -!507 = (!503 !504 !111 !112 !506) -!508 = (!503 !504 !111 !112 !428) -!509 = (!503 !504 !111 !112) -!510 = (!503 !504 !111 !112) -!511 = (!503 !504 !111 !112) -!512 = (!503 !504 !111 !112) -!513 = (!503 !504 !111 !112) -!514 = (!503 !504 !111 !112) -!515 = (!503 !504 !111 !112) -!516 = (!503 !504 !111 !112) -!517 = (!503 !504 !111 !112) -!518 = (!503 !504 !111 !112) -!519 = (!503 !504 !111 !112) -!520 = (!503 !504 !111 !112) -!521 = (!503 !504 !111 !112) -!522 = (!503 !504 !111 !112) -!523 = (!503 !504 !111 !112) -!524 = (!503 !504 !111 !112) -!525 = (!503 !504 !111 !112) -!526 = (!503 !504 !111 !112) -!527 = (!503 !504 !111 !112) -!528 = (!503 !504 !111 !112) -!529 = span !6 4161 4244 -!530 = (!503 !504 !111 !112 !529) -!531 = (!503 !504 !111 !112) -!532 = (!503 !504 !141) -!533 = (!503 !504 !143) -!534 = span !0 2411 2460 -!535 = span !0 2496 2503 -!536 = span !0 2496 2509 -!537 = fn_call_path_span !0 2504 2507 -!538 = (!536 !537) -!539 = (!536 !537 !69) -!540 = (!536 !537 !71 !72) -!541 = (!536 !537 !71 !72 !74) -!542 = (!536 !537 !76) -!543 = span !0 2511 2518 -!544 = span !0 2481 2531 -!545 = (!503 !504 !111 !112) -!546 = (!503 !504 !111 !112) -!547 = (!503 !504 !111 !112) -!548 = (!503 !504 !111 !112) -!549 = span !0 2538 2550 -!550 = span !0 2554 2567 -!551 = span !0 2538 2567 -!552 = span !0 2593 2600 -!553 = span !0 2593 2623 -!554 = fn_call_path_span !0 2601 2607 -!555 = span !0 245 267 -!556 = fn_call_path_span !0 252 258 -!557 = span !6 71904 71932 -!558 = fn_call_path_span !6 71911 71923 -!559 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558 !53) -!560 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558) -!561 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558 !56) -!562 = (!553 !554 !90 !91 !393 !394 !555 !556 !90 !91 !557 !558 !59) -!563 = span !0 285 286 -!564 = span !0 285 318 -!565 = fn_call_path_span !0 285 318 -!566 = (!553 !554 !90 !91 !393 !394 !564 !565) -!567 = (!553 !554 !90 !91 !393 !394 !564) -!568 = span !101 274 293 -!569 = (!553 !554 !90 !91 !393 !394 !568) -!570 = (!553 !554 !90 !91 !393 !394 !568) -!571 = (!553 !554 !90 !91 !393 !394 !568) -!572 = span !0 296 316 -!573 = fn_call_path_span !0 303 309 -!574 = (!553 !554 !90 !91 !393 !394 !572 !573 !90 !91 !557 !558) -!575 = (!553 !554 !90 !91 !393 !394 !572 !573 !90 !91 !557 !558 !56) -!576 = (!553 !554 !90 !91 !393 !394 !572 !573 !90 !91 !557 !558 !59) -!577 = (!553 !554 !90 !91 !393 !394 !568) -!578 = (!553 !554 !90 !91 !393 !394 !568) -!579 = (!553 !554 !90 !91 !92) -!580 = (!553 !554 !90 !91 !92) -!581 = span !0 2570 2624 -!582 = span !0 2697 2701 -!583 = span !0 2702 2703 -!584 = span !0 2668 2704 -!585 = fn_call_path_span !0 2668 2696 -!586 = (!584 !585) -!587 = span !101 5528 5529 -!588 = (!584 !585 !587) -!589 = span !0 2645 2705 -!590 = span !0 2749 2756 -!591 = span !0 2731 2757 -!592 = fn_call_path_span !0 2731 2737 -!593 = (!591 !592) -!594 = (!591 !592 !109) -!595 = (!591 !592 !111 !112) -!596 = (!591 !592 !111 !112) -!597 = span !0 239 243 -!598 = (!591 !592 !111 !112 !597) -!599 = span !0 233 446 -!600 = (!591 !592 !111 !112 !599) -!601 = (!591 !592 !111 !112 !597) -!602 = (!591 !592 !111 !112 !597) -!603 = (!591 !592 !111 !112) -!604 = span !0 246 442 -!605 = fn_call_path_span !0 246 442 -!606 = (!591 !592 !111 !112 !604 !605) -!607 = (!591 !592 !111 !112 !604) -!608 = span !0 335 336 -!609 = span !0 326 337 -!610 = (!553 !554 !90 !91 !393 !394 !609) -!611 = (!591 !592 !111 !112 !597) -!612 = (!591 !592 !111 !112) -!613 = (!591 !592 !111 !112) -!614 = span !0 317 323 -!615 = (!591 !592 !111 !112 !614) -!616 = span !0 301 305 -!617 = span !0 288 325 -!618 = (!591 !592 !111 !112 !617) -!619 = span !0 380 386 -!620 = (!591 !592 !111 !112 !619) -!621 = span !0 350 388 -!622 = (!591 !592 !111 !112 !621) -!623 = span !0 413 419 -!624 = (!591 !592 !111 !112 !623) -!625 = span !0 220 447 -!626 = (!591 !592 !111 !112 !625) -!627 = span !0 468 474 -!628 = (!591 !592 !111 !112 !627) -!629 = (!591 !592 !141) -!630 = (!591 !592 !143) -!631 = span !0 2706 2758 -!632 = span !0 2794 2801 -!633 = span !0 2794 2807 -!634 = fn_call_path_span !0 2802 2805 -!635 = (!633 !634) -!636 = (!633 !634 !69) -!637 = (!633 !634 !71 !72) -!638 = (!633 !634 !71 !72 !74) -!639 = (!633 !634 !76) -!640 = span !0 2809 2816 -!641 = span !0 2779 2829 -!642 = (!591 !592 !111 !112 !599) -!643 = span !0 2836 2848 -!644 = span !0 2852 2869 -!645 = span !0 2836 2869 -!646 = span !0 2900 2907 -!647 = span !0 2900 2935 -!648 = fn_call_path_span !0 2908 2914 -!649 = span !0 265 287 -!650 = fn_call_path_span !0 272 278 -!651 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558 !53) -!652 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558) -!653 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558 !56) -!654 = (!647 !648 !90 !91 !393 !394 !649 !650 !90 !91 !557 !558 !59) -!655 = span !0 305 306 -!656 = span !0 305 338 -!657 = fn_call_path_span !0 305 338 -!658 = (!647 !648 !90 !91 !393 !394 !656 !657) -!659 = (!647 !648 !90 !91 !393 !394 !656) -!660 = span !101 294 322 -!661 = (!647 !648 !90 !91 !393 !394 !660) -!662 = (!647 !648 !90 !91 !393 !394 !660) -!663 = (!647 !648 !90 !91 !393 !394 !660) -!664 = span !0 316 336 -!665 = fn_call_path_span !0 323 329 -!666 = (!647 !648 !90 !91 !393 !394 !664 !665 !90 !91 !557 !558) -!667 = (!647 !648 !90 !91 !393 !394 !664 !665 !90 !91 !557 !558 !56) -!668 = (!647 !648 !90 !91 !393 !394 !664 !665 !90 !91 !557 !558 !59) -!669 = (!647 !648 !90 !91 !393 !394 !660) -!670 = (!647 !648 !90 !91 !393 !394 !660) -!671 = (!647 !648 !90 !91 !393 !394) -!672 = span !0 340 341 -!673 = span !0 340 373 -!674 = fn_call_path_span !0 340 373 -!675 = (!647 !648 !90 !91 !393 !394 !673 !674) -!676 = (!647 !648 !90 !91 !393 !394 !673) -!677 = (!647 !648 !90 !91 !393 !394 !660) -!678 = (!647 !648 !90 !91 !393 !394 !660) -!679 = (!647 !648 !90 !91 !393 !394 !660) -!680 = span !0 351 371 -!681 = (!647 !648 !90 !91 !393 !394 !680 !107 !90 !91 !557 !558) -!682 = (!647 !648 !90 !91 !393 !394 !680 !107 !90 !91 !557 !558 !56) -!683 = (!647 !648 !90 !91 !393 !394 !680 !107 !90 !91 !557 !558 !59) -!684 = (!647 !648 !90 !91 !393 !394 !660) -!685 = (!647 !648 !90 !91 !393 !394 !660) -!686 = (!647 !648 !90 !91 !393 !394) -!687 = span !0 390 391 -!688 = span !0 381 392 -!689 = (!647 !648 !90 !91 !393 !394 !688) -!690 = (!647 !648 !90 !91 !92) -!691 = (!647 !648 !90 !91 !92) -!692 = span !0 2872 2936 -!693 = span !0 3018 3022 -!694 = span !0 3023 3024 -!695 = span !0 2985 3025 -!696 = fn_call_path_span !0 2985 3017 -!697 = (!695 !696) -!698 = span !101 5643 5644 -!699 = (!695 !696 !698) -!700 = span !0 2957 3026 -!701 = span !0 3075 3082 -!702 = span !0 3052 3083 -!703 = fn_call_path_span !0 3052 3058 -!704 = (!702 !703) -!705 = (!702 !703 !109) -!706 = (!702 !703 !111 !112) -!707 = (!702 !703 !111 !112) -!708 = span !0 259 263 -!709 = (!702 !703 !111 !112 !708) -!710 = span !0 253 664 -!711 = (!702 !703 !111 !112 !710) -!712 = (!702 !703 !111 !112 !708) -!713 = (!702 !703 !111 !112 !708) -!714 = (!702 !703 !111 !112) -!715 = span !0 266 462 -!716 = fn_call_path_span !0 266 462 -!717 = (!702 !703 !111 !112 !715 !716) -!718 = (!702 !703 !111 !112 !715) -!719 = (!702 !703 !111 !112 !708) -!720 = (!702 !703 !111 !112) -!721 = (!702 !703 !111 !112) -!722 = span !0 337 343 -!723 = (!702 !703 !111 !112 !722) -!724 = span !0 321 325 -!725 = span !0 308 345 -!726 = (!702 !703 !111 !112 !725) -!727 = span !0 400 406 -!728 = (!702 !703 !111 !112 !727) -!729 = span !0 370 408 -!730 = (!702 !703 !111 !112 !729) -!731 = span !0 433 439 -!732 = (!702 !703 !111 !112 !731) -!733 = (!702 !703 !111 !112) -!734 = (!702 !703 !111 !112 !708) -!735 = (!702 !703 !111 !112 !708) -!736 = (!702 !703 !111 !112) -!737 = span !0 464 660 -!738 = fn_call_path_span !0 464 660 -!739 = (!702 !703 !111 !112 !737 !738) -!740 = (!702 !703 !111 !112 !737) -!741 = (!702 !703 !111 !112 !708) -!742 = (!702 !703 !111 !112) -!743 = (!702 !703 !111 !112) -!744 = span !0 535 541 -!745 = (!702 !703 !111 !112 !744) -!746 = span !0 519 523 -!747 = span !0 506 543 -!748 = (!702 !703 !111 !112 !747) -!749 = span !0 598 604 -!750 = (!702 !703 !111 !112 !749) -!751 = span !0 568 606 -!752 = (!702 !703 !111 !112 !751) -!753 = span !0 631 637 -!754 = (!702 !703 !111 !112 !753) -!755 = (!702 !703 !111 !112) -!756 = (!702 !703 !111 !112 !710) -!757 = span !0 240 665 -!758 = (!702 !703 !111 !112 !757) -!759 = span !0 686 692 -!760 = (!702 !703 !111 !112 !759) -!761 = (!702 !703 !141) -!762 = (!702 !703 !143) -!763 = span !0 3027 3084 -!764 = span !0 3120 3127 -!765 = span !0 3120 3133 -!766 = fn_call_path_span !0 3128 3131 -!767 = (!765 !766) -!768 = (!765 !766 !69) -!769 = (!765 !766 !71 !72) -!770 = (!765 !766 !71 !72 !74) -!771 = (!765 !766 !76) -!772 = span !0 3135 3142 -!773 = span !0 3105 3155 -!774 = span !0 3162 3174 -!775 = span !0 3178 3199 -!776 = span !0 3162 3199 -!777 = span !0 3235 3242 -!778 = span !0 3235 3275 -!779 = fn_call_path_span !0 3243 3249 -!780 = span !0 285 307 -!781 = fn_call_path_span !0 292 298 -!782 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558 !53) -!783 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558) -!784 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558 !56) -!785 = (!778 !779 !90 !91 !393 !394 !780 !781 !90 !91 !557 !558 !59) -!786 = span !0 325 326 -!787 = span !0 325 358 -!788 = fn_call_path_span !0 325 358 -!789 = (!778 !779 !90 !91 !393 !394 !787 !788) -!790 = (!778 !779 !90 !91 !393 !394 !787) -!791 = span !101 323 360 -!792 = (!778 !779 !90 !91 !393 !394 !791) -!793 = (!778 !779 !90 !91 !393 !394 !791) -!794 = (!778 !779 !90 !91 !393 !394 !791) -!795 = span !0 336 356 -!796 = fn_call_path_span !0 343 349 -!797 = (!778 !779 !90 !91 !393 !394 !795 !796 !90 !91 !557 !558) -!798 = (!778 !779 !90 !91 !393 !394 !795 !796 !90 !91 !557 !558 !56) -!799 = (!778 !779 !90 !91 !393 !394 !795 !796 !90 !91 !557 !558 !59) -!800 = (!778 !779 !90 !91 !393 !394 !791) -!801 = (!778 !779 !90 !91 !393 !394 !791) -!802 = (!778 !779 !90 !91 !393 !394) -!803 = span !0 360 361 -!804 = span !0 360 393 -!805 = fn_call_path_span !0 360 393 -!806 = (!778 !779 !90 !91 !393 !394 !804 !805) -!807 = (!778 !779 !90 !91 !393 !394 !804) -!808 = (!778 !779 !90 !91 !393 !394 !791) -!809 = (!778 !779 !90 !91 !393 !394 !791) -!810 = (!778 !779 !90 !91 !393 !394 !791) -!811 = span !0 371 391 -!812 = fn_call_path_span !0 378 384 -!813 = (!778 !779 !90 !91 !393 !394 !811 !812 !90 !91 !557 !558) -!814 = (!778 !779 !90 !91 !393 !394 !811 !812 !90 !91 !557 !558 !56) -!815 = (!778 !779 !90 !91 !393 !394 !811 !812 !90 !91 !557 !558 !59) -!816 = (!778 !779 !90 !91 !393 !394 !791) -!817 = (!778 !779 !90 !91 !393 !394 !791) -!818 = (!778 !779 !90 !91 !393 !394) -!819 = span !0 395 396 -!820 = span !0 395 428 -!821 = fn_call_path_span !0 395 428 -!822 = (!778 !779 !90 !91 !393 !394 !820 !821) -!823 = (!778 !779 !90 !91 !393 !394 !820) -!824 = (!778 !779 !90 !91 !393 !394 !791) -!825 = (!778 !779 !90 !91 !393 !394 !791) -!826 = (!778 !779 !90 !91 !393 !394 !791) -!827 = span !0 406 426 -!828 = fn_call_path_span !0 413 419 -!829 = (!778 !779 !90 !91 !393 !394 !827 !828 !90 !91 !557 !558) -!830 = (!778 !779 !90 !91 !393 !394 !827 !828 !90 !91 !557 !558 !56) -!831 = (!778 !779 !90 !91 !393 !394 !827 !828 !90 !91 !557 !558 !59) -!832 = (!778 !779 !90 !91 !393 !394 !791) -!833 = (!778 !779 !90 !91 !393 !394 !791) -!834 = (!778 !779 !90 !91 !393 !394) -!835 = span !0 445 446 -!836 = span !0 436 447 -!837 = (!778 !779 !90 !91 !393 !394 !836) -!838 = (!778 !779 !90 !91 !393 !394) -!839 = (!778 !779 !90 !91 !92) -!840 = (!778 !779 !90 !91 !92) -!841 = span !0 3202 3276 -!842 = span !0 3367 3371 -!843 = span !0 3372 3373 -!844 = span !0 3330 3374 -!845 = fn_call_path_span !0 3330 3366 -!846 = (!844 !845) -!847 = span !101 5780 5781 -!848 = (!844 !845 !847) -!849 = span !0 3297 3375 -!850 = span !0 3429 3436 -!851 = span !0 3401 3437 -!852 = fn_call_path_span !0 3401 3407 -!853 = (!851 !852) -!854 = (!851 !852 !109) -!855 = (!851 !852 !111 !112) -!856 = (!851 !852 !111 !112) -!857 = span !0 279 283 -!858 = (!851 !852 !111 !112 !857) -!859 = span !0 273 882 -!860 = (!851 !852 !111 !112 !859) -!861 = (!851 !852 !111 !112 !857) -!862 = (!851 !852 !111 !112 !857) -!863 = (!851 !852 !111 !112) -!864 = span !0 286 482 -!865 = fn_call_path_span !0 286 482 -!866 = (!851 !852 !111 !112 !864 !865) -!867 = (!851 !852 !111 !112 !864) -!868 = (!851 !852 !111 !112 !857) -!869 = (!851 !852 !111 !112) -!870 = (!851 !852 !111 !112) -!871 = span !0 357 363 -!872 = (!851 !852 !111 !112 !871) -!873 = span !0 341 345 -!874 = span !0 328 365 -!875 = (!851 !852 !111 !112 !874) -!876 = span !0 420 426 -!877 = (!851 !852 !111 !112 !876) -!878 = span !0 390 428 -!879 = (!851 !852 !111 !112 !878) -!880 = span !0 453 459 -!881 = (!851 !852 !111 !112 !880) -!882 = (!851 !852 !111 !112) -!883 = (!851 !852 !111 !112 !857) -!884 = (!851 !852 !111 !112 !857) -!885 = (!851 !852 !111 !112) -!886 = span !0 484 680 -!887 = fn_call_path_span !0 484 680 -!888 = (!851 !852 !111 !112 !886 !887) -!889 = (!851 !852 !111 !112 !886) -!890 = (!851 !852 !111 !112 !857) -!891 = (!851 !852 !111 !112) -!892 = (!851 !852 !111 !112) -!893 = span !0 555 561 -!894 = (!851 !852 !111 !112 !893) -!895 = span !0 539 543 -!896 = span !0 526 563 -!897 = (!851 !852 !111 !112 !896) -!898 = span !0 618 624 -!899 = (!851 !852 !111 !112 !898) -!900 = span !0 588 626 -!901 = (!851 !852 !111 !112 !900) -!902 = span !0 651 657 -!903 = (!851 !852 !111 !112 !902) -!904 = (!851 !852 !111 !112) -!905 = (!851 !852 !111 !112 !857) -!906 = (!851 !852 !111 !112 !857) -!907 = (!851 !852 !111 !112) -!908 = span !0 682 878 -!909 = fn_call_path_span !0 682 878 -!910 = (!851 !852 !111 !112 !908 !909) -!911 = (!851 !852 !111 !112 !908) -!912 = (!851 !852 !111 !112 !857) -!913 = (!851 !852 !111 !112) -!914 = (!851 !852 !111 !112) -!915 = span !0 753 759 -!916 = (!851 !852 !111 !112 !915) -!917 = span !0 737 741 -!918 = span !0 724 761 -!919 = (!851 !852 !111 !112 !918) -!920 = span !0 816 822 -!921 = (!851 !852 !111 !112 !920) -!922 = span !0 786 824 -!923 = (!851 !852 !111 !112 !922) -!924 = span !0 849 855 -!925 = (!851 !852 !111 !112 !924) -!926 = (!851 !852 !111 !112) -!927 = (!851 !852 !111 !112 !859) -!928 = (!851 !852 !111 !112) -!929 = span !0 260 883 -!930 = (!851 !852 !111 !112 !929) -!931 = span !0 904 910 -!932 = (!851 !852 !111 !112 !931) -!933 = (!851 !852 !141) -!934 = (!851 !852 !143) -!935 = span !0 3376 3438 -!936 = span !0 3474 3481 -!937 = span !0 3474 3487 -!938 = fn_call_path_span !0 3482 3485 -!939 = (!937 !938) -!940 = (!937 !938 !69) -!941 = (!937 !938 !71 !72) -!942 = (!937 !938 !71 !72 !74) -!943 = (!937 !938 !76) -!944 = span !0 3489 3496 -!945 = span !0 3459 3509 -!946 = span !0 3516 3528 -!947 = span !0 3532 3542 -!948 = span !0 3516 3542 -!949 = span !0 3567 3574 -!950 = span !0 3567 3596 -!951 = fn_call_path_span !0 3575 3581 -!952 = span !6 73547 73579 -!953 = (!950 !951 !90 !91 !393 !394 !952) -!954 = span !6 73595 73599 -!955 = (!950 !951 !90 !91 !393 !394 !954) -!956 = span !6 73595 73605 -!957 = fn_call_path_span !6 73600 73603 -!958 = (!950 !951 !90 !91 !393 !394 !956 !957) -!959 = (!950 !951 !90 !91 !393 !394 !956 !957 !69) -!960 = (!950 !951 !90 !91 !393 !394 !956 !957 !71 !72) -!961 = (!950 !951 !90 !91 !393 !394 !956 !957 !71 !72 !74) -!962 = (!950 !951 !90 !91 !393 !394 !956 !957 !76) -!963 = (!950 !951 !90 !91 !92) -!964 = (!950 !951 !90 !91 !92) -!965 = span !0 3545 3597 -!966 = span !0 3666 3670 -!967 = span !0 3671 3672 -!968 = span !0 3640 3673 -!969 = fn_call_path_span !0 3640 3665 -!970 = (!968 !969) -!971 = span !101 3624 3625 -!972 = (!968 !969 !971) -!973 = span !0 3618 3674 -!974 = span !0 3717 3724 -!975 = span !0 3700 3725 -!976 = fn_call_path_span !0 3700 3706 -!977 = (!975 !976) -!978 = (!975 !976 !109) -!979 = (!975 !976 !111 !112) -!980 = (!975 !976 !111 !112) -!981 = span !6 5753 5759 -!982 = (!975 !976 !111 !112 !981) -!983 = (!975 !976 !111 !112 !428) -!984 = (!975 !976 !111 !112) -!985 = (!975 !976 !111 !112) -!986 = (!975 !976 !111 !112) -!987 = (!975 !976 !111 !112) -!988 = (!975 !976 !111 !112) -!989 = (!975 !976 !111 !112) -!990 = (!975 !976 !111 !112) -!991 = span !6 5768 5772 -!992 = (!975 !976 !111 !112 !991) -!993 = (!975 !976 !111 !112) -!994 = (!975 !976 !111 !112) -!995 = (!975 !976 !111 !112) -!996 = (!975 !976 !111 !112) -!997 = (!975 !976 !111 !112) -!998 = (!975 !976 !111 !112) -!999 = (!975 !976 !111 !112) -!1000 = (!975 !976 !111 !112) -!1001 = (!975 !976 !111 !112) -!1002 = (!975 !976 !111 !112) -!1003 = (!975 !976 !111 !112) -!1004 = (!975 !976 !111 !112) -!1005 = (!975 !976 !111 !112) -!1006 = span !6 5701 5784 -!1007 = (!975 !976 !111 !112 !1006) -!1008 = (!975 !976 !111 !112) -!1009 = (!975 !976 !141) -!1010 = (!975 !976 !143) -!1011 = span !0 3675 3726 -!1012 = span !0 3762 3769 -!1013 = span !0 3762 3775 -!1014 = fn_call_path_span !0 3770 3773 -!1015 = (!1013 !1014) -!1016 = (!1013 !1014 !69) -!1017 = (!1013 !1014 !71 !72) -!1018 = (!1013 !1014 !71 !72 !74) -!1019 = (!1013 !1014 !76) -!1020 = span !0 3777 3784 -!1021 = span !0 3747 3797 -!1022 = (!975 !976 !111 !112) -!1023 = (!975 !976 !111 !112) -!1024 = (!975 !976 !111 !112) -!1025 = span !0 3804 3816 -!1026 = span !0 3820 3830 -!1027 = span !0 3804 3830 -!1028 = span !0 3855 3862 -!1029 = span !0 3855 3884 -!1030 = fn_call_path_span !0 3863 3869 -!1031 = (!1029 !1030 !90 !91 !393 !394 !952) -!1032 = (!1029 !1030 !90 !91 !393 !394 !954) -!1033 = (!1029 !1030 !90 !91 !393 !394 !956 !957) -!1034 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !69) -!1035 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !71 !72) -!1036 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !71 !72 !74) -!1037 = (!1029 !1030 !90 !91 !393 !394 !956 !957 !76) -!1038 = (!1029 !1030 !90 !91 !92) -!1039 = (!1029 !1030 !90 !91 !92) -!1040 = span !0 3833 3885 -!1041 = span !0 3954 3958 -!1042 = span !0 3959 3960 -!1043 = span !0 3928 3961 -!1044 = fn_call_path_span !0 3928 3953 -!1045 = (!1043 !1044) -!1046 = span !101 3708 3709 -!1047 = (!1043 !1044 !1046) -!1048 = span !0 3906 3962 -!1049 = span !0 4005 4012 -!1050 = span !0 3988 4013 -!1051 = fn_call_path_span !0 3988 3994 -!1052 = (!1050 !1051) -!1053 = (!1050 !1051 !109) -!1054 = (!1050 !1051 !111 !112) -!1055 = (!1050 !1051 !111 !112) -!1056 = (!1050 !1051 !111 !112 !981) -!1057 = (!1050 !1051 !111 !112 !428) -!1058 = (!1050 !1051 !111 !112) -!1059 = (!1050 !1051 !111 !112) -!1060 = (!1050 !1051 !111 !112) -!1061 = (!1050 !1051 !111 !112) -!1062 = (!1050 !1051 !111 !112) -!1063 = (!1050 !1051 !111 !112) -!1064 = (!1050 !1051 !111 !112) -!1065 = (!1050 !1051 !111 !112 !991) -!1066 = (!1050 !1051 !111 !112) -!1067 = (!1050 !1051 !111 !112) -!1068 = (!1050 !1051 !111 !112) -!1069 = (!1050 !1051 !111 !112) -!1070 = (!1050 !1051 !111 !112) -!1071 = (!1050 !1051 !111 !112) -!1072 = (!1050 !1051 !111 !112) -!1073 = (!1050 !1051 !111 !112) -!1074 = (!1050 !1051 !111 !112) -!1075 = (!1050 !1051 !111 !112) -!1076 = (!1050 !1051 !111 !112) -!1077 = (!1050 !1051 !111 !112) -!1078 = (!1050 !1051 !111 !112) -!1079 = (!1050 !1051 !111 !112) -!1080 = (!1050 !1051 !111 !112 !1006) -!1081 = (!1050 !1051 !111 !112) -!1082 = (!1050 !1051 !141) -!1083 = (!1050 !1051 !143) -!1084 = span !0 3963 4014 -!1085 = span !0 4050 4057 -!1086 = span !0 4050 4063 -!1087 = fn_call_path_span !0 4058 4061 -!1088 = (!1086 !1087) -!1089 = (!1086 !1087 !69) -!1090 = (!1086 !1087 !71 !72) -!1091 = (!1086 !1087 !71 !72 !74) -!1092 = (!1086 !1087 !76) -!1093 = span !0 4065 4072 -!1094 = span !0 4035 4085 -!1095 = (!1050 !1051 !111 !112) -!1096 = (!1050 !1051 !111 !112) -!1097 = (!1050 !1051 !111 !112) -!1098 = (!1050 !1051 !111 !112) -!1099 = span !0 4092 4104 -!1100 = span !0 4108 4119 -!1101 = span !0 4092 4119 -!1102 = span !0 4145 4152 -!1103 = span !0 4145 4175 -!1104 = fn_call_path_span !0 4153 4159 -!1105 = (!1103 !1104 !90 !91 !393 !394 !952) -!1106 = (!1103 !1104 !90 !91 !393 !394 !954) -!1107 = (!1103 !1104 !90 !91 !393 !394 !956 !957) -!1108 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !69) -!1109 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !71 !72) -!1110 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !71 !72 !74) -!1111 = (!1103 !1104 !90 !91 !393 !394 !956 !957 !76) -!1112 = (!1103 !1104 !90 !91 !92) -!1113 = (!1103 !1104 !90 !91 !92) -!1114 = span !0 4122 4176 -!1115 = span !0 4247 4251 -!1116 = span !0 4252 4253 -!1117 = span !0 4220 4254 -!1118 = fn_call_path_span !0 4220 4246 -!1119 = (!1117 !1118) -!1120 = span !101 3880 3881 -!1121 = (!1117 !1118 !1120) -!1122 = span !0 4197 4255 -!1123 = span !0 4299 4306 -!1124 = span !0 4281 4307 -!1125 = fn_call_path_span !0 4281 4287 -!1126 = (!1124 !1125) -!1127 = (!1124 !1125 !109) -!1128 = (!1124 !1125 !111 !112) -!1129 = (!1124 !1125 !111 !112) -!1130 = (!1124 !1125 !111 !112 !981) -!1131 = (!1124 !1125 !111 !112 !428) -!1132 = (!1124 !1125 !111 !112) -!1133 = (!1124 !1125 !111 !112) -!1134 = (!1124 !1125 !111 !112) -!1135 = (!1124 !1125 !111 !112) -!1136 = (!1124 !1125 !111 !112) -!1137 = (!1124 !1125 !111 !112) -!1138 = (!1124 !1125 !111 !112) -!1139 = (!1124 !1125 !111 !112 !991) -!1140 = (!1124 !1125 !111 !112) -!1141 = (!1124 !1125 !111 !112) -!1142 = (!1124 !1125 !111 !112) -!1143 = (!1124 !1125 !111 !112) -!1144 = (!1124 !1125 !111 !112) -!1145 = (!1124 !1125 !111 !112) -!1146 = (!1124 !1125 !111 !112) -!1147 = (!1124 !1125 !111 !112) -!1148 = (!1124 !1125 !111 !112) -!1149 = (!1124 !1125 !111 !112) -!1150 = (!1124 !1125 !111 !112) -!1151 = (!1124 !1125 !111 !112) -!1152 = (!1124 !1125 !111 !112) -!1153 = (!1124 !1125 !111 !112) -!1154 = (!1124 !1125 !111 !112 !1006) -!1155 = (!1124 !1125 !111 !112) -!1156 = (!1124 !1125 !141) -!1157 = (!1124 !1125 !143) -!1158 = span !0 4256 4308 -!1159 = span !0 4344 4351 -!1160 = span !0 4344 4357 -!1161 = fn_call_path_span !0 4352 4355 -!1162 = (!1160 !1161) -!1163 = (!1160 !1161 !69) -!1164 = (!1160 !1161 !71 !72) -!1165 = (!1160 !1161 !71 !72 !74) -!1166 = (!1160 !1161 !76) -!1167 = span !0 4359 4366 -!1168 = span !0 4329 4379 -!1169 = (!1124 !1125 !111 !112) -!1170 = (!1124 !1125 !111 !112) -!1171 = (!1124 !1125 !111 !112) -!1172 = (!1124 !1125 !111 !112) -!1173 = span !0 4386 4398 -!1174 = span !0 4402 4413 -!1175 = span !0 4386 4413 -!1176 = span !0 4439 4446 -!1177 = span !0 4439 4469 -!1178 = fn_call_path_span !0 4447 4453 -!1179 = (!1177 !1178 !90 !91 !393 !394 !952) -!1180 = (!1177 !1178 !90 !91 !393 !394 !954) -!1181 = (!1177 !1178 !90 !91 !393 !394 !956 !957) -!1182 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !69) -!1183 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !71 !72) -!1184 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !71 !72 !74) -!1185 = (!1177 !1178 !90 !91 !393 !394 !956 !957 !76) -!1186 = (!1177 !1178 !90 !91 !92) -!1187 = (!1177 !1178 !90 !91 !92) -!1188 = span !0 4416 4470 -!1189 = span !0 4541 4545 -!1190 = span !0 4546 4547 -!1191 = span !0 4514 4548 -!1192 = fn_call_path_span !0 4514 4540 -!1193 = (!1191 !1192) -!1194 = span !101 3969 3970 -!1195 = (!1191 !1192 !1194) -!1196 = span !0 4491 4549 -!1197 = span !0 4593 4600 -!1198 = span !0 4575 4601 -!1199 = fn_call_path_span !0 4575 4581 -!1200 = (!1198 !1199) -!1201 = (!1198 !1199 !109) -!1202 = (!1198 !1199 !111 !112) -!1203 = (!1198 !1199 !111 !112) -!1204 = (!1198 !1199 !111 !112 !981) -!1205 = (!1198 !1199 !111 !112 !428) -!1206 = (!1198 !1199 !111 !112) -!1207 = (!1198 !1199 !111 !112) -!1208 = (!1198 !1199 !111 !112) -!1209 = (!1198 !1199 !111 !112) -!1210 = (!1198 !1199 !111 !112) -!1211 = (!1198 !1199 !111 !112) -!1212 = (!1198 !1199 !111 !112) -!1213 = (!1198 !1199 !111 !112 !991) -!1214 = (!1198 !1199 !111 !112) -!1215 = (!1198 !1199 !111 !112) -!1216 = (!1198 !1199 !111 !112) -!1217 = (!1198 !1199 !111 !112) -!1218 = (!1198 !1199 !111 !112) -!1219 = (!1198 !1199 !111 !112) -!1220 = (!1198 !1199 !111 !112) -!1221 = (!1198 !1199 !111 !112) -!1222 = (!1198 !1199 !111 !112) -!1223 = (!1198 !1199 !111 !112) -!1224 = (!1198 !1199 !111 !112) -!1225 = (!1198 !1199 !111 !112) -!1226 = (!1198 !1199 !111 !112) -!1227 = (!1198 !1199 !111 !112) -!1228 = (!1198 !1199 !111 !112 !1006) -!1229 = (!1198 !1199 !111 !112) -!1230 = (!1198 !1199 !141) -!1231 = (!1198 !1199 !143) -!1232 = span !0 4550 4602 -!1233 = span !0 4638 4645 -!1234 = span !0 4638 4651 -!1235 = fn_call_path_span !0 4646 4649 -!1236 = (!1234 !1235) -!1237 = (!1234 !1235 !69) -!1238 = (!1234 !1235 !71 !72) -!1239 = (!1234 !1235 !71 !72 !74) -!1240 = (!1234 !1235 !76) -!1241 = span !0 4653 4660 -!1242 = span !0 4623 4673 -!1243 = (!1198 !1199 !111 !112) -!1244 = (!1198 !1199 !111 !112) -!1245 = (!1198 !1199 !111 !112) -!1246 = (!1198 !1199 !111 !112) -!1247 = span !0 4680 4692 -!1248 = span !0 4696 4706 -!1249 = span !0 4680 4706 -!1250 = span !0 4731 4738 -!1251 = span !0 4731 4760 -!1252 = fn_call_path_span !0 4739 4745 -!1253 = (!1251 !1252 !90 !91 !393 !394 !952) -!1254 = (!1251 !1252 !90 !91 !393 !394 !954) -!1255 = (!1251 !1252 !90 !91 !393 !394 !956 !957) -!1256 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !69) -!1257 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !71 !72) -!1258 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !71 !72 !74) -!1259 = (!1251 !1252 !90 !91 !393 !394 !956 !957 !76) -!1260 = (!1251 !1252 !90 !91 !92) -!1261 = (!1251 !1252 !90 !91 !92) -!1262 = span !0 4709 4761 -!1263 = span !0 4830 4834 -!1264 = span !0 4835 4836 -!1265 = span !0 4804 4837 -!1266 = fn_call_path_span !0 4804 4829 -!1267 = (!1265 !1266) -!1268 = span !101 3792 3793 -!1269 = (!1265 !1266 !1268) -!1270 = span !0 4782 4838 -!1271 = span !0 4881 4888 -!1272 = span !0 4864 4889 -!1273 = fn_call_path_span !0 4864 4870 -!1274 = (!1272 !1273) -!1275 = (!1272 !1273 !109) -!1276 = (!1272 !1273 !111 !112) -!1277 = (!1272 !1273 !111 !112) -!1278 = (!1272 !1273 !111 !112 !981) -!1279 = (!1272 !1273 !111 !112 !428) -!1280 = (!1272 !1273 !111 !112) -!1281 = (!1272 !1273 !111 !112) -!1282 = (!1272 !1273 !111 !112) -!1283 = (!1272 !1273 !111 !112) -!1284 = (!1272 !1273 !111 !112) -!1285 = (!1272 !1273 !111 !112) -!1286 = (!1272 !1273 !111 !112) -!1287 = (!1272 !1273 !111 !112 !991) -!1288 = (!1272 !1273 !111 !112) -!1289 = (!1272 !1273 !111 !112) -!1290 = (!1272 !1273 !111 !112) -!1291 = (!1272 !1273 !111 !112) -!1292 = (!1272 !1273 !111 !112) -!1293 = (!1272 !1273 !111 !112) -!1294 = (!1272 !1273 !111 !112) -!1295 = (!1272 !1273 !111 !112) -!1296 = (!1272 !1273 !111 !112) -!1297 = (!1272 !1273 !111 !112) -!1298 = (!1272 !1273 !111 !112) -!1299 = (!1272 !1273 !111 !112) -!1300 = (!1272 !1273 !111 !112) -!1301 = (!1272 !1273 !111 !112) -!1302 = (!1272 !1273 !111 !112 !1006) -!1303 = (!1272 !1273 !111 !112) -!1304 = (!1272 !1273 !141) -!1305 = (!1272 !1273 !143) -!1306 = span !0 4839 4890 -!1307 = span !0 4926 4933 -!1308 = span !0 4926 4939 -!1309 = fn_call_path_span !0 4934 4937 -!1310 = (!1308 !1309) -!1311 = (!1308 !1309 !69) -!1312 = (!1308 !1309 !71 !72) -!1313 = (!1308 !1309 !71 !72 !74) -!1314 = (!1308 !1309 !76) -!1315 = span !0 4941 4948 -!1316 = span !0 4911 4961 -!1317 = (!1272 !1273 !111 !112) -!1318 = (!1272 !1273 !111 !112) -!1319 = (!1272 !1273 !111 !112) -!1320 = (!1272 !1273 !111 !112) -!1321 = span !0 4968 4980 -!1322 = span !0 4984 4999 -!1323 = span !0 4968 4999 -!1324 = span !0 5025 5032 -!1325 = span !0 5025 5055 -!1326 = fn_call_path_span !0 5033 5039 -!1327 = span !0 236 256 -!1328 = fn_call_path_span !0 243 249 -!1329 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558 !53) -!1330 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558) -!1331 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558 !56) -!1332 = (!1325 !1326 !90 !91 !393 !394 !1327 !1328 !90 !91 !557 !558 !59) -!1333 = span !0 226 259 -!1334 = (!1325 !1326 !90 !91 !393 !394 !1333) -!1335 = (!1325 !1326 !90 !91 !393 !394) -!1336 = (!1325 !1326 !90 !91 !393 !394 !1333) -!1337 = (!1325 !1326 !90 !91 !92) -!1338 = (!1325 !1326 !90 !91 !92) -!1339 = span !0 5002 5056 -!1340 = span !0 5131 5135 -!1341 = span !0 5136 5137 -!1342 = span !0 5100 5138 -!1343 = fn_call_path_span !0 5100 5130 -!1344 = (!1342 !1343) -!1345 = span !101 4730 4731 -!1346 = (!1342 !1343 !1345) -!1347 = span !0 5077 5139 -!1348 = span !0 5183 5190 -!1349 = span !0 5140 5192 -!1350 = span !0 5228 5235 -!1351 = span !0 5228 5241 -!1352 = fn_call_path_span !0 5236 5239 -!1353 = (!1351 !1352) -!1354 = (!1351 !1352 !69) -!1355 = (!1351 !1352 !71 !72) -!1356 = (!1351 !1352 !71 !72 !74) -!1357 = (!1351 !1352 !76) -!1358 = span !0 5243 5250 -!1359 = span !0 5213 5263 -!1360 = span !0 5270 5282 -!1361 = span !0 5286 5305 -!1362 = span !0 5270 5305 -!1363 = span !0 5336 5343 -!1364 = span !0 5336 5371 -!1365 = fn_call_path_span !0 5344 5350 -!1366 = span !0 256 276 -!1367 = fn_call_path_span !0 263 269 -!1368 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558 !53) -!1369 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558) -!1370 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558 !56) -!1371 = (!1364 !1365 !90 !91 !393 !394 !1366 !1367 !90 !91 !557 !558 !59) -!1372 = span !0 280 300 -!1373 = fn_call_path_span !0 287 293 -!1374 = (!1364 !1365 !90 !91 !393 !394 !1372 !1373 !90 !91 !557 !558) -!1375 = (!1364 !1365 !90 !91 !393 !394 !1372 !1373 !90 !91 !557 !558 !56) -!1376 = (!1364 !1365 !90 !91 !393 !394 !1372 !1373 !90 !91 !557 !558 !59) -!1377 = span !0 246 303 -!1378 = (!1364 !1365 !90 !91 !393 !394 !1377) -!1379 = (!1364 !1365 !90 !91 !393 !394) -!1380 = (!1364 !1365 !90 !91 !393 !394 !1377) -!1381 = (!1364 !1365 !90 !91 !393 !394) -!1382 = (!1364 !1365 !90 !91 !393 !394 !1377) -!1383 = (!1364 !1365 !90 !91 !92) -!1384 = (!1364 !1365 !90 !91 !92) -!1385 = span !0 5308 5372 -!1386 = span !0 5456 5460 -!1387 = span !0 5461 5462 -!1388 = span !0 5421 5463 -!1389 = fn_call_path_span !0 5421 5455 -!1390 = (!1388 !1389) -!1391 = span !101 5278 5279 -!1392 = (!1388 !1389 !1391) -!1393 = span !0 5393 5464 -!1394 = span !0 5513 5520 -!1395 = span !0 5465 5522 -!1396 = span !0 5558 5565 -!1397 = span !0 5558 5571 -!1398 = fn_call_path_span !0 5566 5569 -!1399 = (!1397 !1398) -!1400 = (!1397 !1398 !69) -!1401 = (!1397 !1398 !71 !72) -!1402 = (!1397 !1398 !71 !72 !74) -!1403 = (!1397 !1398 !76) -!1404 = span !0 5573 5580 -!1405 = span !0 5543 5593 -!1406 = span !0 5600 5612 -!1407 = span !0 5616 5639 -!1408 = span !0 5600 5639 -!1409 = span !0 5675 5682 -!1410 = span !0 5675 5715 -!1411 = fn_call_path_span !0 5683 5689 -!1412 = span !0 276 296 -!1413 = fn_call_path_span !0 283 289 -!1414 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558 !53) -!1415 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558) -!1416 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558 !56) -!1417 = (!1410 !1411 !90 !91 !393 !394 !1412 !1413 !90 !91 !557 !558 !59) -!1418 = span !0 300 320 -!1419 = fn_call_path_span !0 307 313 -!1420 = (!1410 !1411 !90 !91 !393 !394 !1418 !1419 !90 !91 !557 !558) -!1421 = (!1410 !1411 !90 !91 !393 !394 !1418 !1419 !90 !91 !557 !558 !56) -!1422 = (!1410 !1411 !90 !91 !393 !394 !1418 !1419 !90 !91 !557 !558 !59) -!1423 = span !0 324 344 -!1424 = fn_call_path_span !0 331 337 -!1425 = (!1410 !1411 !90 !91 !393 !394 !1423 !1424 !90 !91 !557 !558) -!1426 = (!1410 !1411 !90 !91 !393 !394 !1423 !1424 !90 !91 !557 !558 !56) -!1427 = (!1410 !1411 !90 !91 !393 !394 !1423 !1424 !90 !91 !557 !558 !59) -!1428 = span !0 266 347 -!1429 = (!1410 !1411 !90 !91 !393 !394 !1428) -!1430 = (!1410 !1411 !90 !91 !393 !394) -!1431 = (!1410 !1411 !90 !91 !393 !394 !1428) -!1432 = (!1410 !1411 !90 !91 !393 !394) -!1433 = (!1410 !1411 !90 !91 !393 !394 !1428) -!1434 = (!1410 !1411 !90 !91 !393 !394) -!1435 = (!1410 !1411 !90 !91 !393 !394 !1428) -!1436 = (!1410 !1411 !90 !91 !92) -!1437 = (!1410 !1411 !90 !91 !92) -!1438 = span !0 5642 5716 -!1439 = span !0 5809 5813 -!1440 = span !0 5814 5815 -!1441 = span !0 5770 5816 -!1442 = fn_call_path_span !0 5770 5808 -!1443 = (!1441 !1442) -!1444 = span !101 4936 4937 -!1445 = (!1441 !1442 !1444) -!1446 = span !0 5737 5817 -!1447 = span !0 5871 5878 -!1448 = span !0 5818 5880 -!1449 = span !0 5916 5923 -!1450 = span !0 5916 5929 -!1451 = fn_call_path_span !0 5924 5927 -!1452 = (!1450 !1451) -!1453 = (!1450 !1451 !69) -!1454 = (!1450 !1451 !71 !72) -!1455 = (!1450 !1451 !71 !72 !74) -!1456 = (!1450 !1451 !76) -!1457 = span !0 5931 5938 -!1458 = span !0 5901 5951 -!1459 = span !0 5958 5970 -!1460 = span !0 5974 5986 -!1461 = span !0 5958 5986 -!1462 = span !0 6007 6032 -!1463 = fn_call_path_span !0 6015 6021 -!1464 = (!1462 !1463 !90 !91 !92) -!1465 = (!1462 !1463 !90 !91 !92) -!1466 = (!1462 !1463 !90 !91 !92) -!1467 = span !0 5989 6033 -!1468 = span !0 6124 6147 -!1469 = span !0 6149 6150 -!1470 = span !0 6109 6151 -!1471 = span !0 6158 6170 -!1472 = span !0 6174 6186 -!1473 = span !0 6158 6186 -!1474 = span !0 6211 6218 -!1475 = span !0 6211 6240 -!1476 = fn_call_path_span !0 6219 6225 -!1477 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558 !53) -!1478 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558) -!1479 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558 !56) -!1480 = (!1475 !1476 !90 !91 !393 !394 !393 !394 !557 !558 !59) -!1481 = (!1475 !1476 !90 !91 !393 !394 !92) -!1482 = (!1475 !1476 !90 !91 !393 !394 !92) -!1483 = (!1475 !1476 !90 !91 !393 !394 !92) -!1484 = (!1475 !1476 !90 !91 !92) -!1485 = (!1475 !1476 !90 !91 !92) -!1486 = span !0 6189 6241 -!1487 = span !0 6312 6316 -!1488 = span !0 6317 6318 -!1489 = span !0 6284 6319 -!1490 = fn_call_path_span !0 6284 6311 -!1491 = (!1489 !1490) -!1492 = (!1489 !1490 !1345) -!1493 = span !0 6262 6320 -!1494 = span !0 6363 6370 -!1495 = span !0 6321 6372 -!1496 = span !0 6408 6415 -!1497 = span !0 6408 6421 -!1498 = fn_call_path_span !0 6416 6419 -!1499 = (!1497 !1498) -!1500 = (!1497 !1498 !69) -!1501 = (!1497 !1498 !71 !72) -!1502 = (!1497 !1498 !71 !72 !74) -!1503 = (!1497 !1498 !76) -!1504 = span !0 6423 6430 -!1505 = span !0 6393 6443 -!1506 = span !0 6450 6462 -!1507 = span !0 6466 6478 -!1508 = span !0 6450 6478 -!1509 = span !0 6507 6514 -!1510 = span !0 6507 6540 -!1511 = fn_call_path_span !0 6515 6521 -!1512 = span !6 115618 115639 -!1513 = fn_call_path_span !6 115618 115631 -!1514 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558 !53) -!1515 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558) -!1516 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558 !56) -!1517 = (!1510 !1511 !90 !91 !393 !394 !1512 !1513 !557 !558 !59) -!1518 = span !6 115641 115662 -!1519 = fn_call_path_span !6 115641 115654 -!1520 = (!1510 !1511 !90 !91 !393 !394 !1518 !1519 !557 !558) -!1521 = (!1510 !1511 !90 !91 !393 !394 !1518 !1519 !557 !558 !56) -!1522 = (!1510 !1511 !90 !91 !393 !394 !1518 !1519 !557 !558 !59) -!1523 = span !6 115617 115663 -!1524 = (!1510 !1511 !90 !91 !393 !394 !1523) -!1525 = (!1510 !1511 !90 !91 !393 !394 !1523) -!1526 = (!1510 !1511 !90 !91 !393 !394 !1523) -!1527 = (!1510 !1511 !90 !91 !393 !394 !1523) -!1528 = (!1510 !1511 !90 !91 !393 !394 !1523) -!1529 = (!1510 !1511 !90 !91 !92) -!1530 = (!1510 !1511 !90 !91 !92) -!1531 = span !0 6481 6541 -!1532 = span !0 6616 6620 -!1533 = span !0 6621 6622 -!1534 = span !0 6588 6623 -!1535 = fn_call_path_span !0 6588 6615 -!1536 = (!1534 !1535) -!1537 = (!1534 !1535 !1391) -!1538 = span !0 6562 6624 -!1539 = span !0 6671 6678 -!1540 = span !0 6625 6680 -!1541 = span !0 6716 6723 -!1542 = span !0 6716 6729 -!1543 = fn_call_path_span !0 6724 6727 -!1544 = (!1542 !1543) -!1545 = (!1542 !1543 !69) -!1546 = (!1542 !1543 !71 !72) -!1547 = (!1542 !1543 !71 !72 !74) -!1548 = (!1542 !1543 !76) -!1549 = span !0 6731 6738 -!1550 = span !0 6701 6751 -!1551 = span !0 6758 6770 -!1552 = span !0 6774 6786 -!1553 = span !0 6758 6786 -!1554 = span !0 6820 6827 -!1555 = span !0 6820 6858 -!1556 = fn_call_path_span !0 6828 6834 -!1557 = span !6 115839 115860 -!1558 = fn_call_path_span !6 115839 115852 -!1559 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558 !53) -!1560 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558) -!1561 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558 !56) -!1562 = (!1555 !1556 !90 !91 !393 !394 !1557 !1558 !557 !558 !59) -!1563 = span !6 115862 115883 -!1564 = fn_call_path_span !6 115862 115875 -!1565 = (!1555 !1556 !90 !91 !393 !394 !1563 !1564 !557 !558) -!1566 = (!1555 !1556 !90 !91 !393 !394 !1563 !1564 !557 !558 !56) -!1567 = (!1555 !1556 !90 !91 !393 !394 !1563 !1564 !557 !558 !59) -!1568 = span !6 115885 115906 -!1569 = fn_call_path_span !6 115885 115898 -!1570 = (!1555 !1556 !90 !91 !393 !394 !1568 !1569 !557 !558) -!1571 = (!1555 !1556 !90 !91 !393 !394 !1568 !1569 !557 !558 !56) -!1572 = (!1555 !1556 !90 !91 !393 !394 !1568 !1569 !557 !558 !59) -!1573 = span !6 115838 115907 -!1574 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1575 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1576 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1577 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1578 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1579 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1580 = (!1555 !1556 !90 !91 !393 !394 !1573) -!1581 = (!1555 !1556 !90 !91 !92) -!1582 = (!1555 !1556 !90 !91 !92) -!1583 = span !0 6789 6859 -!1584 = span !0 6939 6943 -!1585 = span !0 6944 6945 -!1586 = span !0 6911 6946 -!1587 = fn_call_path_span !0 6911 6938 -!1588 = (!1586 !1587) -!1589 = (!1586 !1587 !1444) -!1590 = span !0 6880 6947 -!1591 = span !0 6999 7006 -!1592 = span !0 6948 7008 -!1593 = span !0 7044 7051 -!1594 = span !0 7044 7057 -!1595 = fn_call_path_span !0 7052 7055 -!1596 = (!1594 !1595) -!1597 = (!1594 !1595 !69) -!1598 = (!1594 !1595 !71 !72) -!1599 = (!1594 !1595 !71 !72 !74) -!1600 = (!1594 !1595 !76) -!1601 = span !0 7059 7066 -!1602 = span !0 7029 7079 -!1603 = span !0 7086 7098 -!1604 = span !0 7102 7114 -!1605 = span !0 7086 7114 -!1606 = span !0 7153 7160 -!1607 = span !0 7153 7196 -!1608 = fn_call_path_span !0 7161 7167 -!1609 = span !6 116120 116141 -!1610 = fn_call_path_span !6 116120 116133 -!1611 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558 !53) -!1612 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558) -!1613 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558 !56) -!1614 = (!1607 !1608 !90 !91 !393 !394 !1609 !1610 !557 !558 !59) -!1615 = span !6 116155 116176 -!1616 = fn_call_path_span !6 116155 116168 -!1617 = (!1607 !1608 !90 !91 !393 !394 !1615 !1616 !557 !558) -!1618 = (!1607 !1608 !90 !91 !393 !394 !1615 !1616 !557 !558 !56) -!1619 = (!1607 !1608 !90 !91 !393 !394 !1615 !1616 !557 !558 !59) -!1620 = span !6 116190 116211 -!1621 = fn_call_path_span !6 116190 116203 -!1622 = (!1607 !1608 !90 !91 !393 !394 !1620 !1621 !557 !558) -!1623 = (!1607 !1608 !90 !91 !393 !394 !1620 !1621 !557 !558 !56) -!1624 = (!1607 !1608 !90 !91 !393 !394 !1620 !1621 !557 !558 !59) -!1625 = span !6 116225 116246 -!1626 = fn_call_path_span !6 116225 116238 -!1627 = (!1607 !1608 !90 !91 !393 !394 !1625 !1626 !557 !558) -!1628 = (!1607 !1608 !90 !91 !393 !394 !1625 !1626 !557 !558 !56) -!1629 = (!1607 !1608 !90 !91 !393 !394 !1625 !1626 !557 !558 !59) -!1630 = span !6 116106 116257 -!1631 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1632 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1633 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1634 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1635 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1636 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1637 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1638 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1639 = (!1607 !1608 !90 !91 !393 !394 !1630) -!1640 = (!1607 !1608 !90 !91 !92) -!1641 = (!1607 !1608 !90 !91 !92) -!1642 = span !0 7117 7197 -!1643 = span !0 7282 7286 -!1644 = span !0 7287 7288 -!1645 = span !0 7254 7289 -!1646 = fn_call_path_span !0 7254 7281 -!1647 = (!1645 !1646) -!1648 = span !101 5054 5055 -!1649 = (!1645 !1646 !1648) -!1650 = span !0 7218 7290 -!1651 = span !0 7347 7354 -!1652 = span !0 7316 7355 -!1653 = fn_call_path_span !0 7316 7322 -!1654 = (!1652 !1653) -!1655 = (!1652 !1653 !109) -!1656 = (!1652 !1653 !111 !112) -!1657 = (!1652 !1653 !111 !112) -!1658 = span !6 43600 43604 -!1659 = (!1652 !1653 !111 !112 !1658) -!1660 = span !6 43605 43606 -!1661 = (!1652 !1653 !111 !112 !1660) -!1662 = (!1652 !1653 !111 !112) -!1663 = span !6 43618 43624 -!1664 = (!1652 !1653 !111 !112 !1663) -!1665 = span !6 43587 43626 -!1666 = (!1652 !1653 !111 !112 !1665) -!1667 = span !6 43648 43652 -!1668 = (!1652 !1653 !111 !112 !1667) -!1669 = span !6 43653 43654 -!1670 = (!1652 !1653 !111 !112 !1669) -!1671 = (!1652 !1653 !111 !112) -!1672 = span !6 43666 43672 -!1673 = (!1652 !1653 !111 !112 !1672) -!1674 = span !6 43635 43674 -!1675 = (!1652 !1653 !111 !112 !1674) -!1676 = span !6 43696 43700 -!1677 = (!1652 !1653 !111 !112 !1676) -!1678 = span !6 43701 43702 -!1679 = (!1652 !1653 !111 !112 !1678) -!1680 = (!1652 !1653 !111 !112) -!1681 = span !6 43714 43720 -!1682 = (!1652 !1653 !111 !112 !1681) -!1683 = span !6 43683 43722 -!1684 = (!1652 !1653 !111 !112 !1683) -!1685 = span !6 43744 43748 -!1686 = (!1652 !1653 !111 !112 !1685) -!1687 = span !6 43749 43750 -!1688 = (!1652 !1653 !111 !112 !1687) -!1689 = (!1652 !1653 !111 !112) -!1690 = span !6 43762 43768 -!1691 = (!1652 !1653 !111 !112 !1690) -!1692 = span !6 43731 43770 -!1693 = (!1652 !1653 !111 !112 !1692) -!1694 = span !6 43779 43785 -!1695 = (!1652 !1653 !111 !112 !1694) -!1696 = (!1652 !1653 !141) -!1697 = (!1652 !1653 !143) -!1698 = span !0 7291 7356 -!1699 = span !0 7392 7399 -!1700 = span !0 7392 7405 -!1701 = fn_call_path_span !0 7400 7403 -!1702 = (!1700 !1701) -!1703 = (!1700 !1701 !69) -!1704 = (!1700 !1701 !71 !72) -!1705 = (!1700 !1701 !71 !72 !74) -!1706 = (!1700 !1701 !76) -!1707 = span !0 7407 7414 -!1708 = span !0 7377 7427 -!1709 = span !0 7434 7446 -!1710 = span !0 7450 7458 -!1711 = span !0 7434 7458 -!1712 = span !0 7480 7487 -!1713 = span !0 7480 7506 -!1714 = fn_call_path_span !0 7488 7494 -!1715 = span !6 72535 72554 -!1716 = fn_call_path_span !6 72542 72546 -!1717 = (!1713 !1714 !90 !91 !393 !394 !1715 !1716) -!1718 = span !6 72528 72555 -!1719 = fn_call_path_span !6 72528 72534 -!1720 = span !6 71980 72024 -!1721 = (!1713 !1714 !90 !91 !393 !394 !1718 !1719 !1720) -!1722 = span !6 72580 72599 -!1723 = fn_call_path_span !6 72587 72591 -!1724 = (!1713 !1714 !90 !91 !393 !394 !1722 !1723) -!1725 = span !6 72573 72600 -!1726 = fn_call_path_span !6 72573 72579 -!1727 = (!1713 !1714 !90 !91 !393 !394 !1725 !1726 !1720) -!1728 = span !6 72616 72617 -!1729 = span !6 72611 72617 -!1730 = fn_call_path_span !6 72613 72615 -!1731 = (!1713 !1714 !90 !91 !393 !394 !1729 !1730) -!1732 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/primitives.sw" -!1733 = span !1732 5415 5420 -!1734 = (!1713 !1714 !90 !91 !393 !394 !1729 !1730) -!1735 = span !6 72610 72622 -!1736 = fn_call_path_span !6 72619 72620 -!1737 = (!1713 !1714 !90 !91 !393 !394 !1735 !1736) -!1738 = (!1713 !1714 !90 !91 !92) -!1739 = (!1713 !1714 !90 !91 !92) -!1740 = (!1713 !1714 !90 !91 !92) -!1741 = span !0 7461 7507 -!1742 = span !0 7571 7575 -!1743 = span !0 7576 7577 -!1744 = span !0 7605 7627 -!1745 = fn_call_path_span !0 7605 7611 -!1746 = (!1744 !1745 !111 !112) -!1747 = span !6 5124 5130 -!1748 = (!1744 !1745 !111 !112 !1747) -!1749 = (!1744 !1745 !111 !112 !428) -!1750 = (!1744 !1745 !111 !112) -!1751 = (!1744 !1745 !111 !112) -!1752 = (!1744 !1745 !111 !112) -!1753 = (!1744 !1745 !111 !112) -!1754 = (!1744 !1745 !111 !112) -!1755 = (!1744 !1745 !111 !112) -!1756 = (!1744 !1745 !111 !112) -!1757 = (!1744 !1745 !111 !112) -!1758 = (!1744 !1745 !111 !112) -!1759 = (!1744 !1745 !111 !112) -!1760 = (!1744 !1745 !111 !112) -!1761 = (!1744 !1745 !111 !112) -!1762 = (!1744 !1745 !111 !112) -!1763 = (!1744 !1745 !111 !112) -!1764 = (!1744 !1745 !111 !112) -!1765 = (!1744 !1745 !111 !112) -!1766 = (!1744 !1745 !111 !112) -!1767 = (!1744 !1745 !111 !112) -!1768 = (!1744 !1745 !111 !112) -!1769 = (!1744 !1745 !111 !112) -!1770 = (!1744 !1745 !111 !112) -!1771 = (!1744 !1745 !111 !112) -!1772 = (!1744 !1745 !111 !112) -!1773 = span !6 5072 5155 -!1774 = (!1744 !1745 !111 !112 !1773) -!1775 = (!1744 !1745 !111 !112) -!1776 = (!1744 !1745 !141) -!1777 = (!1744 !1745 !143) -!1778 = span !0 7580 7628 -!1779 = span !0 7664 7671 -!1780 = span !0 7664 7677 -!1781 = fn_call_path_span !0 7672 7675 -!1782 = (!1780 !1781) -!1783 = (!1780 !1781 !69) -!1784 = (!1780 !1781 !71 !72) -!1785 = (!1780 !1781 !71 !72 !74) -!1786 = (!1780 !1781 !76) -!1787 = span !0 7679 7686 -!1788 = span !0 7649 7699 -!1789 = (!1744 !1745 !111 !112) -!1790 = (!1744 !1745 !111 !112) -!1791 = (!1744 !1745 !111 !112) -!1792 = (!1744 !1745 !111 !112) -!1793 = span !0 7706 7718 -!1794 = span !0 7722 7731 -!1795 = span !0 7706 7731 -!1796 = span !0 7754 7761 -!1797 = span !0 7754 7781 -!1798 = fn_call_path_span !0 7762 7768 -!1799 = span !6 71774 71804 -!1800 = fn_call_path_span !6 71781 71794 -!1801 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !53) -!1802 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) -!1803 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !399) -!1804 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) -!1805 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) -!1806 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800) -!1807 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !404) -!1808 = (!1797 !1798 !90 !91 !393 !394 !1799 !1800 !406) -!1809 = (!1797 !1798 !90 !91 !92) -!1810 = (!1797 !1798 !90 !91 !92) -!1811 = span !0 7734 7782 -!1812 = span !0 7848 7852 -!1813 = span !0 7853 7854 -!1814 = span !0 7823 7855 -!1815 = fn_call_path_span !0 7823 7847 -!1816 = (!1814 !1815) -!1817 = span !101 3461 3462 -!1818 = (!1814 !1815 !1817) -!1819 = span !0 7803 7856 -!1820 = span !0 7897 7904 -!1821 = span !0 7882 7905 -!1822 = fn_call_path_span !0 7882 7888 -!1823 = (!1821 !1822) -!1824 = (!1821 !1822 !109) -!1825 = (!1821 !1822 !111 !112) -!1826 = (!1821 !1822 !111 !112) -!1827 = span !6 4590 4596 -!1828 = (!1821 !1822 !111 !112 !1827) -!1829 = (!1821 !1822 !111 !112 !428) -!1830 = (!1821 !1822 !111 !112) -!1831 = (!1821 !1822 !111 !112) -!1832 = (!1821 !1822 !111 !112) -!1833 = (!1821 !1822 !111 !112) -!1834 = (!1821 !1822 !111 !112) -!1835 = (!1821 !1822 !111 !112) -!1836 = (!1821 !1822 !111 !112) -!1837 = span !6 4605 4609 -!1838 = (!1821 !1822 !111 !112 !1837) -!1839 = (!1821 !1822 !111 !112) -!1840 = (!1821 !1822 !111 !112) -!1841 = (!1821 !1822 !111 !112) -!1842 = (!1821 !1822 !111 !112) -!1843 = (!1821 !1822 !111 !112) -!1844 = (!1821 !1822 !111 !112) -!1845 = (!1821 !1822 !111 !112) -!1846 = (!1821 !1822 !111 !112) -!1847 = (!1821 !1822 !111 !112) -!1848 = (!1821 !1822 !111 !112) -!1849 = (!1821 !1822 !111 !112) -!1850 = (!1821 !1822 !111 !112) -!1851 = (!1821 !1822 !111 !112) -!1852 = (!1821 !1822 !111 !112) -!1853 = span !6 4538 4621 -!1854 = (!1821 !1822 !111 !112 !1853) -!1855 = (!1821 !1822 !111 !112) -!1856 = (!1821 !1822 !141) -!1857 = (!1821 !1822 !143) -!1858 = span !0 7857 7906 -!1859 = span !0 7942 7949 -!1860 = span !0 7942 7955 -!1861 = fn_call_path_span !0 7950 7953 -!1862 = (!1860 !1861) -!1863 = (!1860 !1861 !69) -!1864 = (!1860 !1861 !71 !72) -!1865 = (!1860 !1861 !71 !72 !74) -!1866 = (!1860 !1861 !76) -!1867 = span !0 7957 7964 -!1868 = span !0 7927 7977 -!1869 = (!1821 !1822 !111 !112) -!1870 = (!1821 !1822 !111 !112) -!1871 = (!1821 !1822 !111 !112) -!1872 = (!1821 !1822 !111 !112) -!1873 = span !0 7984 7996 -!1874 = span !0 8000 8008 -!1875 = span !0 7984 8008 -!1876 = span !0 8030 8037 -!1877 = span !0 8030 8056 -!1878 = fn_call_path_span !0 8038 8044 -!1879 = span !6 72219 72238 -!1880 = fn_call_path_span !6 72226 72230 -!1881 = (!1877 !1878 !90 !91 !393 !394 !1879 !1880) -!1882 = span !6 72212 72239 -!1883 = fn_call_path_span !6 72212 72218 -!1884 = (!1877 !1878 !90 !91 !393 !394 !1882 !1883 !1720) -!1885 = span !6 72264 72283 -!1886 = fn_call_path_span !6 72271 72275 -!1887 = (!1877 !1878 !90 !91 !393 !394 !1885 !1886) -!1888 = span !6 72257 72284 -!1889 = fn_call_path_span !6 72257 72263 -!1890 = (!1877 !1878 !90 !91 !393 !394 !1888 !1889 !1720) -!1891 = span !6 72309 72328 -!1892 = fn_call_path_span !6 72316 72320 -!1893 = (!1877 !1878 !90 !91 !393 !394 !1891 !1892) -!1894 = span !6 72302 72329 -!1895 = fn_call_path_span !6 72302 72308 -!1896 = (!1877 !1878 !90 !91 !393 !394 !1894 !1895 !1720) -!1897 = span !6 72354 72373 -!1898 = fn_call_path_span !6 72361 72365 -!1899 = (!1877 !1878 !90 !91 !393 !394 !1897 !1898) -!1900 = span !6 72347 72374 -!1901 = fn_call_path_span !6 72347 72353 -!1902 = (!1877 !1878 !90 !91 !393 !394 !1900 !1901 !1720) -!1903 = span !6 72390 72392 -!1904 = span !6 72385 72392 -!1905 = fn_call_path_span !6 72387 72389 -!1906 = (!1877 !1878 !90 !91 !393 !394 !1904 !1905) -!1907 = span !1732 3962 3972 -!1908 = (!1877 !1878 !90 !91 !393 !394 !1904 !1905) -!1909 = span !6 72402 72404 -!1910 = span !6 72397 72404 -!1911 = fn_call_path_span !6 72399 72401 -!1912 = (!1877 !1878 !90 !91 !393 !394 !1910 !1911) -!1913 = (!1877 !1878 !90 !91 !393 !394 !1910 !1911) -!1914 = span !6 72384 72405 -!1915 = fn_call_path_span !6 72394 72395 -!1916 = (!1877 !1878 !90 !91 !393 !394 !1914 !1915) -!1917 = span !6 72414 72415 -!1918 = span !6 72409 72415 -!1919 = fn_call_path_span !6 72411 72413 -!1920 = (!1877 !1878 !90 !91 !393 !394 !1918 !1919) -!1921 = (!1877 !1878 !90 !91 !393 !394 !1918 !1919) -!1922 = span !6 72384 72416 -!1923 = fn_call_path_span !6 72406 72407 -!1924 = (!1877 !1878 !90 !91 !393 !394 !1922 !1923) -!1925 = span !6 72384 72420 -!1926 = fn_call_path_span !6 72417 72418 -!1927 = (!1877 !1878 !90 !91 !393 !394 !1925 !1926) -!1928 = (!1877 !1878 !90 !91 !92) -!1929 = (!1877 !1878 !90 !91 !92) -!1930 = (!1877 !1878 !90 !91 !92) -!1931 = span !0 8011 8057 -!1932 = span !0 8121 8125 -!1933 = span !0 8126 8127 -!1934 = span !0 8155 8177 -!1935 = fn_call_path_span !0 8155 8161 -!1936 = (!1934 !1935 !111 !112) -!1937 = span !6 4946 4952 -!1938 = (!1934 !1935 !111 !112 !1937) -!1939 = (!1934 !1935 !111 !112 !428) -!1940 = (!1934 !1935 !111 !112) -!1941 = (!1934 !1935 !111 !112) -!1942 = (!1934 !1935 !111 !112) -!1943 = (!1934 !1935 !111 !112) -!1944 = (!1934 !1935 !111 !112) -!1945 = (!1934 !1935 !111 !112) -!1946 = (!1934 !1935 !111 !112) -!1947 = (!1934 !1935 !111 !112) -!1948 = (!1934 !1935 !111 !112) -!1949 = (!1934 !1935 !111 !112) -!1950 = (!1934 !1935 !111 !112) -!1951 = (!1934 !1935 !111 !112) -!1952 = (!1934 !1935 !111 !112) -!1953 = (!1934 !1935 !111 !112) -!1954 = (!1934 !1935 !111 !112) -!1955 = (!1934 !1935 !111 !112) -!1956 = (!1934 !1935 !111 !112) -!1957 = (!1934 !1935 !111 !112) -!1958 = (!1934 !1935 !111 !112) -!1959 = (!1934 !1935 !111 !112) -!1960 = (!1934 !1935 !111 !112) -!1961 = (!1934 !1935 !111 !112) -!1962 = (!1934 !1935 !111 !112) -!1963 = span !6 4894 4977 -!1964 = (!1934 !1935 !111 !112 !1963) -!1965 = (!1934 !1935 !111 !112) -!1966 = (!1934 !1935 !141) -!1967 = (!1934 !1935 !143) -!1968 = span !0 8130 8178 -!1969 = span !0 8214 8221 -!1970 = span !0 8214 8227 -!1971 = fn_call_path_span !0 8222 8225 -!1972 = (!1970 !1971) -!1973 = (!1970 !1971 !69) -!1974 = (!1970 !1971 !71 !72) -!1975 = (!1970 !1971 !71 !72 !74) -!1976 = (!1970 !1971 !76) -!1977 = span !0 8229 8236 -!1978 = span !0 8199 8249 -!1979 = (!1934 !1935 !111 !112) -!1980 = (!1934 !1935 !111 !112) -!1981 = (!1934 !1935 !111 !112) -!1982 = (!1934 !1935 !111 !112) -!1983 = span !0 8256 8268 -!1984 = span !0 8272 8280 -!1985 = span !0 8256 8280 -!1986 = span !0 8302 8309 -!1987 = span !0 8302 8328 -!1988 = fn_call_path_span !0 8310 8316 -!1989 = (!1987 !1988 !90 !91 !393 !394 !557 !558 !53) -!1990 = (!1987 !1988 !90 !91 !393 !394 !557 !558) -!1991 = (!1987 !1988 !90 !91 !393 !394 !557 !558 !56) -!1992 = (!1987 !1988 !90 !91 !393 !394 !557 !558 !59) -!1993 = (!1987 !1988 !90 !91 !92) -!1994 = (!1987 !1988 !90 !91 !92) -!1995 = (!1987 !1988 !90 !91 !92) -!1996 = span !0 8283 8329 -!1997 = span !0 8393 8397 -!1998 = span !0 8398 8399 -!1999 = span !0 8427 8449 -!2000 = fn_call_path_span !0 8427 8433 -!2001 = (!1999 !2000 !141) -!2002 = (!1999 !2000 !143) -!2003 = span !0 8402 8450 -!2004 = span !0 8486 8493 -!2005 = span !0 8486 8499 -!2006 = fn_call_path_span !0 8494 8497 -!2007 = (!2005 !2006) -!2008 = (!2005 !2006 !69) -!2009 = (!2005 !2006 !71 !72) -!2010 = (!2005 !2006 !71 !72 !74) -!2011 = (!2005 !2006 !76) -!2012 = span !0 8501 8508 -!2013 = span !0 8471 8521 -!2014 = span !0 8528 8540 -!2015 = span !0 8544 8551 -!2016 = span !0 8528 8551 -!2017 = span !0 8572 8579 -!2018 = span !0 8572 8597 -!2019 = fn_call_path_span !0 8580 8586 -!2020 = span !6 72720 72739 -!2021 = fn_call_path_span !6 72727 72731 -!2022 = (!2018 !2019 !90 !91 !393 !394 !2020 !2021) -!2023 = (!2018 !2019 !90 !91 !92) -!2024 = (!2018 !2019 !90 !91 !92) -!2025 = (!2018 !2019 !90 !91 !92) -!2026 = span !0 8554 8598 -!2027 = span !0 8660 8664 -!2028 = span !0 8665 8666 -!2029 = span !0 8694 8715 -!2030 = fn_call_path_span !0 8694 8700 -!2031 = (!2029 !2030 !111 !112) -!2032 = span !6 5301 5307 -!2033 = (!2029 !2030 !111 !112 !2032) -!2034 = (!2029 !2030 !111 !112 !428) -!2035 = (!2029 !2030 !111 !112) -!2036 = (!2029 !2030 !111 !112) -!2037 = (!2029 !2030 !111 !112) -!2038 = (!2029 !2030 !111 !112) -!2039 = (!2029 !2030 !111 !112) -!2040 = (!2029 !2030 !111 !112) -!2041 = (!2029 !2030 !111 !112) -!2042 = (!2029 !2030 !111 !112) -!2043 = (!2029 !2030 !111 !112) -!2044 = (!2029 !2030 !111 !112) -!2045 = (!2029 !2030 !111 !112) -!2046 = (!2029 !2030 !111 !112) -!2047 = (!2029 !2030 !111 !112) -!2048 = (!2029 !2030 !111 !112) -!2049 = (!2029 !2030 !111 !112) -!2050 = (!2029 !2030 !111 !112) -!2051 = (!2029 !2030 !111 !112) -!2052 = (!2029 !2030 !111 !112) -!2053 = (!2029 !2030 !111 !112) -!2054 = (!2029 !2030 !111 !112) -!2055 = span !6 5249 5332 -!2056 = (!2029 !2030 !111 !112 !2055) -!2057 = (!2029 !2030 !111 !112) -!2058 = (!2029 !2030 !141) -!2059 = (!2029 !2030 !143) -!2060 = span !0 8669 8716 -!2061 = span !0 8752 8759 -!2062 = span !0 8752 8765 -!2063 = fn_call_path_span !0 8760 8763 -!2064 = (!2062 !2063) -!2065 = (!2062 !2063 !69) -!2066 = (!2062 !2063 !71 !72) -!2067 = (!2062 !2063 !71 !72 !74) -!2068 = (!2062 !2063 !76) -!2069 = span !0 8767 8774 -!2070 = span !0 8737 8787 -!2071 = (!2029 !2030 !111 !112) -!2072 = (!2029 !2030 !111 !112) -!2073 = (!2029 !2030 !111 !112) -!2074 = (!2029 !2030 !111 !112) -!2075 = span !0 8813 8816 -!2076 = span !0 8804 8817 -!2077 = span !6 3128 3132 -!2078 = span !6 3134 3139 -!2079 = span !6 3102 3321 -!2080 = fn_name_span !6 3109 3119 -!2081 = (!2079 !2080) -!2082 = span !6 3190 3207 -!2083 = span !6 3169 3248 -!2084 = span !6 3257 3300 -!2085 = span !6 3310 3315 -!2086 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/ops.sw" -!2087 = span !2086 35686 36058 -!2088 = fn_name_span !2086 35689 35691 -!2089 = (!2087 !2088) -!2090 = span !2086 35732 35736 -!2091 = span !2086 35746 35751 -!2092 = span !2086 35732 35757 -!2093 = fn_call_path_span !2086 35743 35745 -!2094 = span !2086 15555 15569 -!2095 = fn_call_path_span !2086 15560 15562 -!2096 = (!2092 !2093 !2094 !2095) -!2097 = span !2086 12573 12578 -!2098 = span !2086 15554 15576 -!2099 = fn_call_path_span !2086 15571 15574 -!2100 = (!2092 !2093 !2098 !2099) -!2101 = span !2086 35772 35777 -!2102 = span !2086 35822 35826 -!2103 = span !2086 35865 35870 -!2104 = span !2086 35901 35905 -!2105 = span !2086 35925 36042 -!2106 = span !2086 35987 36002 -!2107 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/str.sw" -!2108 = span !2107 281 403 -!2109 = fn_name_span !2107 288 291 -!2110 = (!2108 !2109) -!2111 = span !2107 337 341 -!2112 = span !2107 90 219 -!2113 = fn_name_span !2107 97 103 -!2114 = (!2112 !2113) -!2115 = span !2107 153 157 -!2116 = span !6 89760 89766 -!2117 = span !6 89738 90238 -!2118 = fn_name_span !6 89741 89751 -!2119 = inline "never" -!2120 = (!2117 !2118 !2119) -!2121 = span !6 89822 89842 -!2122 = span !6 89858 89864 -!2123 = (!2122 !141) -!2124 = (!2122 !143) -!2125 = span !6 89891 89904 -!2126 = span !6 89875 89905 -!2127 = span !6 89998 90003 -!2128 = span !6 90045 90046 -!2129 = (!2128 !141) -!2130 = (!2128 !143) -!2131 = span !6 90027 90028 -!2132 = span !6 90063 90068 -!2133 = fn_call_path_span !6 90065 90066 -!2134 = (!2132 !2133) -!2135 = span !6 90089 90090 -!2136 = (!2135 !141) -!2137 = (!2135 !143) -!2138 = span !6 90165 90185 -!2139 = fn_call_path_span !6 90172 90178 -!2140 = (!2138 !2139 !90 !91 !557 !558 !53) -!2141 = (!2138 !2139 !90 !91 !557 !558) -!2142 = (!2138 !2139 !90 !91 !557 !558 !56) -!2143 = (!2138 !2139 !90 !91 !557 !558 !59) -!2144 = span !6 90157 90185 -!2145 = span !6 90204 90205 -!2146 = span !6 90199 90205 -!2147 = fn_call_path_span !6 90201 90203 -!2148 = (!2146 !2147) -!2149 = span !6 4674 4678 -!2150 = span !6 4660 4805 -!2151 = fn_name_span !6 4663 4673 -!2152 = (!2150 !2151) -!2153 = span !6 4768 4774 -!2154 = span !6 4716 4799 -!2155 = span !6 160 260 -!2156 = fn_name_span !6 167 170 -!2157 = (!2155 !2156) -!2158 = span !6 191 254 -!2159 = span !6 499 591 -!2160 = fn_name_span !6 502 514 -!2161 = (!2159 !2160) -!2162 = span !6 573 577 -!2163 = span !68 3372 3452 -!2164 = fn_name_span !68 3379 3382 -!2165 = (!2163 !2164) -!2166 = span !68 3409 3425 -!2167 = fn_call_path_span !68 3409 3419 -!2168 = (!2166 !2167) -!2169 = (!2166 !2167 !74) -!2170 = (!2117 !2118 !2119) -!2171 = (!2122 !141) -!2172 = (!2122 !143) -!2173 = (!2128 !141) -!2174 = (!2128 !143) -!2175 = (!2132 !2133) -!2176 = (!2135 !141) -!2177 = (!2135 !143) -!2178 = (!2138 !2139 !90 !91 !557 !558 !53) -!2179 = (!2138 !2139 !90 !91 !557 !558) -!2180 = (!2138 !2139 !90 !91 !557 !558 !56) -!2181 = (!2138 !2139 !90 !91 !557 !558 !59) -!2182 = (!2146 !2147) -!2183 = (!2117 !2118 !2119) -!2184 = (!2122 !141) -!2185 = (!2122 !143) -!2186 = (!2128 !141) -!2187 = (!2128 !143) -!2188 = (!2132 !2133) -!2189 = (!2135 !141) -!2190 = (!2135 !143) -!2191 = (!2138 !2139 !90 !91 !557 !558 !53) -!2192 = (!2138 !2139 !90 !91 !557 !558) -!2193 = (!2138 !2139 !90 !91 !557 !558 !56) -!2194 = (!2138 !2139 !90 !91 !557 !558 !59) -!2195 = (!2146 !2147) -!2196 = (!2117 !2118 !2119) -!2197 = (!2122 !141) -!2198 = (!2122 !143) -!2199 = (!2128 !141) -!2200 = (!2128 !143) -!2201 = (!2132 !2133) -!2202 = (!2135 !141) -!2203 = (!2135 !143) -!2204 = (!2138 !2139 !90 !91 !557 !558 !53) -!2205 = (!2138 !2139 !90 !91 !557 !558) -!2206 = (!2138 !2139 !90 !91 !557 !558 !56) -!2207 = (!2138 !2139 !90 !91 !557 !558 !59) -!2208 = (!2146 !2147) -!2209 = (!2117 !2118 !2119) -!2210 = (!2122 !141) -!2211 = (!2122 !143) -!2212 = (!2128 !141) -!2213 = (!2128 !143) -!2214 = (!2132 !2133) -!2215 = (!2135 !141) -!2216 = (!2135 !143) -!2217 = (!2138 !2139 !90 !91 !557 !558 !53) -!2218 = (!2138 !2139 !90 !91 !557 !558) -!2219 = (!2138 !2139 !90 !91 !557 !558 !56) -!2220 = (!2138 !2139 !90 !91 !557 !558 !59) -!2221 = (!2146 !2147) -!2222 = (!2117 !2118 !2119) -!2223 = (!2122 !141) -!2224 = (!2122 !143) -!2225 = (!2128 !141) -!2226 = (!2128 !143) -!2227 = (!2132 !2133) -!2228 = (!2135 !141) -!2229 = (!2135 !143) -!2230 = (!2138 !2139 !90 !91 !557 !558 !53) -!2231 = (!2138 !2139 !90 !91 !557 !558) -!2232 = (!2138 !2139 !90 !91 !557 !558 !56) -!2233 = (!2138 !2139 !90 !91 !557 !558 !59) -!2234 = (!2146 !2147) -!2235 = span !6 70770 70911 -!2236 = fn_name_span !6 70777 70783 -!2237 = (!2235 !2236) -!2238 = (!111 !112) -!2239 = (!111 !112 !117) -!2240 = (!111 !112 !121 !122) -!2241 = (!111 !112 !125) -!2242 = (!111 !112 !127) -!2243 = (!111 !112 !130) -!2244 = (!111 !112 !132) -!2245 = (!111 !112 !135 !136) -!2246 = (!111 !112 !139) -!2247 = span !6 3350 3354 -!2248 = span !6 3327 3871 -!2249 = fn_name_span !6 3334 3338 -!2250 = (!2248 !2249) -!2251 = span !6 3640 3733 -!2252 = span !6 3682 3695 -!2253 = span !6 3747 3786 -!2254 = (!2235 !2236) -!2255 = (!111 !112) -!2256 = span !101 54 58 -!2257 = (!111 !112 !2256) -!2258 = span !0 220 259 -!2259 = (!111 !112 !2258) -!2260 = (!2235 !2236) -!2261 = (!111 !112) -!2262 = span !101 198 202 -!2263 = (!111 !112 !2262) -!2264 = span !0 260 299 -!2265 = (!111 !112 !2264) -!2266 = span !101 232 236 -!2267 = (!111 !112 !2266) -!2268 = span !0 300 339 -!2269 = (!111 !112 !2268) -!2270 = span !101 266 270 -!2271 = (!111 !112 !2270) -!2272 = span !0 340 379 -!2273 = (!111 !112 !2272) -!2274 = (!2235 !2236) -!2275 = (!111 !112) -!2276 = span !6 42991 42992 -!2277 = (!111 !112 !2276) -!2278 = span !6 42973 43012 -!2279 = (!111 !112 !2278) -!2280 = span !6 43039 43040 -!2281 = (!111 !112 !2280) -!2282 = span !6 43021 43060 -!2283 = (!111 !112 !2282) - -// IR: Final -contract { - global __const_global : string<10> = const string<10> "in_array_0" - global __const_global0 : string<10> = const string<10> "in_array_1" - global __const_global1 : string<11> = const string<11> "in_array_16" - global __const_global10 : string<8> = const string<8> "in_str_0" - global __const_global11 : string<8> = const string<8> "in_str_1" - global __const_global12 : string<9> = const string<9> "in_str_16" - global __const_global13 : string<9> = const string<9> "in_str_32" - global __const_global14 : string<8> = const string<8> "in_str_8" - global __const_global15 : string<13> = const string<13> "in_struct_u64" - global __const_global16 : string<17> = const string<17> "in_struct_u64_u64" - global __const_global17 : string<21> = const string<21> "in_struct_u64_u64_u64" - global __const_global18 : string<10> = const string<10> "in_tuple_0" - global __const_global19 : string<10> = const string<10> "in_tuple_1" - global __const_global2 : string<11> = const string<11> "in_array_32" - global __const_global20 : string<10> = const string<10> "in_tuple_2" - global __const_global21 : string<10> = const string<10> "in_tuple_3" - global __const_global22 : string<10> = const string<10> "in_tuple_4" - global __const_global23 : string<6> = const string<6> "in_u16" - global __const_global24 : string<7> = const string<7> "in_u256" - global __const_global25 : string<6> = const string<6> "in_u32" - global __const_global26 : string<6> = const string<6> "in_u64" - global __const_global27 : string<5> = const string<5> "in_u8" - global __const_global28 : string<7> = const string<7> "in_bool" - global __const_global29 : string<5> = const string<5> "in_u8" - global __const_global3 : string<11> = const string<11> "in_array_64" - global __const_global30 : string<6> = const string<6> "in_u16" - global __const_global31 : string<6> = const string<6> "in_u32" - global __const_global32 : string<6> = const string<6> "in_u64" - global __const_global33 : string<7> = const string<7> "in_u256" - global __const_global34 : string<7> = const string<7> "in_b256" - global __const_global35 : string<8> = const string<8> "in_str_0" - global __const_global36 : string<8> = const string<8> "in_str_1" - global __const_global37 : string<8> = const string<8> "in_str_8" - global __const_global38 : string<9> = const string<9> "in_str_16" - global __const_global39 : string<9> = const string<9> "in_str_32" - global __const_global4 : string<10> = const string<10> "in_array_8" - global __const_global40 : string<10> = const string<10> "in_array_0" - global __const_global41 : string<10> = const string<10> "in_array_1" - global __const_global42 : string<10> = const string<10> "in_array_8" - global __const_global43 : string<11> = const string<11> "in_array_16" - global __const_global44 : string<11> = const string<11> "in_array_32" - global __const_global45 : string<11> = const string<11> "in_array_64" - global __const_global46 : string<10> = const string<10> "in_tuple_0" - global __const_global47 : string<10> = const string<10> "in_tuple_1" - global __const_global48 : string<10> = const string<10> "in_tuple_2" - global __const_global49 : string<10> = const string<10> "in_tuple_3" - global __const_global5 : string<7> = const string<7> "in_b256" - global __const_global50 : string<10> = const string<10> "in_tuple_4" - global __const_global51 : string<13> = const string<13> "in_struct_u64" - global __const_global52 : string<17> = const string<17> "in_struct_u64_u64" - global __const_global53 : string<21> = const string<21> "in_struct_u64_u64_u64" - global __const_global54 : string<11> = const string<11> "in_enum_u64" - global __const_global55 : string<15> = const string<15> "in_enum_u64_u64" - global __const_global56 : string<19> = const string<19> "in_enum_u64_u64_u64" - global __const_global6 : string<7> = const string<7> "in_bool" - global __const_global7 : string<11> = const string<11> "in_enum_u64" - global __const_global8 : string<15> = const string<15> "in_enum_u64_u64" - global __const_global9 : string<19> = const string<19> "in_enum_u64_u64_u64" - global const_of_contract_call::CONTRACT_ID : b256 = const b256 0xe0e478ce6c0db695cca5ddfd11e1d041fd4bbb30bde397218a24a1a4df3ac422 - - pub entry fn __entry() -> (), !3 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut slice __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_010 - local mut { ptr, u64 } __aggr_memcpy_011 - local mut { ptr, u64 } __aggr_memcpy_012 - local mut string<0> __aggr_memcpy_013 - local mut { ptr, u64 } __aggr_memcpy_014 - local mut { ptr, u64 } __aggr_memcpy_015 - local mut string<1> __aggr_memcpy_016 - local mut { ptr, u64 } __aggr_memcpy_017 - local mut { ptr, u64 } __aggr_memcpy_018 - local mut string<16> __aggr_memcpy_019 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut { ptr, u64 } __aggr_memcpy_020 - local mut { ptr, u64 } __aggr_memcpy_021 - local mut string<32> __aggr_memcpy_022 - local mut { ptr, u64 } __aggr_memcpy_023 - local mut { ptr, u64 } __aggr_memcpy_024 - local mut string<8> __aggr_memcpy_025 - local mut { ptr, u64 } __aggr_memcpy_026 - local mut { ptr, u64 } __aggr_memcpy_027 - local mut { ptr, u64 } __aggr_memcpy_028 - local mut { ptr, u64 } __aggr_memcpy_029 - local mut { ptr, u64 } __aggr_memcpy_03 - local mut { ptr, u64 } __aggr_memcpy_030 - local mut { ptr, u64 } __aggr_memcpy_031 - local mut { ptr, u64 } __aggr_memcpy_032 - local mut { ptr, u64 } __aggr_memcpy_033 - local mut { ptr, u64 } __aggr_memcpy_034 - local mut { ptr, u64 } __aggr_memcpy_035 - local mut { ptr, u64 } __aggr_memcpy_036 - local mut { ptr, u64 } __aggr_memcpy_037 - local mut { ptr, u64 } __aggr_memcpy_038 - local mut { ptr, u64 } __aggr_memcpy_04 - local mut { ptr, u64 } __aggr_memcpy_05 - local mut { ptr, u64 } __aggr_memcpy_06 - local mut { ptr, u64 } __aggr_memcpy_07 - local mut { ptr, u64 } __aggr_memcpy_08 - local mut { ptr, u64 } __aggr_memcpy_09 - local { ptr, u64 } __anon_0 - local { ptr } __anon_00 - local { ptr, u64 } __anon_000 - local { u64 } __anon_001 - local { ptr } __anon_01 - local { { u64, ( u64 ) } } __anon_010 - local { { u64, ( u64 | u64 ) } } __anon_011 - local { { u64, ( u64 | u64 | u64 ) } } __anon_012 - local { string<0> } __anon_013 - local { string<1> } __anon_014 - local { string<16> } __anon_015 - local { string<32> } __anon_016 - local { string<8> } __anon_017 - local { { u64 } } __anon_018 - local { { u64, u64 } } __anon_019 - local { [u64; 0] } __anon_02 - local { { u64, u64, u64 } } __anon_020 - local { () } __anon_021 - local { { u64 } } __anon_022 - local { { u64, u64 } } __anon_023 - local { { u64, u64, u64 } } __anon_024 - local { { u64, u64, u64, u64 } } __anon_025 - local { u64 } __anon_026 - local { u256 } __anon_027 - local { u64 } __anon_028 - local { u64 } __anon_029 - local { [u64; 1] } __anon_03 - local { u8 } __anon_030 - local { ptr, u64 } __anon_031 - local { ptr, u64 } __anon_032 - local { ptr, u64 } __anon_033 - local { ptr, u64 } __anon_034 - local { ptr, u64 } __anon_035 - local { ptr, u64 } __anon_036 - local { ptr, u64 } __anon_037 - local { ptr, u64 } __anon_038 - local { ptr, u64 } __anon_039 - local { [u64; 16] } __anon_04 - local { ptr, u64 } __anon_040 - local { ptr, u64 } __anon_041 - local { ptr, u64 } __anon_042 - local { ptr, u64 } __anon_043 - local { ptr, u64 } __anon_044 - local { ptr, u64 } __anon_045 - local { ptr, u64 } __anon_046 - local { ptr, u64 } __anon_047 - local { ptr, u64 } __anon_048 - local { ptr, u64 } __anon_049 - local { [u64; 32] } __anon_05 - local { ptr, u64 } __anon_050 - local { ptr, u64 } __anon_051 - local { ptr, u64 } __anon_052 - local { ptr, u64 } __anon_053 - local { ptr, u64 } __anon_054 - local { ptr, u64 } __anon_055 - local { ptr, u64 } __anon_056 - local { ptr, u64 } __anon_057 - local { ptr, u64 } __anon_058 - local { ptr, u64 } __anon_059 - local { [u64; 64] } __anon_06 - local { ptr, u64 } __anon_060 - local { ptr, u64 } __anon_061 - local { ptr, u64 } __anon_062 - local { ptr, u64 } __anon_063 - local { ptr, u64 } __anon_064 - local { [u64; 8] } __anon_07 - local { b256 } __anon_08 - local { bool } __anon_09 - local slice __anon_1 - local { ptr, u64 } __anon_10 - local slice __anon_11 - local { ptr, u64 } __anon_12 - local slice __anon_13 - local { ptr, u64 } __anon_14 - local slice __anon_15 - local { ptr, u64 } __anon_16 - local slice __anon_17 - local { ptr, u64 } __anon_18 - local slice __anon_19 - local { ptr, u64 } __anon_2 - local { ptr, u64 } __anon_20 - local slice __anon_21 - local { ptr, u64 } __anon_22 - local slice __anon_23 - local { ptr, u64 } __anon_24 - local slice __anon_25 - local { ptr, u64 } __anon_26 - local slice __anon_27 - local { ptr, u64 } __anon_28 - local slice __anon_29 - local slice __anon_3 - local { ptr, u64 } __anon_30 - local slice __anon_31 - local { ptr, u64 } __anon_32 - local slice __anon_33 - local { ptr, u64 } __anon_34 - local slice __anon_35 - local { ptr, u64 } __anon_36 - local slice __anon_37 - local { ptr, u64 } __anon_38 - local slice __anon_39 - local { ptr, u64 } __anon_4 - local { ptr, u64 } __anon_40 - local slice __anon_41 - local { ptr, u64 } __anon_42 - local slice __anon_43 - local { ptr, u64 } __anon_44 - local slice __anon_45 - local { ptr, u64 } __anon_46 - local slice __anon_47 - local { ptr, u64 } __anon_48 - local slice __anon_49 - local slice __anon_5 - local { ptr, u64 } __anon_50 - local slice __anon_51 - local { ptr, u64 } __anon_52 - local slice __anon_53 - local { ptr, u64 } __anon_54 - local slice __anon_55 - local { ptr, u64 } __anon_56 - local slice __anon_57 - local { ptr, u64 } __anon_6 - local slice __anon_7 - local { ptr, u64 } __anon_8 - local slice __anon_9 - local slice __log_arg - local slice __ret_val - local slice __ret_val0 - local slice __ret_val1 - local { { ptr, u64, u64 } } __ret_val10 - local { u64, u64, u64 } __ret_val100 - local { u64, u64, u64 } __ret_val101 - local { u64, u64, u64, u64 } __ret_val102 - local { { ptr, u64, u64 } } __ret_val103 - local { { ptr, u64, u64 } } __ret_val104 - local u256 __ret_val105 - local { { ptr, u64, u64 } } __ret_val106 - local { { ptr, u64, u64 } } __ret_val107 - local { { ptr, u64, u64 } } __ret_val108 - local { { ptr, u64, u64 } } __ret_val11 - local { { ptr, u64, u64 } } __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local { { ptr, u64, u64 } } __ret_val15 - local { { ptr, u64, u64 } } __ret_val16 - local { { ptr, u64, u64 } } __ret_val17 - local { { ptr, u64, u64 } } __ret_val18 - local { { ptr, u64, u64 } } __ret_val19 - local slice __ret_val2 - local { { ptr, u64, u64 } } __ret_val20 - local { { ptr, u64, u64 } } __ret_val21 - local { { ptr, u64, u64 } } __ret_val22 - local { { ptr, u64, u64 } } __ret_val23 - local { { ptr, u64, u64 } } __ret_val24 - local { { ptr, u64, u64 } } __ret_val25 - local { { ptr, u64, u64 } } __ret_val26 - local { { ptr, u64, u64 } } __ret_val27 - local { { ptr, u64, u64 } } __ret_val28 - local { { ptr, u64, u64 } } __ret_val29 - local slice __ret_val3 - local { { ptr, u64, u64 } } __ret_val30 - local { { ptr, u64, u64 } } __ret_val31 - local { { ptr, u64, u64 } } __ret_val32 - local { { ptr, u64, u64 } } __ret_val33 - local { { ptr, u64, u64 } } __ret_val34 - local { { ptr, u64, u64 } } __ret_val35 - local slice __ret_val36 - local slice __ret_val37 - local slice __ret_val38 - local slice __ret_val39 - local slice __ret_val4 - local slice __ret_val40 - local slice __ret_val41 - local slice __ret_val42 - local slice __ret_val43 - local slice __ret_val44 - local slice __ret_val45 - local slice __ret_val46 - local slice __ret_val47 - local slice __ret_val48 - local slice __ret_val49 - local [u64; 0] __ret_val5 - local slice __ret_val50 - local slice __ret_val51 - local slice __ret_val52 - local slice __ret_val53 - local slice __ret_val54 - local slice __ret_val55 - local slice __ret_val56 - local slice __ret_val57 - local slice __ret_val58 - local slice __ret_val59 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val60 - local slice __ret_val61 - local slice __ret_val62 - local slice __ret_val63 - local slice __ret_val64 - local { { ptr, u64, u64 } } __ret_val65 - local [u64; 1] __ret_val66 - local { { ptr, u64, u64 } } __ret_val67 - local [u64; 16] __ret_val68 - local { { ptr, u64, u64 } } __ret_val69 - local { { ptr, u64, u64 } } __ret_val7 - local [u64; 32] __ret_val70 - local { { ptr, u64, u64 } } __ret_val71 - local [u64; 64] __ret_val72 - local { { ptr, u64, u64 } } __ret_val73 - local [u64; 8] __ret_val74 - local { { ptr, u64, u64 } } __ret_val75 - local { { ptr, u64, u64 } } __ret_val76 - local b256 __ret_val77 - local { { ptr, u64, u64 } } __ret_val78 - local { { ptr, u64, u64 } } __ret_val79 - local { { ptr, u64, u64 } } __ret_val8 - local { u64, ( u64 ) } __ret_val80 - local { { ptr, u64, u64 } } __ret_val81 - local { u64, ( u64 | u64 ) } __ret_val82 - local { { ptr, u64, u64 } } __ret_val83 - local { u64, ( u64 | u64 | u64 ) } __ret_val84 - local { { ptr, u64, u64 } } __ret_val85 - local { { ptr, u64, u64 } } __ret_val86 - local { { ptr, u64, u64 } } __ret_val87 - local { { ptr, u64, u64 } } __ret_val88 - local { { ptr, u64, u64 } } __ret_val89 - local { { ptr, u64, u64 } } __ret_val9 - local { { ptr, u64, u64 } } __ret_val90 - local { u64 } __ret_val91 - local { { ptr, u64, u64 } } __ret_val92 - local { { ptr, u64, u64 } } __ret_val93 - local { u64, u64 } __ret_val94 - local { u64, u64 } __ret_val95 - local { { ptr, u64, u64 } } __ret_val96 - local { { ptr, u64, u64 } } __ret_val97 - local { { ptr, u64, u64 } } __ret_val98 - local { { ptr, u64, u64 } } __ret_val99 - local slice __tmp_arg - local slice __tmp_arg0 - local slice __tmp_arg1 - local slice __tmp_arg10 - local slice __tmp_arg100 - local slice __tmp_arg101 - local slice __tmp_arg102 - local slice __tmp_arg103 - local slice __tmp_arg104 - local slice __tmp_arg105 - local slice __tmp_arg106 - local slice __tmp_arg107 - local slice __tmp_arg108 - local slice __tmp_arg109 - local slice __tmp_arg11 - local slice __tmp_arg110 - local slice __tmp_arg111 - local slice __tmp_arg112 - local slice __tmp_arg113 - local slice __tmp_arg114 - local slice __tmp_arg115 - local slice __tmp_arg116 - local [u64; 1] __tmp_arg117 - local { { ptr, u64, u64 } } __tmp_arg118 - local [u64; 16] __tmp_arg119 - local slice __tmp_arg12 - local { { ptr, u64, u64 } } __tmp_arg120 - local [u64; 32] __tmp_arg121 - local { { ptr, u64, u64 } } __tmp_arg122 - local [u64; 64] __tmp_arg123 - local { { ptr, u64, u64 } } __tmp_arg124 - local [u64; 8] __tmp_arg125 - local { { ptr, u64, u64 } } __tmp_arg126 - local [u64; 8] __tmp_arg127 - local { { ptr, u64, u64 } } __tmp_arg128 - local b256 __tmp_arg129 - local slice __tmp_arg13 - local { { ptr, u64, u64 } } __tmp_arg130 - local { { ptr, u64, u64 } } __tmp_arg131 - local { u64, ( u64 ) } __tmp_arg132 - local { { ptr, u64, u64 } } __tmp_arg133 - local { u64, ( u64 | u64 ) } __tmp_arg134 - local { { ptr, u64, u64 } } __tmp_arg135 - local { u64, ( u64 | u64 | u64 ) } __tmp_arg136 - local { { ptr, u64, u64 } } __tmp_arg137 - local string<0> __tmp_arg138 - local { { ptr, u64, u64 } } __tmp_arg139 - local slice __tmp_arg14 - local string<1> __tmp_arg140 - local { { ptr, u64, u64 } } __tmp_arg141 - local string<16> __tmp_arg142 - local { { ptr, u64, u64 } } __tmp_arg143 - local string<32> __tmp_arg144 - local { { ptr, u64, u64 } } __tmp_arg145 - local string<8> __tmp_arg146 - local { { ptr, u64, u64 } } __tmp_arg147 - local { u64 } __tmp_arg148 - local { { ptr, u64, u64 } } __tmp_arg149 - local slice __tmp_arg15 - local { u64 } __tmp_arg150 - local { { ptr, u64, u64 } } __tmp_arg151 - local { u64, u64, u64 } __tmp_arg152 - local { { ptr, u64, u64 } } __tmp_arg153 - local { u64, u64, u64 } __tmp_arg154 - local { { ptr, u64, u64 } } __tmp_arg155 - local { u64, u64 } __tmp_arg156 - local { { ptr, u64, u64 } } __tmp_arg157 - local { u64, u64 } __tmp_arg158 - local { { ptr, u64, u64 } } __tmp_arg159 - local slice __tmp_arg16 - local { u64, u64, u64, u64 } __tmp_arg160 - local { { ptr, u64, u64 } } __tmp_arg161 - local { { ptr, u64, u64 } } __tmp_arg162 - local u256 __tmp_arg163 - local { { ptr, u64, u64 } } __tmp_arg164 - local { { ptr, u64, u64 } } __tmp_arg165 - local { { ptr, u64, u64 } } __tmp_arg166 - local slice __tmp_arg17 - local slice __tmp_arg18 - local slice __tmp_arg19 - local slice __tmp_arg2 - local slice __tmp_arg20 - local slice __tmp_arg21 - local slice __tmp_arg22 - local slice __tmp_arg23 - local slice __tmp_arg24 - local slice __tmp_arg25 - local slice __tmp_arg26 - local slice __tmp_arg27 - local slice __tmp_arg28 - local slice __tmp_arg29 - local slice __tmp_arg3 - local slice __tmp_arg30 - local slice __tmp_arg31 - local slice __tmp_arg32 - local slice __tmp_arg33 - local slice __tmp_arg34 - local slice __tmp_arg35 - local slice __tmp_arg36 - local slice __tmp_arg37 - local slice __tmp_arg38 - local slice __tmp_arg39 - local slice __tmp_arg4 - local slice __tmp_arg40 - local slice __tmp_arg41 - local slice __tmp_arg42 - local slice __tmp_arg43 - local slice __tmp_arg44 - local slice __tmp_arg45 - local slice __tmp_arg46 - local slice __tmp_arg47 - local slice __tmp_arg48 - local slice __tmp_arg49 - local slice __tmp_arg5 - local slice __tmp_arg50 - local slice __tmp_arg51 - local slice __tmp_arg52 - local slice __tmp_arg53 - local slice __tmp_arg54 - local slice __tmp_arg55 - local slice __tmp_arg56 - local { { ptr, u64, u64 } } __tmp_arg57 - local { { ptr, u64, u64 } } __tmp_arg58 - local { { ptr, u64, u64 } } __tmp_arg59 - local slice __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg60 - local { { ptr, u64, u64 } } __tmp_arg61 - local { { ptr, u64, u64 } } __tmp_arg62 - local { { ptr, u64, u64 } } __tmp_arg63 - local { { ptr, u64, u64 } } __tmp_arg64 - local { { ptr, u64, u64 } } __tmp_arg65 - local { { ptr, u64, u64 } } __tmp_arg66 - local { { ptr, u64, u64 } } __tmp_arg67 - local { { ptr, u64, u64 } } __tmp_arg68 - local { { ptr, u64, u64 } } __tmp_arg69 - local slice __tmp_arg7 - local { { ptr, u64, u64 } } __tmp_arg70 - local { { ptr, u64, u64 } } __tmp_arg71 - local { { ptr, u64, u64 } } __tmp_arg72 - local { { ptr, u64, u64 } } __tmp_arg73 - local { { ptr, u64, u64 } } __tmp_arg74 - local { { ptr, u64, u64 } } __tmp_arg75 - local { { ptr, u64, u64 } } __tmp_arg76 - local { { ptr, u64, u64 } } __tmp_arg77 - local { { ptr, u64, u64 } } __tmp_arg78 - local { { ptr, u64, u64 } } __tmp_arg79 - local slice __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg80 - local { { ptr, u64, u64 } } __tmp_arg81 - local { { ptr, u64, u64 } } __tmp_arg82 - local { { ptr, u64, u64 } } __tmp_arg83 - local { { ptr, u64, u64 } } __tmp_arg84 - local { { ptr, u64, u64 } } __tmp_arg85 - local { { ptr, u64, u64 } } __tmp_arg86 - local [u64; 0] __tmp_arg87 - local { { ptr, u64, u64 } } __tmp_arg88 - local slice __tmp_arg89 - local slice __tmp_arg9 - local slice __tmp_arg90 - local slice __tmp_arg91 - local slice __tmp_arg92 - local slice __tmp_arg93 - local slice __tmp_arg94 - local slice __tmp_arg95 - local slice __tmp_arg96 - local slice __tmp_arg97 - local slice __tmp_arg98 - local slice __tmp_arg99 - local mut { ptr } _buffer - local slice _method_name - local [u64; 0] _result - local slice _result_ - local [u64; 1] _result__ - local slice _result___ - local [u64; 16] _result____ - local slice _result_____ - local [u64; 32] _result______ - local slice _result_______ - local [u64; 64] _result________ - local slice _result_________ - local [u64; 8] _result__________ - local slice _result___________ - local b256 _result____________ - local slice _result_____________ - local slice _result_______________ - local { u64, ( u64 ) } _result________________ - local slice _result_________________ - local { u64, ( u64 | u64 ) } _result__________________ - local slice _result___________________ - local { u64, ( u64 | u64 | u64 ) } _result____________________ - local slice _result_____________________ - local string<0> _result______________________ - local slice _result_______________________ - local string<1> _result________________________ - local slice _result_________________________ - local string<16> _result__________________________ - local slice _result___________________________ - local string<32> _result____________________________ - local slice _result_____________________________ - local string<8> _result______________________________ - local slice _result_______________________________ - local { u64 } _result________________________________ - local slice _result_________________________________ - local { u64, u64 } _result__________________________________ - local slice _result___________________________________ - local { u64, u64, u64 } _result____________________________________ - local slice _result_____________________________________ - local { u64 } _result_______________________________________ - local slice _result________________________________________ - local { u64, u64 } _result_________________________________________ - local slice _result__________________________________________ - local { u64, u64, u64 } _result___________________________________________ - local slice _result____________________________________________ - local { u64, u64, u64, u64 } _result_____________________________________________ - local slice _result______________________________________________ - local slice _result________________________________________________ - local u256 _result_________________________________________________ - local slice _result__________________________________________________ - local slice _result____________________________________________________ - local slice _result______________________________________________________ - local slice _result________________________________________________________ - local { [u64; 0] } args - local { [u64; 1] } args_ - local { [u64; 16] } args__ - local { [u64; 32] } args___ - local { [u64; 64] } args____ - local { [u64; 8] } args_____ - local { b256 } args______ - local { bool } args_______ - local { { u64, ( u64 ) } } args________ - local { { u64, ( u64 | u64 ) } } args_________ - local { { u64, ( u64 | u64 | u64 ) } } args__________ - local { string<0> } args___________ - local { string<1> } args____________ - local { string<16> } args_____________ - local { string<32> } args______________ - local { string<8> } args_______________ - local { { u64 } } args________________ - local { { u64, u64 } } args_________________ - local { { u64, u64, u64 } } args__________________ - local { () } args___________________ - local { { u64 } } args____________________ - local { { u64, u64 } } args_____________________ - local { { u64, u64, u64 } } args______________________ - local { { u64, u64, u64, u64 } } args_______________________ - local { u64 } args________________________ - local { u256 } args_________________________ - local { u64 } args__________________________ - local { u64 } args___________________________ - local { u8 } args____________________________ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer10 - local { { ptr, u64, u64 } } buffer11 - local { { ptr, u64, u64 } } buffer12 - local { { ptr, u64, u64 } } buffer13 - local { { ptr, u64, u64 } } buffer14 - local { { ptr, u64, u64 } } buffer15 - local { { ptr, u64, u64 } } buffer16 - local { { ptr, u64, u64 } } buffer17 - local { { ptr, u64, u64 } } buffer18 - local { { ptr, u64, u64 } } buffer19 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer20 - local { { ptr, u64, u64 } } buffer21 - local { { ptr, u64, u64 } } buffer22 - local { { ptr, u64, u64 } } buffer23 - local { { ptr, u64, u64 } } buffer24 - local { { ptr, u64, u64 } } buffer25 - local { { ptr, u64, u64 } } buffer26 - local { { ptr, u64, u64 } } buffer27 - local { { ptr, u64, u64 } } buffer28 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer5 - local { { ptr, u64, u64 } } buffer6 - local { { ptr, u64, u64 } } buffer7 - local { { ptr, u64, u64 } } buffer8 - local { { ptr, u64, u64 } } buffer9 - local slice data - local slice data0 - local slice data1 - local slice data2 - local slice data3 - local slice data4 - local [u64; 0] item_ - local [u64; 1] item_0 - local [u64; 16] item_1 - local { u64, ( u64 | u64 | u64 ) } item_10 - local string<0> item_11 - local string<1> item_12 - local string<16> item_13 - local string<32> item_14 - local string<8> item_15 - local { u64 } item_16 - local { u64, u64 } item_17 - local { u64, u64, u64 } item_18 - local { u64 } item_19 - local [u64; 32] item_2 - local { u64, u64 } item_20 - local { u64, u64, u64 } item_21 - local { u64, u64, u64, u64 } item_22 - local u256 item_24 - local [u64; 64] item_3 - local [u64; 8] item_4 - local [u64; 8] item_5 - local b256 item_6 - local { u64, ( u64 ) } item_8 - local { u64, ( u64 | u64 ) } item_9 - local slice self_ - local slice self_0 - local slice self_1 - local slice self_10 - local slice self_11 - local slice self_12 - local slice self_13 - local slice self_14 - local slice self_15 - local slice self_16 - local slice self_17 - local slice self_18 - local slice self_19 - local slice self_2 - local slice self_20 - local slice self_21 - local slice self_22 - local slice self_23 - local slice self_24 - local slice self_25 - local slice self_26 - local slice self_27 - local slice self_28 - local slice self_29 - local slice self_3 - local slice self_30 - local slice self_31 - local slice self_32 - local slice self_4 - local slice self_5 - local slice self_6 - local slice self_7 - local slice self_8 - local slice self_9 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_10 - local slice slice_11 - local slice slice_12 - local slice slice_13 - local slice slice_14 - local slice slice_15 - local slice slice_16 - local slice slice_17 - local slice slice_18 - local slice slice_19 - local slice slice_2 - local slice slice_20 - local slice slice_21 - local slice slice_22 - local slice slice_23 - local slice slice_24 - local slice slice_25 - local slice slice_26 - local slice slice_27 - local slice slice_28 - local slice slice_29 - local slice slice_3 - local slice slice_30 - local slice slice_31 - local slice slice_32 - local slice slice_4 - local slice slice_5 - local slice slice_6 - local slice slice_7 - local slice slice_8 - local slice slice_9 - local [u64; 0] v_ - local [u64; 1] v_0 - local [u64; 16] v_1 - local string<0> v_10 - local string<1> v_11 - local string<16> v_12 - local string<32> v_13 - local string<8> v_14 - local { u64 } v_15 - local { u64, u64 } v_16 - local { u64, u64, u64 } v_17 - local { u64 } v_19 - local [u64; 32] v_2 - local { u64, u64 } v_20 - local { u64, u64, u64 } v_21 - local { u64, u64, u64, u64 } v_22 - local u256 v_24 - local [u64; 64] v_3 - local [u64; 8] v_4 - local b256 v_5 - local { u64, ( u64 ) } v_7 - local { u64, ( u64 | u64 ) } v_8 - local { u64, ( u64 | u64 | u64 ) } v_9 - - entry(): - v0 = asm() -> ptr fp, !8 { - } - v1 = const u64 592, !11 - v2 = add v0, v1, !12 - v3 = asm(ptr: v2, val) -> u64 val, !17 { - lw val ptr i0, !18 - } - v4 = asm(ptr: v3) -> ptr ptr, !20 { - } - v5 = get_local __ptr { ptr }, __anon_00, !22 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6, !23 - store v4 to v7, !24 - v8 = get_local __ptr { ptr }, _buffer, !25 - mem_copy_val v8, v5 - v9 = asm() -> ptr fp, !31 { - } - v10 = const u64 584, !34 - v11 = add v9, v10, !35 - v12 = asm(ptr: v11, val) -> u64 val, !38 { - lw val ptr i0, !18 - } - v13 = asm(ptr: v12) -> ptr ptr, !40 { - } - v14 = get_local __ptr { ptr }, __anon_01, !42 - v15 = const u64 0 - v16 = get_elem_ptr v14, __ptr ptr, v15, !43 - store v13 to v16, !44 - v17 = get_local __ptr { ptr }, buffer, !46 - mem_copy_val v17, v14 - v18 = get_local __ptr { ptr }, buffer, !48 - v19 = const u64 0 - v20 = get_elem_ptr v18, __ptr ptr, v19, !54 - v21 = load v20, !55 - v22 = asm(ptr: v21, val) -> u64 val, !57 { - lw val ptr i0, !58 - } - v23 = load v20, !55 - v24 = const u64 8, !55 - v25 = add v23, v24, !55 - store v25 to v20, !60 - v26 = get_local __ptr slice, __ret_val - v27 = call read_bytes_8(v18, v22, v26) - v28 = get_local __ptr slice, data, !62 - mem_copy_val v28, v26 - v29 = get_local __ptr slice, data, !64 - v30 = get_local __ptr slice, self_, !67 - mem_copy_val v30, v29 - v31 = get_local __ptr slice, self_, !70 - v32 = get_local __ptr slice, slice_, !73 - mem_copy_val v32, v31 - v33 = get_local __ptr slice, slice_, !75 - v34 = asm(ptr: v33) -> __ptr { ptr, u64 } ptr { - } - v35 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v35, v34 - v36 = get_local __ptr { ptr, u64 }, __anon_031, !67 - mem_copy_val v36, v35 - v37 = const u64 0 - v38 = get_elem_ptr v36, __ptr ptr, v37, !77 - v39 = get_local __ptr { ptr, u64 }, __anon_000, !79 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr ptr, v40, !80 - mem_copy_val v41, v38 - v42 = const u64 1 - v43 = get_elem_ptr v39, __ptr u64, v42, !81 - store v22 to v43, !82 - v44 = asm(s: v39) -> __ptr slice s { - } - v45 = get_local __ptr slice, __aggr_memcpy_00 - mem_copy_val v45, v44 - v46 = get_local __ptr slice, _method_name, !83 - mem_copy_val v46, v45 - v47 = get_local __ptr slice, _method_name, !84 - v48 = get_global __ptr string<10>, __const_global - v49 = cast_ptr v48 to ptr, !85 - v50 = get_local __ptr { ptr, u64 }, __anon_0, !85 - v51 = const u64 0 - v52 = get_elem_ptr v50, __ptr ptr, v51 - store v49 to v52, !85 - v53 = const u64 1 - v54 = get_elem_ptr v50, __ptr u64, v53 - v55 = const u64 10 - store v55 to v54, !85 - v56 = get_local __ptr slice, __anon_1, !85 - mem_copy_bytes v56, v50, 16 - v57 = get_local __ptr slice, __tmp_arg - mem_copy_val v57, v47 - v58 = get_local __ptr slice, __tmp_arg0 - mem_copy_val v58, v56 - v59 = call eq_11(v57, v58) - cbr v59, block0(), block1(), !86 - - block0(): - v60 = get_local __ptr { ptr }, _buffer, !87 - v61 = get_local __ptr [u64; 0], __ret_val5 - v62 = call abi_decode_18(v60, v61) - v63 = get_local __ptr { [u64; 0] }, __anon_02, !93 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr [u64; 0], v64, !94 - mem_copy_val v65, v61 - v66 = get_local __ptr { [u64; 0] }, args, !95 - mem_copy_val v66, v63 - v67 = get_local __ptr { [u64; 0] }, args, !96 - v68 = const u64 0 - v69 = get_elem_ptr v67, __ptr [u64; 0], v68, !97 - v70 = get_local __ptr [u64; 0], v_, !100 - mem_copy_val v70, v69 - v71 = get_local __ptr [u64; 0], v_, !103 - v72 = get_local __ptr [u64; 0], _result, !104 - mem_copy_val v72, v71 - v73 = get_local __ptr [u64; 0], _result, !105 - v74 = get_local __ptr [u64; 0], item_, !108 - mem_copy_val v74, v73 - v75 = get_local __ptr [u64; 0], item_, !110 - v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v77 = call new_21(v76) - v78 = get_local __ptr [u64; 0], __tmp_arg87 - mem_copy_val v78, v75 - v79 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg88 - mem_copy_val v79, v76 - v80 = get_local __ptr { { ptr, u64, u64 } }, __ret_val65 - v81 = call abi_encode_29(v78, v79, v80) - v82 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !112 - mem_copy_val v82, v80 - v83 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !114 - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg58 - mem_copy_val v84, v83 - v85 = get_local __ptr slice, __ret_val36 - v86 = call as_raw_slice_22(v84, v85) - v87 = get_local __ptr slice, _result_, !115 - mem_copy_val v87, v85 - v88 = get_local __ptr slice, _result_, !116 - v89 = get_local __ptr slice, self_0, !119 - mem_copy_val v89, v88 - v90 = get_local __ptr slice, self_0, !120 - v91 = get_local __ptr slice, slice_0, !121 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, slice_0, !122 - v93 = asm(ptr: v92) -> __ptr { ptr, u64 } ptr { - } - v94 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v94, v93 - v95 = get_local __ptr { ptr, u64 }, __anon_032, !119 - mem_copy_val v95, v94 - v96 = get_elem_ptr v95, __ptr ptr, v37, !123 - v97 = load v96, !119 - v98 = get_local __ptr slice, _result_, !124 - v99 = get_local __ptr slice, __tmp_arg89 - mem_copy_val v99, v98 - v100 = call len_30(v99) - retd v97 v100, !125 - - block1(): - v101 = get_local __ptr slice, _method_name, !126 - v102 = get_global __ptr string<10>, __const_global0 - v103 = cast_ptr v102 to ptr, !127 - v104 = get_local __ptr { ptr, u64 }, __anon_2, !127 - v105 = const u64 0 - v106 = get_elem_ptr v104, __ptr ptr, v105 - store v103 to v106, !127 - v107 = const u64 1 - v108 = get_elem_ptr v104, __ptr u64, v107 - v109 = const u64 10 - store v109 to v108, !127 - v110 = get_local __ptr slice, __anon_3, !127 - mem_copy_bytes v110, v104, 16 - v111 = get_local __ptr slice, __tmp_arg1 - mem_copy_val v111, v101 - v112 = get_local __ptr slice, __tmp_arg2 - mem_copy_val v112, v110 - v113 = call eq_11(v111, v112) - cbr v113, block3(), block4(), !128 - - block3(): - v114 = get_local __ptr { ptr }, _buffer, !129 - v115 = get_local __ptr [u64; 1], __ret_val66 - v116 = call abi_decode_34(v114, v115) - v117 = get_local __ptr { [u64; 1] }, __anon_03, !132 - v118 = const u64 0 - v119 = get_elem_ptr v117, __ptr [u64; 1], v118, !133 - mem_copy_val v119, v115 - v120 = get_local __ptr { [u64; 1] }, args_, !134 - mem_copy_val v120, v117 - v121 = get_local __ptr { [u64; 1] }, args_, !135 - v122 = const u64 0 - v123 = get_elem_ptr v121, __ptr [u64; 1], v122, !136 - v124 = get_local __ptr [u64; 1], v_0, !139 - mem_copy_val v124, v123 - v125 = get_local __ptr [u64; 1], v_0, !141 - v126 = get_local __ptr [u64; 1], _result__, !142 - mem_copy_val v126, v125 - v127 = get_local __ptr [u64; 1], _result__, !143 - v128 = get_local __ptr [u64; 1], item_0, !146 - mem_copy_val v128, v127 - v129 = get_local __ptr [u64; 1], item_0, !147 - v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v131 = call new_21(v130) - v132 = get_local __ptr [u64; 1], __tmp_arg117 - mem_copy_val v132, v129 - v133 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg118 - mem_copy_val v133, v130 - v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val67 - v135 = call abi_encode_37(v132, v133, v134) - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !148 - mem_copy_val v136, v134 - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !149 - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg59 - mem_copy_val v138, v137 - v139 = get_local __ptr slice, __ret_val37 - v140 = call as_raw_slice_22(v138, v139) - v141 = get_local __ptr slice, _result___, !150 - mem_copy_val v141, v139 - v142 = get_local __ptr slice, _result___, !151 - v143 = get_local __ptr slice, self_1, !154 - mem_copy_val v143, v142 - v144 = get_local __ptr slice, self_1, !155 - v145 = get_local __ptr slice, slice_1, !156 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, slice_1, !157 - v147 = asm(ptr: v146) -> __ptr { ptr, u64 } ptr { - } - v148 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v148, v147 - v149 = get_local __ptr { ptr, u64 }, __anon_033, !154 - mem_copy_val v149, v148 - v150 = get_elem_ptr v149, __ptr ptr, v37, !158 - v151 = load v150, !154 - v152 = get_local __ptr slice, _result___, !159 - v153 = get_local __ptr slice, __tmp_arg90 - mem_copy_val v153, v152 - v154 = call len_30(v153) - retd v151 v154, !160 - - block4(): - v155 = get_local __ptr slice, _method_name, !161 - v156 = get_global __ptr string<11>, __const_global1 - v157 = cast_ptr v156 to ptr, !162 - v158 = get_local __ptr { ptr, u64 }, __anon_4, !162 - v159 = const u64 0 - v160 = get_elem_ptr v158, __ptr ptr, v159 - store v157 to v160, !162 - v161 = const u64 1 - v162 = get_elem_ptr v158, __ptr u64, v161 - v163 = const u64 11 - store v163 to v162, !162 - v164 = get_local __ptr slice, __anon_5, !162 - mem_copy_bytes v164, v158, 16 - v165 = get_local __ptr slice, __tmp_arg3 - mem_copy_val v165, v155 - v166 = get_local __ptr slice, __tmp_arg4 - mem_copy_val v166, v164 - v167 = call eq_11(v165, v166) - cbr v167, block6(), block7(), !163 - - block6(): - v168 = get_local __ptr { ptr }, _buffer, !164 - v169 = get_local __ptr [u64; 16], __ret_val68 - v170 = call abi_decode_40(v168, v169) - v171 = get_local __ptr { [u64; 16] }, __anon_04, !167 - v172 = const u64 0 - v173 = get_elem_ptr v171, __ptr [u64; 16], v172, !168 - mem_copy_val v173, v169 - v174 = get_local __ptr { [u64; 16] }, args__, !169 - mem_copy_val v174, v171 - v175 = get_local __ptr { [u64; 16] }, args__, !170 - v176 = const u64 0 - v177 = get_elem_ptr v175, __ptr [u64; 16], v176, !171 - v178 = get_local __ptr [u64; 16], v_1, !174 - mem_copy_val v178, v177 - v179 = get_local __ptr [u64; 16], v_1, !176 - v180 = get_local __ptr [u64; 16], _result____, !177 - mem_copy_val v180, v179 - v181 = get_local __ptr [u64; 16], _result____, !178 - v182 = get_local __ptr [u64; 16], item_1, !181 - mem_copy_val v182, v181 - v183 = get_local __ptr [u64; 16], item_1, !182 - v184 = get_local __ptr { { ptr, u64, u64 } }, __ret_val9 - v185 = call new_21(v184) - v186 = get_local __ptr [u64; 16], __tmp_arg119 - mem_copy_val v186, v183 - v187 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg120 - mem_copy_val v187, v184 - v188 = get_local __ptr { { ptr, u64, u64 } }, __ret_val69 - v189 = call abi_encode_43(v186, v187, v188) - v190 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !183 - mem_copy_val v190, v188 - v191 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !184 - v192 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg60 - mem_copy_val v192, v191 - v193 = get_local __ptr slice, __ret_val38 - v194 = call as_raw_slice_22(v192, v193) - v195 = get_local __ptr slice, _result_____, !185 - mem_copy_val v195, v193 - v196 = get_local __ptr slice, _result_____, !186 - v197 = get_local __ptr slice, self_2, !189 - mem_copy_val v197, v196 - v198 = get_local __ptr slice, self_2, !190 - v199 = get_local __ptr slice, slice_2, !191 - mem_copy_val v199, v198 - v200 = get_local __ptr slice, slice_2, !192 - v201 = asm(ptr: v200) -> __ptr { ptr, u64 } ptr { - } - v202 = get_local __ptr { ptr, u64 }, __aggr_memcpy_03 - mem_copy_val v202, v201 - v203 = get_local __ptr { ptr, u64 }, __anon_034, !189 - mem_copy_val v203, v202 - v204 = get_elem_ptr v203, __ptr ptr, v37, !193 - v205 = load v204, !189 - v206 = get_local __ptr slice, _result_____, !194 - v207 = get_local __ptr slice, __tmp_arg91 - mem_copy_val v207, v206 - v208 = call len_30(v207) - retd v205 v208, !195 - - block7(): - v209 = get_local __ptr slice, _method_name, !196 - v210 = get_global __ptr string<11>, __const_global2 - v211 = cast_ptr v210 to ptr, !197 - v212 = get_local __ptr { ptr, u64 }, __anon_6, !197 - v213 = const u64 0 - v214 = get_elem_ptr v212, __ptr ptr, v213 - store v211 to v214, !197 - v215 = const u64 1 - v216 = get_elem_ptr v212, __ptr u64, v215 - v217 = const u64 11 - store v217 to v216, !197 - v218 = get_local __ptr slice, __anon_7, !197 - mem_copy_bytes v218, v212, 16 - v219 = get_local __ptr slice, __tmp_arg5 - mem_copy_val v219, v209 - v220 = get_local __ptr slice, __tmp_arg6 - mem_copy_val v220, v218 - v221 = call eq_11(v219, v220) - cbr v221, block9(), block10(), !198 - - block9(): - v222 = get_local __ptr { ptr }, _buffer, !199 - v223 = get_local __ptr [u64; 32], __ret_val70 - v224 = call abi_decode_46(v222, v223) - v225 = get_local __ptr { [u64; 32] }, __anon_05, !202 - v226 = const u64 0 - v227 = get_elem_ptr v225, __ptr [u64; 32], v226, !203 - mem_copy_val v227, v223 - v228 = get_local __ptr { [u64; 32] }, args___, !204 - mem_copy_val v228, v225 - v229 = get_local __ptr { [u64; 32] }, args___, !205 - v230 = const u64 0 - v231 = get_elem_ptr v229, __ptr [u64; 32], v230, !206 - v232 = get_local __ptr [u64; 32], v_2, !209 - mem_copy_val v232, v231 - v233 = get_local __ptr [u64; 32], v_2, !211 - v234 = get_local __ptr [u64; 32], _result______, !212 - mem_copy_val v234, v233 - v235 = get_local __ptr [u64; 32], _result______, !213 - v236 = get_local __ptr [u64; 32], item_2, !216 - mem_copy_val v236, v235 - v237 = get_local __ptr [u64; 32], item_2, !217 - v238 = get_local __ptr { { ptr, u64, u64 } }, __ret_val10 - v239 = call new_21(v238) - v240 = get_local __ptr [u64; 32], __tmp_arg121 - mem_copy_val v240, v237 - v241 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg122 - mem_copy_val v241, v238 - v242 = get_local __ptr { { ptr, u64, u64 } }, __ret_val71 - v243 = call abi_encode_49(v240, v241, v242) - v244 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !218 - mem_copy_val v244, v242 - v245 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !219 - v246 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg61 - mem_copy_val v246, v245 - v247 = get_local __ptr slice, __ret_val39 - v248 = call as_raw_slice_22(v246, v247) - v249 = get_local __ptr slice, _result_______, !220 - mem_copy_val v249, v247 - v250 = get_local __ptr slice, _result_______, !221 - v251 = get_local __ptr slice, self_3, !224 - mem_copy_val v251, v250 - v252 = get_local __ptr slice, self_3, !225 - v253 = get_local __ptr slice, slice_3, !226 - mem_copy_val v253, v252 - v254 = get_local __ptr slice, slice_3, !227 - v255 = asm(ptr: v254) -> __ptr { ptr, u64 } ptr { - } - v256 = get_local __ptr { ptr, u64 }, __aggr_memcpy_04 - mem_copy_val v256, v255 - v257 = get_local __ptr { ptr, u64 }, __anon_035, !224 - mem_copy_val v257, v256 - v258 = get_elem_ptr v257, __ptr ptr, v37, !228 - v259 = load v258, !224 - v260 = get_local __ptr slice, _result_______, !229 - v261 = get_local __ptr slice, __tmp_arg92 - mem_copy_val v261, v260 - v262 = call len_30(v261) - retd v259 v262, !230 - - block10(): - v263 = get_local __ptr slice, _method_name, !231 - v264 = get_global __ptr string<11>, __const_global3 - v265 = cast_ptr v264 to ptr, !232 - v266 = get_local __ptr { ptr, u64 }, __anon_8, !232 - v267 = const u64 0 - v268 = get_elem_ptr v266, __ptr ptr, v267 - store v265 to v268, !232 - v269 = const u64 1 - v270 = get_elem_ptr v266, __ptr u64, v269 - v271 = const u64 11 - store v271 to v270, !232 - v272 = get_local __ptr slice, __anon_9, !232 - mem_copy_bytes v272, v266, 16 - v273 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v273, v263 - v274 = get_local __ptr slice, __tmp_arg8 - mem_copy_val v274, v272 - v275 = call eq_11(v273, v274) - cbr v275, block12(), block13(), !233 - - block12(): - v276 = get_local __ptr { ptr }, _buffer, !234 - v277 = get_local __ptr [u64; 64], __ret_val72 - v278 = call abi_decode_52(v276, v277) - v279 = get_local __ptr { [u64; 64] }, __anon_06, !237 - v280 = const u64 0 - v281 = get_elem_ptr v279, __ptr [u64; 64], v280, !238 - mem_copy_val v281, v277 - v282 = get_local __ptr { [u64; 64] }, args____, !239 - mem_copy_val v282, v279 - v283 = get_local __ptr { [u64; 64] }, args____, !240 - v284 = const u64 0 - v285 = get_elem_ptr v283, __ptr [u64; 64], v284, !241 - v286 = get_local __ptr [u64; 64], v_3, !244 - mem_copy_val v286, v285 - v287 = get_local __ptr [u64; 64], v_3, !246 - v288 = get_local __ptr [u64; 64], _result________, !247 - mem_copy_val v288, v287 - v289 = get_local __ptr [u64; 64], _result________, !248 - v290 = get_local __ptr [u64; 64], item_3, !251 - mem_copy_val v290, v289 - v291 = get_local __ptr [u64; 64], item_3, !252 - v292 = get_local __ptr { { ptr, u64, u64 } }, __ret_val11 - v293 = call new_21(v292) - v294 = get_local __ptr [u64; 64], __tmp_arg123 - mem_copy_val v294, v291 - v295 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg124 - mem_copy_val v295, v292 - v296 = get_local __ptr { { ptr, u64, u64 } }, __ret_val73 - v297 = call abi_encode_55(v294, v295, v296) - v298 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !253 - mem_copy_val v298, v296 - v299 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !254 - v300 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg62 - mem_copy_val v300, v299 - v301 = get_local __ptr slice, __ret_val40 - v302 = call as_raw_slice_22(v300, v301) - v303 = get_local __ptr slice, _result_________, !255 - mem_copy_val v303, v301 - v304 = get_local __ptr slice, _result_________, !256 - v305 = get_local __ptr slice, self_4, !259 - mem_copy_val v305, v304 - v306 = get_local __ptr slice, self_4, !260 - v307 = get_local __ptr slice, slice_4, !261 - mem_copy_val v307, v306 - v308 = get_local __ptr slice, slice_4, !262 - v309 = asm(ptr: v308) -> __ptr { ptr, u64 } ptr { - } - v310 = get_local __ptr { ptr, u64 }, __aggr_memcpy_05 - mem_copy_val v310, v309 - v311 = get_local __ptr { ptr, u64 }, __anon_036, !259 - mem_copy_val v311, v310 - v312 = get_elem_ptr v311, __ptr ptr, v37, !263 - v313 = load v312, !259 - v314 = get_local __ptr slice, _result_________, !264 - v315 = get_local __ptr slice, __tmp_arg93 - mem_copy_val v315, v314 - v316 = call len_30(v315) - retd v313 v316, !265 - - block13(): - v317 = get_local __ptr slice, _method_name, !266 - v318 = get_global __ptr string<10>, __const_global4 - v319 = cast_ptr v318 to ptr, !267 - v320 = get_local __ptr { ptr, u64 }, __anon_10, !267 - v321 = const u64 0 - v322 = get_elem_ptr v320, __ptr ptr, v321 - store v319 to v322, !267 - v323 = const u64 1 - v324 = get_elem_ptr v320, __ptr u64, v323 - v325 = const u64 10 - store v325 to v324, !267 - v326 = get_local __ptr slice, __anon_11, !267 - mem_copy_bytes v326, v320, 16 - v327 = get_local __ptr slice, __tmp_arg9 - mem_copy_val v327, v317 - v328 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v328, v326 - v329 = call eq_11(v327, v328) - cbr v329, block15(), block16(), !268 - - block15(): - v330 = get_local __ptr { ptr }, _buffer, !269 - v331 = get_local __ptr [u64; 8], __ret_val74 - v332 = call abi_decode_58(v330, v331) - v333 = get_local __ptr { [u64; 8] }, __anon_07, !272 - v334 = const u64 0 - v335 = get_elem_ptr v333, __ptr [u64; 8], v334, !273 - mem_copy_val v335, v331 - v336 = get_local __ptr { [u64; 8] }, args_____, !274 - mem_copy_val v336, v333 - v337 = get_local __ptr { [u64; 8] }, args_____, !275 - v338 = const u64 0 - v339 = get_elem_ptr v337, __ptr [u64; 8], v338, !276 - v340 = get_local __ptr [u64; 8], v_4, !279 - mem_copy_val v340, v339 - v341 = get_local __ptr [u64; 8], v_4, !281 - v342 = get_local __ptr [u64; 8], item_4, !282 - mem_copy_val v342, v341 - v343 = get_local __ptr [u64; 8], item_4, !283 - v344 = get_local __ptr { { ptr, u64, u64 } }, __ret_val12 - v345 = call new_21(v344) - v346 = get_local __ptr [u64; 8], __tmp_arg125 - mem_copy_val v346, v343 - v347 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg126 - mem_copy_val v347, v344 - v348 = get_local __ptr { { ptr, u64, u64 } }, __ret_val75 - v349 = call abi_encode_61(v346, v347, v348) - v350 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !284 - mem_copy_val v350, v348 - v351 = get_local __ptr { { ptr, u64, u64 } }, buffer5, !285 - v352 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg63 - mem_copy_val v352, v351 - v353 = get_local __ptr slice, __ret_val41 - v354 = call as_raw_slice_22(v352, v353) - v355 = get_local __ptr slice, __log_arg - mem_copy_val v355, v353 - v356 = const u64 3565715504387854074 - log __ptr slice v355, v356 - v357 = get_local __ptr [u64; 8], v_4, !287 - v358 = get_local __ptr [u64; 8], _result__________, !288 - mem_copy_val v358, v357 - v359 = get_local __ptr [u64; 8], _result__________, !289 - v360 = get_local __ptr [u64; 8], item_5, !292 - mem_copy_val v360, v359 - v361 = get_local __ptr [u64; 8], item_5, !293 - v362 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v363 = call new_21(v362) - v364 = get_local __ptr [u64; 8], __tmp_arg127 - mem_copy_val v364, v361 - v365 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg128 - mem_copy_val v365, v362 - v366 = get_local __ptr { { ptr, u64, u64 } }, __ret_val76 - v367 = call abi_encode_61(v364, v365, v366) - v368 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !294 - mem_copy_val v368, v366 - v369 = get_local __ptr { { ptr, u64, u64 } }, buffer6, !295 - v370 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg64 - mem_copy_val v370, v369 - v371 = get_local __ptr slice, __ret_val42 - v372 = call as_raw_slice_22(v370, v371) - v373 = get_local __ptr slice, _result___________, !296 - mem_copy_val v373, v371 - v374 = get_local __ptr slice, _result___________, !297 - v375 = get_local __ptr slice, self_5, !300 - mem_copy_val v375, v374 - v376 = get_local __ptr slice, self_5, !301 - v377 = get_local __ptr slice, slice_5, !302 - mem_copy_val v377, v376 - v378 = get_local __ptr slice, slice_5, !303 - v379 = asm(ptr: v378) -> __ptr { ptr, u64 } ptr { - } - v380 = get_local __ptr { ptr, u64 }, __aggr_memcpy_06 - mem_copy_val v380, v379 - v381 = get_local __ptr { ptr, u64 }, __anon_037, !300 - mem_copy_val v381, v380 - v382 = get_elem_ptr v381, __ptr ptr, v37, !304 - v383 = load v382, !300 - v384 = get_local __ptr slice, _result___________, !305 - v385 = get_local __ptr slice, __tmp_arg94 - mem_copy_val v385, v384 - v386 = call len_30(v385) - retd v383 v386, !306 - - block16(): - v387 = get_local __ptr slice, _method_name, !307 - v388 = get_global __ptr string<7>, __const_global5 - v389 = cast_ptr v388 to ptr, !308 - v390 = get_local __ptr { ptr, u64 }, __anon_12, !308 - v391 = const u64 0 - v392 = get_elem_ptr v390, __ptr ptr, v391 - store v389 to v392, !308 - v393 = const u64 1 - v394 = get_elem_ptr v390, __ptr u64, v393 - v395 = const u64 7 - store v395 to v394, !308 - v396 = get_local __ptr slice, __anon_13, !308 - mem_copy_bytes v396, v390, 16 - v397 = get_local __ptr slice, __tmp_arg11 - mem_copy_val v397, v387 - v398 = get_local __ptr slice, __tmp_arg12 - mem_copy_val v398, v396 - v399 = call eq_11(v397, v398) - cbr v399, block18(), block19(), !309 - - block18(): - v400 = get_local __ptr { ptr }, _buffer, !310 - v401 = get_local __ptr b256, __ret_val77 - v402 = call abi_decode_64(v400, v401) - v403 = get_local __ptr { b256 }, __anon_08, !313 - v404 = const u64 0 - v405 = get_elem_ptr v403, __ptr b256, v404, !314 - mem_copy_val v405, v401 - v406 = get_local __ptr { b256 }, args______, !315 - mem_copy_val v406, v403 - v407 = get_local __ptr { b256 }, args______, !316 - v408 = const u64 0 - v409 = get_elem_ptr v407, __ptr b256, v408, !317 - v410 = get_local __ptr b256, v_5, !320 - mem_copy_val v410, v409 - v411 = get_local __ptr b256, v_5, !322 - v412 = get_local __ptr b256, _result____________, !323 - mem_copy_val v412, v411 - v413 = get_local __ptr b256, _result____________, !324 - v414 = get_local __ptr b256, item_6, !327 - mem_copy_val v414, v413 - v415 = get_local __ptr b256, item_6, !328 - v416 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v417 = call new_21(v416) - v418 = get_local __ptr b256, __tmp_arg129 - mem_copy_val v418, v415 - v419 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg130 - mem_copy_val v419, v416 - v420 = get_local __ptr { { ptr, u64, u64 } }, __ret_val78 - v421 = call abi_encode_68(v418, v419, v420) - v422 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !329 - mem_copy_val v422, v420 - v423 = get_local __ptr { { ptr, u64, u64 } }, buffer7, !330 - v424 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg65 - mem_copy_val v424, v423 - v425 = get_local __ptr slice, __ret_val43 - v426 = call as_raw_slice_22(v424, v425) - v427 = get_local __ptr slice, _result_____________, !331 - mem_copy_val v427, v425 - v428 = get_local __ptr slice, _result_____________, !332 - v429 = get_local __ptr slice, self_6, !335 - mem_copy_val v429, v428 - v430 = get_local __ptr slice, self_6, !336 - v431 = get_local __ptr slice, slice_6, !337 - mem_copy_val v431, v430 - v432 = get_local __ptr slice, slice_6, !338 - v433 = asm(ptr: v432) -> __ptr { ptr, u64 } ptr { - } - v434 = get_local __ptr { ptr, u64 }, __aggr_memcpy_07 - mem_copy_val v434, v433 - v435 = get_local __ptr { ptr, u64 }, __anon_038, !335 - mem_copy_val v435, v434 - v436 = get_elem_ptr v435, __ptr ptr, v37, !339 - v437 = load v436, !335 - v438 = get_local __ptr slice, _result_____________, !340 - v439 = get_local __ptr slice, __tmp_arg95 - mem_copy_val v439, v438 - v440 = call len_30(v439) - retd v437 v440, !341 - - block19(): - v441 = get_local __ptr slice, _method_name, !342 - v442 = get_global __ptr string<7>, __const_global6 - v443 = cast_ptr v442 to ptr, !343 - v444 = get_local __ptr { ptr, u64 }, __anon_14, !343 - v445 = const u64 0 - v446 = get_elem_ptr v444, __ptr ptr, v445 - store v443 to v446, !343 - v447 = const u64 1 - v448 = get_elem_ptr v444, __ptr u64, v447 - v449 = const u64 7 - store v449 to v448, !343 - v450 = get_local __ptr slice, __anon_15, !343 - mem_copy_bytes v450, v444, 16 - v451 = get_local __ptr slice, __tmp_arg13 - mem_copy_val v451, v441 - v452 = get_local __ptr slice, __tmp_arg14 - mem_copy_val v452, v450 - v453 = call eq_11(v451, v452) - cbr v453, block21(), block22(), !344 - - block21(): - v454 = get_local __ptr { ptr }, _buffer, !345 - v455 = call read_72(v454), !352 - v456 = const u8 0, !353 - v457 = cmp eq v455 v456, !356 - v458 = const bool false, !357 - cbr v457, abi_decode_71_block5(v458), abi_decode_71_block1(), !358 - - abi_decode_71_block1(): - v459 = const u8 1, !359 - v460 = cmp eq v455 v459, !362 - v461 = const bool true, !363 - cbr v460, abi_decode_71_block5(v461), abi_decode_71_block3(), !364 - - abi_decode_71_block3(): - v462 = const u64 0, !365 - revert v462, !367 - - abi_decode_71_block5(v463: bool): - v464 = get_local __ptr { bool }, __anon_09, !368 - v465 = const u64 0 - v466 = get_elem_ptr v464, __ptr bool, v465, !369 - store v463 to v466, !370 - v467 = get_local __ptr { bool }, args_______, !371 - mem_copy_val v467, v464 - v468 = get_local __ptr { bool }, args_______, !372 - v469 = const u64 0 - v470 = get_elem_ptr v468, __ptr bool, v469, !373 - v471 = load v470 - v472 = get_local __ptr { { ptr, u64, u64 } }, __ret_val15 - v473 = call new_21(v472) - v474 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg131 - mem_copy_val v474, v472 - v475 = get_local __ptr { { ptr, u64, u64 } }, __ret_val79 - v476 = call abi_encode_77(v471, v474, v475) - v477 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !376 - mem_copy_val v477, v475 - v478 = get_local __ptr { { ptr, u64, u64 } }, buffer8, !377 - v479 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg66 - mem_copy_val v479, v478 - v480 = get_local __ptr slice, __ret_val44 - v481 = call as_raw_slice_22(v479, v480) - v482 = get_local __ptr slice, _result_______________, !378 - mem_copy_val v482, v480 - v483 = get_local __ptr slice, _result_______________, !379 - v484 = get_local __ptr slice, self_7, !382 - mem_copy_val v484, v483 - v485 = get_local __ptr slice, self_7, !383 - v486 = get_local __ptr slice, slice_7, !384 - mem_copy_val v486, v485 - v487 = get_local __ptr slice, slice_7, !385 - v488 = asm(ptr: v487) -> __ptr { ptr, u64 } ptr { - } - v489 = get_local __ptr { ptr, u64 }, __aggr_memcpy_08 - mem_copy_val v489, v488 - v490 = get_local __ptr { ptr, u64 }, __anon_039, !382 - mem_copy_val v490, v489 - v491 = get_elem_ptr v490, __ptr ptr, v37, !386 - v492 = load v491, !382 - v493 = get_local __ptr slice, _result_______________, !387 - v494 = get_local __ptr slice, __tmp_arg96 - mem_copy_val v494, v493 - v495 = call len_30(v494) - retd v492 v495, !388 - - block22(): - v496 = get_local __ptr slice, _method_name, !389 - v497 = get_global __ptr string<11>, __const_global7 - v498 = cast_ptr v497 to ptr, !390 - v499 = get_local __ptr { ptr, u64 }, __anon_16, !390 - v500 = const u64 0 - v501 = get_elem_ptr v499, __ptr ptr, v500 - store v498 to v501, !390 - v502 = const u64 1 - v503 = get_elem_ptr v499, __ptr u64, v502 - v504 = const u64 11 - store v504 to v503, !390 - v505 = get_local __ptr slice, __anon_17, !390 - mem_copy_bytes v505, v499, 16 - v506 = get_local __ptr slice, __tmp_arg15 - mem_copy_val v506, v496 - v507 = get_local __ptr slice, __tmp_arg16 - mem_copy_val v507, v505 - v508 = call eq_11(v506, v507) - cbr v508, block24(), block25(), !391 - - block24(): - v509 = get_local __ptr { ptr }, _buffer, !392 - v510 = get_local __ptr { u64, ( u64 ) }, __ret_val80 - v511 = call abi_decode_80(v509, v510) - v512 = get_local __ptr { { u64, ( u64 ) } }, __anon_010, !395 - v513 = const u64 0 - v514 = get_elem_ptr v512, __ptr { u64, ( u64 ) }, v513, !396 - mem_copy_val v514, v510 - v515 = get_local __ptr { { u64, ( u64 ) } }, args________, !397 - mem_copy_val v515, v512 - v516 = get_local __ptr { { u64, ( u64 ) } }, args________, !398 - v517 = const u64 0 - v518 = get_elem_ptr v516, __ptr { u64, ( u64 ) }, v517, !399 - v519 = get_local __ptr { u64, ( u64 ) }, v_7, !402 - mem_copy_val v519, v518 - v520 = get_local __ptr { u64, ( u64 ) }, v_7, !404 - v521 = get_local __ptr { u64, ( u64 ) }, _result________________, !405 - mem_copy_val v521, v520 - v522 = get_local __ptr { u64, ( u64 ) }, _result________________, !406 - v523 = get_local __ptr { u64, ( u64 ) }, item_8, !409 - mem_copy_val v523, v522 - v524 = get_local __ptr { u64, ( u64 ) }, item_8, !410 - v525 = get_local __ptr { { ptr, u64, u64 } }, __ret_val16 - v526 = call new_21(v525) - v527 = get_local __ptr { u64, ( u64 ) }, __tmp_arg132 - mem_copy_val v527, v524 - v528 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg133 - mem_copy_val v528, v525 - v529 = get_local __ptr { { ptr, u64, u64 } }, __ret_val81 - v530 = call abi_encode_83(v527, v528, v529) - v531 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !411 - mem_copy_val v531, v529 - v532 = get_local __ptr { { ptr, u64, u64 } }, buffer9, !412 - v533 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg67 - mem_copy_val v533, v532 - v534 = get_local __ptr slice, __ret_val45 - v535 = call as_raw_slice_22(v533, v534) - v536 = get_local __ptr slice, _result_________________, !413 - mem_copy_val v536, v534 - v537 = get_local __ptr slice, _result_________________, !414 - v538 = get_local __ptr slice, self_8, !417 - mem_copy_val v538, v537 - v539 = get_local __ptr slice, self_8, !418 - v540 = get_local __ptr slice, slice_8, !419 - mem_copy_val v540, v539 - v541 = get_local __ptr slice, slice_8, !420 - v542 = asm(ptr: v541) -> __ptr { ptr, u64 } ptr { - } - v543 = get_local __ptr { ptr, u64 }, __aggr_memcpy_09 - mem_copy_val v543, v542 - v544 = get_local __ptr { ptr, u64 }, __anon_040, !417 - mem_copy_val v544, v543 - v545 = get_elem_ptr v544, __ptr ptr, v37, !421 - v546 = load v545, !417 - v547 = get_local __ptr slice, _result_________________, !422 - v548 = get_local __ptr slice, __tmp_arg97 - mem_copy_val v548, v547 - v549 = call len_30(v548) - retd v546 v549, !423 - - block25(): - v550 = get_local __ptr slice, _method_name, !424 - v551 = get_global __ptr string<15>, __const_global8 - v552 = cast_ptr v551 to ptr, !425 - v553 = get_local __ptr { ptr, u64 }, __anon_18, !425 - v554 = const u64 0 - v555 = get_elem_ptr v553, __ptr ptr, v554 - store v552 to v555, !425 - v556 = const u64 1 - v557 = get_elem_ptr v553, __ptr u64, v556 - v558 = const u64 15 - store v558 to v557, !425 - v559 = get_local __ptr slice, __anon_19, !425 - mem_copy_bytes v559, v553, 16 - v560 = get_local __ptr slice, __tmp_arg17 - mem_copy_val v560, v550 - v561 = get_local __ptr slice, __tmp_arg18 - mem_copy_val v561, v559 - v562 = call eq_11(v560, v561) - cbr v562, block27(), block28(), !426 - - block27(): - v563 = get_local __ptr { ptr }, _buffer, !427 - v564 = get_local __ptr { u64, ( u64 | u64 ) }, __ret_val82 - v565 = call abi_decode_86(v563, v564) - v566 = get_local __ptr { { u64, ( u64 | u64 ) } }, __anon_011, !430 - v567 = const u64 0 - v568 = get_elem_ptr v566, __ptr { u64, ( u64 | u64 ) }, v567, !431 - mem_copy_val v568, v564 - v569 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !432 - mem_copy_val v569, v566 - v570 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_________, !433 - v571 = const u64 0 - v572 = get_elem_ptr v570, __ptr { u64, ( u64 | u64 ) }, v571, !434 - v573 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !437 - mem_copy_val v573, v572 - v574 = get_local __ptr { u64, ( u64 | u64 ) }, v_8, !439 - v575 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !440 - mem_copy_val v575, v574 - v576 = get_local __ptr { u64, ( u64 | u64 ) }, _result__________________, !441 - v577 = get_local __ptr { u64, ( u64 | u64 ) }, item_9, !444 - mem_copy_val v577, v576 - v578 = get_local __ptr { u64, ( u64 | u64 ) }, item_9, !445 - v579 = get_local __ptr { { ptr, u64, u64 } }, __ret_val17 - v580 = call new_21(v579) - v581 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_arg134 - mem_copy_val v581, v578 - v582 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg135 - mem_copy_val v582, v579 - v583 = get_local __ptr { { ptr, u64, u64 } }, __ret_val83 - v584 = call abi_encode_89(v581, v582, v583) - v585 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !446 - mem_copy_val v585, v583 - v586 = get_local __ptr { { ptr, u64, u64 } }, buffer10, !447 - v587 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg68 - mem_copy_val v587, v586 - v588 = get_local __ptr slice, __ret_val46 - v589 = call as_raw_slice_22(v587, v588) - v590 = get_local __ptr slice, _result___________________, !448 - mem_copy_val v590, v588 - v591 = get_local __ptr slice, _result___________________, !449 - v592 = get_local __ptr slice, self_9, !452 - mem_copy_val v592, v591 - v593 = get_local __ptr slice, self_9, !453 - v594 = get_local __ptr slice, slice_9, !454 - mem_copy_val v594, v593 - v595 = get_local __ptr slice, slice_9, !455 - v596 = asm(ptr: v595) -> __ptr { ptr, u64 } ptr { - } - v597 = get_local __ptr { ptr, u64 }, __aggr_memcpy_010 - mem_copy_val v597, v596 - v598 = get_local __ptr { ptr, u64 }, __anon_041, !452 - mem_copy_val v598, v597 - v599 = get_elem_ptr v598, __ptr ptr, v37, !456 - v600 = load v599, !452 - v601 = get_local __ptr slice, _result___________________, !457 - v602 = get_local __ptr slice, __tmp_arg98 - mem_copy_val v602, v601 - v603 = call len_30(v602) - retd v600 v603, !458 - - block28(): - v604 = get_local __ptr slice, _method_name, !459 - v605 = get_global __ptr string<19>, __const_global9 - v606 = cast_ptr v605 to ptr, !460 - v607 = get_local __ptr { ptr, u64 }, __anon_20, !460 - v608 = const u64 0 - v609 = get_elem_ptr v607, __ptr ptr, v608 - store v606 to v609, !460 - v610 = const u64 1 - v611 = get_elem_ptr v607, __ptr u64, v610 - v612 = const u64 19 - store v612 to v611, !460 - v613 = get_local __ptr slice, __anon_21, !460 - mem_copy_bytes v613, v607, 16 - v614 = get_local __ptr slice, __tmp_arg19 - mem_copy_val v614, v604 - v615 = get_local __ptr slice, __tmp_arg20 - mem_copy_val v615, v613 - v616 = call eq_11(v614, v615) - cbr v616, block30(), block31(), !461 - - block30(): - v617 = get_local __ptr { ptr }, _buffer, !462 - v618 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __ret_val84 - v619 = call abi_decode_92(v617, v618) - v620 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, __anon_012, !465 - v621 = const u64 0 - v622 = get_elem_ptr v620, __ptr { u64, ( u64 | u64 | u64 ) }, v621, !466 - mem_copy_val v622, v618 - v623 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !467 - mem_copy_val v623, v620 - v624 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args__________, !468 - v625 = const u64 0 - v626 = get_elem_ptr v624, __ptr { u64, ( u64 | u64 | u64 ) }, v625, !469 - v627 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !472 - mem_copy_val v627, v626 - v628 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, v_9, !474 - v629 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !475 - mem_copy_val v629, v628 - v630 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _result____________________, !476 - v631 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_10, !479 - mem_copy_val v631, v630 - v632 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, item_10, !480 - v633 = get_local __ptr { { ptr, u64, u64 } }, __ret_val18 - v634 = call new_21(v633) - v635 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_arg136 - mem_copy_val v635, v632 - v636 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg137 - mem_copy_val v636, v633 - v637 = get_local __ptr { { ptr, u64, u64 } }, __ret_val85 - v638 = call abi_encode_95(v635, v636, v637) - v639 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !481 - mem_copy_val v639, v637 - v640 = get_local __ptr { { ptr, u64, u64 } }, buffer11, !482 - v641 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg69 - mem_copy_val v641, v640 - v642 = get_local __ptr slice, __ret_val47 - v643 = call as_raw_slice_22(v641, v642) - v644 = get_local __ptr slice, _result_____________________, !483 - mem_copy_val v644, v642 - v645 = get_local __ptr slice, _result_____________________, !484 - v646 = get_local __ptr slice, self_10, !487 - mem_copy_val v646, v645 - v647 = get_local __ptr slice, self_10, !488 - v648 = get_local __ptr slice, slice_10, !489 - mem_copy_val v648, v647 - v649 = get_local __ptr slice, slice_10, !490 - v650 = asm(ptr: v649) -> __ptr { ptr, u64 } ptr { - } - v651 = get_local __ptr { ptr, u64 }, __aggr_memcpy_011 - mem_copy_val v651, v650 - v652 = get_local __ptr { ptr, u64 }, __anon_042, !487 - mem_copy_val v652, v651 - v653 = get_elem_ptr v652, __ptr ptr, v37, !491 - v654 = load v653, !487 - v655 = get_local __ptr slice, _result_____________________, !492 - v656 = get_local __ptr slice, __tmp_arg99 - mem_copy_val v656, v655 - v657 = call len_30(v656) - retd v654 v657, !493 - - block31(): - v658 = get_local __ptr slice, _method_name, !494 - v659 = get_global __ptr string<8>, __const_global10 - v660 = cast_ptr v659 to ptr, !495 - v661 = get_local __ptr { ptr, u64 }, __anon_22, !495 - v662 = const u64 0 - v663 = get_elem_ptr v661, __ptr ptr, v662 - store v660 to v663, !495 - v664 = const u64 1 - v665 = get_elem_ptr v661, __ptr u64, v664 - v666 = const u64 8 - store v666 to v665, !495 - v667 = get_local __ptr slice, __anon_23, !495 - mem_copy_bytes v667, v661, 16 - v668 = get_local __ptr slice, __tmp_arg21 - mem_copy_val v668, v658 - v669 = get_local __ptr slice, __tmp_arg22 - mem_copy_val v669, v667 - v670 = call eq_11(v668, v669) - cbr v670, block33(), block34(), !496 - - block33(): - v671 = get_local __ptr { ptr }, _buffer, !497 - v672 = get_local __ptr slice, __ret_val0 - v673 = const u64 0 - v674 = call read_bytes_8(v671, v673, v672) - v675 = get_local __ptr slice, data0, !501 - mem_copy_val v675, v672 - v676 = get_local __ptr slice, data0, !503 - v677 = get_local __ptr slice, self_11, !506 - mem_copy_val v677, v676 - v678 = get_local __ptr slice, self_11, !507 - v679 = get_local __ptr slice, slice_11, !508 - mem_copy_val v679, v678 - v680 = get_local __ptr slice, slice_11, !509 - v681 = asm(ptr: v680) -> __ptr { ptr, u64 } ptr { - } - v682 = get_local __ptr { ptr, u64 }, __aggr_memcpy_012 - mem_copy_val v682, v681 - v683 = get_local __ptr { ptr, u64 }, __anon_043, !506 - mem_copy_val v683, v682 - v684 = get_elem_ptr v683, __ptr ptr, v37, !510 - v685 = load v684, !506 - v686 = asm(s: v685) -> __ptr string<0> s { - } - v687 = get_local __ptr string<0>, __aggr_memcpy_013 - mem_copy_val v687, v686 - v688 = get_local __ptr { string<0> }, __anon_013, !511 - v689 = const u64 0 - v690 = get_elem_ptr v688, __ptr string<0>, v689, !512 - mem_copy_val v690, v687 - v691 = get_local __ptr { string<0> }, args___________, !513 - mem_copy_val v691, v688 - v692 = get_local __ptr { string<0> }, args___________, !514 - v693 = const u64 0 - v694 = get_elem_ptr v692, __ptr string<0>, v693, !515 - v695 = get_local __ptr string<0>, v_10, !518 - mem_copy_val v695, v694 - v696 = get_local __ptr string<0>, v_10, !520 - v697 = get_local __ptr string<0>, _result______________________, !521 - mem_copy_val v697, v696 - v698 = get_local __ptr string<0>, _result______________________, !522 - v699 = get_local __ptr string<0>, item_11, !525 - mem_copy_val v699, v698 - v700 = get_local __ptr string<0>, item_11, !526 - v701 = get_local __ptr { { ptr, u64, u64 } }, __ret_val19 - v702 = call new_21(v701) - v703 = get_local __ptr string<0>, __tmp_arg138 - mem_copy_val v703, v700 - v704 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg139 - mem_copy_val v704, v701 - v705 = get_local __ptr { { ptr, u64, u64 } }, __ret_val86 - v706 = call abi_encode_101(v703, v704, v705) - v707 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !527 - mem_copy_val v707, v705 - v708 = get_local __ptr { { ptr, u64, u64 } }, buffer12, !528 - v709 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg70 - mem_copy_val v709, v708 - v710 = get_local __ptr slice, __ret_val48 - v711 = call as_raw_slice_22(v709, v710) - v712 = get_local __ptr slice, _result_______________________, !529 - mem_copy_val v712, v710 - v713 = get_local __ptr slice, _result_______________________, !530 - v714 = get_local __ptr slice, self_12, !533 - mem_copy_val v714, v713 - v715 = get_local __ptr slice, self_12, !534 - v716 = get_local __ptr slice, slice_12, !535 - mem_copy_val v716, v715 - v717 = get_local __ptr slice, slice_12, !536 - v718 = asm(ptr: v717) -> __ptr { ptr, u64 } ptr { - } - v719 = get_local __ptr { ptr, u64 }, __aggr_memcpy_014 - mem_copy_val v719, v718 - v720 = get_local __ptr { ptr, u64 }, __anon_044, !533 - mem_copy_val v720, v719 - v721 = get_elem_ptr v720, __ptr ptr, v37, !537 - v722 = load v721, !533 - v723 = get_local __ptr slice, _result_______________________, !538 - v724 = get_local __ptr slice, __tmp_arg100 - mem_copy_val v724, v723 - v725 = call len_30(v724) - retd v722 v725, !539 - - block34(): - v726 = get_local __ptr slice, _method_name, !540 - v727 = get_global __ptr string<8>, __const_global11 - v728 = cast_ptr v727 to ptr, !541 - v729 = get_local __ptr { ptr, u64 }, __anon_24, !541 - v730 = const u64 0 - v731 = get_elem_ptr v729, __ptr ptr, v730 - store v728 to v731, !541 - v732 = const u64 1 - v733 = get_elem_ptr v729, __ptr u64, v732 - v734 = const u64 8 - store v734 to v733, !541 - v735 = get_local __ptr slice, __anon_25, !541 - mem_copy_bytes v735, v729, 16 - v736 = get_local __ptr slice, __tmp_arg23 - mem_copy_val v736, v726 - v737 = get_local __ptr slice, __tmp_arg24 - mem_copy_val v737, v735 - v738 = call eq_11(v736, v737) - cbr v738, block36(), block37(), !542 - - block36(): - v739 = get_local __ptr { ptr }, _buffer, !543 - v740 = get_local __ptr slice, __ret_val1 - v741 = const u64 1 - v742 = call read_bytes_8(v739, v741, v740) - v743 = get_local __ptr slice, data1, !546 - mem_copy_val v743, v740 - v744 = get_local __ptr slice, data1, !547 - v745 = get_local __ptr slice, self_13, !548 - mem_copy_val v745, v744 - v746 = get_local __ptr slice, self_13, !549 - v747 = get_local __ptr slice, slice_13, !550 - mem_copy_val v747, v746 - v748 = get_local __ptr slice, slice_13, !551 - v749 = asm(ptr: v748) -> __ptr { ptr, u64 } ptr { - } - v750 = get_local __ptr { ptr, u64 }, __aggr_memcpy_015 - mem_copy_val v750, v749 - v751 = get_local __ptr { ptr, u64 }, __anon_045, !548 - mem_copy_val v751, v750 - v752 = get_elem_ptr v751, __ptr ptr, v37, !552 - v753 = load v752, !548 - v754 = asm(s: v753) -> __ptr string<1> s { - } - v755 = get_local __ptr string<1>, __aggr_memcpy_016 - mem_copy_val v755, v754 - v756 = get_local __ptr { string<1> }, __anon_014, !553 - v757 = const u64 0 - v758 = get_elem_ptr v756, __ptr string<1>, v757, !554 - mem_copy_val v758, v755 - v759 = get_local __ptr { string<1> }, args____________, !555 - mem_copy_val v759, v756 - v760 = get_local __ptr { string<1> }, args____________, !556 - v761 = const u64 0 - v762 = get_elem_ptr v760, __ptr string<1>, v761, !557 - v763 = get_local __ptr string<1>, v_11, !560 - mem_copy_val v763, v762 - v764 = get_local __ptr string<1>, v_11, !562 - v765 = get_local __ptr string<1>, _result________________________, !563 - mem_copy_val v765, v764 - v766 = get_local __ptr string<1>, _result________________________, !564 - v767 = get_local __ptr string<1>, item_12, !567 - mem_copy_val v767, v766 - v768 = get_local __ptr string<1>, item_12, !568 - v769 = get_local __ptr { { ptr, u64, u64 } }, __ret_val20 - v770 = call new_21(v769) - v771 = get_local __ptr string<1>, __tmp_arg140 - mem_copy_val v771, v768 - v772 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg141 - mem_copy_val v772, v769 - v773 = get_local __ptr { { ptr, u64, u64 } }, __ret_val87 - v774 = call abi_encode_107(v771, v772, v773) - v775 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !569 - mem_copy_val v775, v773 - v776 = get_local __ptr { { ptr, u64, u64 } }, buffer13, !570 - v777 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg71 - mem_copy_val v777, v776 - v778 = get_local __ptr slice, __ret_val49 - v779 = call as_raw_slice_22(v777, v778) - v780 = get_local __ptr slice, _result_________________________, !571 - mem_copy_val v780, v778 - v781 = get_local __ptr slice, _result_________________________, !572 - v782 = get_local __ptr slice, self_14, !575 - mem_copy_val v782, v781 - v783 = get_local __ptr slice, self_14, !576 - v784 = get_local __ptr slice, slice_14, !577 - mem_copy_val v784, v783 - v785 = get_local __ptr slice, slice_14, !578 - v786 = asm(ptr: v785) -> __ptr { ptr, u64 } ptr { - } - v787 = get_local __ptr { ptr, u64 }, __aggr_memcpy_017 - mem_copy_val v787, v786 - v788 = get_local __ptr { ptr, u64 }, __anon_046, !575 - mem_copy_val v788, v787 - v789 = get_elem_ptr v788, __ptr ptr, v37, !579 - v790 = load v789, !575 - v791 = get_local __ptr slice, _result_________________________, !580 - v792 = get_local __ptr slice, __tmp_arg101 - mem_copy_val v792, v791 - v793 = call len_30(v792) - retd v790 v793, !581 - - block37(): - v794 = get_local __ptr slice, _method_name, !582 - v795 = get_global __ptr string<9>, __const_global12 - v796 = cast_ptr v795 to ptr, !583 - v797 = get_local __ptr { ptr, u64 }, __anon_26, !583 - v798 = const u64 0 - v799 = get_elem_ptr v797, __ptr ptr, v798 - store v796 to v799, !583 - v800 = const u64 1 - v801 = get_elem_ptr v797, __ptr u64, v800 - v802 = const u64 9 - store v802 to v801, !583 - v803 = get_local __ptr slice, __anon_27, !583 - mem_copy_bytes v803, v797, 16 - v804 = get_local __ptr slice, __tmp_arg25 - mem_copy_val v804, v794 - v805 = get_local __ptr slice, __tmp_arg26 - mem_copy_val v805, v803 - v806 = call eq_11(v804, v805) - cbr v806, block39(), block40(), !584 - - block39(): - v807 = get_local __ptr { ptr }, _buffer, !585 - v808 = get_local __ptr slice, __ret_val2 - v809 = const u64 16 - v810 = call read_bytes_8(v807, v809, v808) - v811 = get_local __ptr slice, data2, !588 - mem_copy_val v811, v808 - v812 = get_local __ptr slice, data2, !589 - v813 = get_local __ptr slice, self_15, !590 - mem_copy_val v813, v812 - v814 = get_local __ptr slice, self_15, !591 - v815 = get_local __ptr slice, slice_15, !592 - mem_copy_val v815, v814 - v816 = get_local __ptr slice, slice_15, !593 - v817 = asm(ptr: v816) -> __ptr { ptr, u64 } ptr { - } - v818 = get_local __ptr { ptr, u64 }, __aggr_memcpy_018 - mem_copy_val v818, v817 - v819 = get_local __ptr { ptr, u64 }, __anon_047, !590 - mem_copy_val v819, v818 - v820 = get_elem_ptr v819, __ptr ptr, v37, !594 - v821 = load v820, !590 - v822 = asm(s: v821) -> __ptr string<16> s { - } - v823 = get_local __ptr string<16>, __aggr_memcpy_019 - mem_copy_val v823, v822 - v824 = get_local __ptr { string<16> }, __anon_015, !595 - v825 = const u64 0 - v826 = get_elem_ptr v824, __ptr string<16>, v825, !596 - mem_copy_val v826, v823 - v827 = get_local __ptr { string<16> }, args_____________, !597 - mem_copy_val v827, v824 - v828 = get_local __ptr { string<16> }, args_____________, !598 - v829 = const u64 0 - v830 = get_elem_ptr v828, __ptr string<16>, v829, !599 - v831 = get_local __ptr string<16>, v_12, !602 - mem_copy_val v831, v830 - v832 = get_local __ptr string<16>, v_12, !604 - v833 = get_local __ptr string<16>, _result__________________________, !605 - mem_copy_val v833, v832 - v834 = get_local __ptr string<16>, _result__________________________, !606 - v835 = get_local __ptr string<16>, item_13, !609 - mem_copy_val v835, v834 - v836 = get_local __ptr string<16>, item_13, !610 - v837 = get_local __ptr { { ptr, u64, u64 } }, __ret_val21 - v838 = call new_21(v837) - v839 = get_local __ptr string<16>, __tmp_arg142 - mem_copy_val v839, v836 - v840 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg143 - mem_copy_val v840, v837 - v841 = get_local __ptr { { ptr, u64, u64 } }, __ret_val88 - v842 = call abi_encode_113(v839, v840, v841) - v843 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !611 - mem_copy_val v843, v841 - v844 = get_local __ptr { { ptr, u64, u64 } }, buffer14, !612 - v845 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg72 - mem_copy_val v845, v844 - v846 = get_local __ptr slice, __ret_val50 - v847 = call as_raw_slice_22(v845, v846) - v848 = get_local __ptr slice, _result___________________________, !613 - mem_copy_val v848, v846 - v849 = get_local __ptr slice, _result___________________________, !614 - v850 = get_local __ptr slice, self_16, !617 - mem_copy_val v850, v849 - v851 = get_local __ptr slice, self_16, !618 - v852 = get_local __ptr slice, slice_16, !619 - mem_copy_val v852, v851 - v853 = get_local __ptr slice, slice_16, !620 - v854 = asm(ptr: v853) -> __ptr { ptr, u64 } ptr { - } - v855 = get_local __ptr { ptr, u64 }, __aggr_memcpy_020 - mem_copy_val v855, v854 - v856 = get_local __ptr { ptr, u64 }, __anon_048, !617 - mem_copy_val v856, v855 - v857 = get_elem_ptr v856, __ptr ptr, v37, !621 - v858 = load v857, !617 - v859 = get_local __ptr slice, _result___________________________, !622 - v860 = get_local __ptr slice, __tmp_arg102 - mem_copy_val v860, v859 - v861 = call len_30(v860) - retd v858 v861, !623 - - block40(): - v862 = get_local __ptr slice, _method_name, !624 - v863 = get_global __ptr string<9>, __const_global13 - v864 = cast_ptr v863 to ptr, !625 - v865 = get_local __ptr { ptr, u64 }, __anon_28, !625 - v866 = const u64 0 - v867 = get_elem_ptr v865, __ptr ptr, v866 - store v864 to v867, !625 - v868 = const u64 1 - v869 = get_elem_ptr v865, __ptr u64, v868 - v870 = const u64 9 - store v870 to v869, !625 - v871 = get_local __ptr slice, __anon_29, !625 - mem_copy_bytes v871, v865, 16 - v872 = get_local __ptr slice, __tmp_arg27 - mem_copy_val v872, v862 - v873 = get_local __ptr slice, __tmp_arg28 - mem_copy_val v873, v871 - v874 = call eq_11(v872, v873) - cbr v874, block42(), block43(), !626 - - block42(): - v875 = get_local __ptr { ptr }, _buffer, !627 - v876 = get_local __ptr slice, __ret_val3 - v877 = const u64 32 - v878 = call read_bytes_8(v875, v877, v876) - v879 = get_local __ptr slice, data3, !630 - mem_copy_val v879, v876 - v880 = get_local __ptr slice, data3, !631 - v881 = get_local __ptr slice, self_17, !632 - mem_copy_val v881, v880 - v882 = get_local __ptr slice, self_17, !633 - v883 = get_local __ptr slice, slice_17, !634 - mem_copy_val v883, v882 - v884 = get_local __ptr slice, slice_17, !635 - v885 = asm(ptr: v884) -> __ptr { ptr, u64 } ptr { - } - v886 = get_local __ptr { ptr, u64 }, __aggr_memcpy_021 - mem_copy_val v886, v885 - v887 = get_local __ptr { ptr, u64 }, __anon_049, !632 - mem_copy_val v887, v886 - v888 = get_elem_ptr v887, __ptr ptr, v37, !636 - v889 = load v888, !632 - v890 = asm(s: v889) -> __ptr string<32> s { - } - v891 = get_local __ptr string<32>, __aggr_memcpy_022 - mem_copy_val v891, v890 - v892 = get_local __ptr { string<32> }, __anon_016, !637 - v893 = const u64 0 - v894 = get_elem_ptr v892, __ptr string<32>, v893, !638 - mem_copy_val v894, v891 - v895 = get_local __ptr { string<32> }, args______________, !639 - mem_copy_val v895, v892 - v896 = get_local __ptr { string<32> }, args______________, !640 - v897 = const u64 0 - v898 = get_elem_ptr v896, __ptr string<32>, v897, !641 - v899 = get_local __ptr string<32>, v_13, !644 - mem_copy_val v899, v898 - v900 = get_local __ptr string<32>, v_13, !646 - v901 = get_local __ptr string<32>, _result____________________________, !647 - mem_copy_val v901, v900 - v902 = get_local __ptr string<32>, _result____________________________, !648 - v903 = get_local __ptr string<32>, item_14, !651 - mem_copy_val v903, v902 - v904 = get_local __ptr string<32>, item_14, !652 - v905 = get_local __ptr { { ptr, u64, u64 } }, __ret_val22 - v906 = call new_21(v905) - v907 = get_local __ptr string<32>, __tmp_arg144 - mem_copy_val v907, v904 - v908 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg145 - mem_copy_val v908, v905 - v909 = get_local __ptr { { ptr, u64, u64 } }, __ret_val89 - v910 = call abi_encode_119(v907, v908, v909) - v911 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !653 - mem_copy_val v911, v909 - v912 = get_local __ptr { { ptr, u64, u64 } }, buffer15, !654 - v913 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg73 - mem_copy_val v913, v912 - v914 = get_local __ptr slice, __ret_val51 - v915 = call as_raw_slice_22(v913, v914) - v916 = get_local __ptr slice, _result_____________________________, !655 - mem_copy_val v916, v914 - v917 = get_local __ptr slice, _result_____________________________, !656 - v918 = get_local __ptr slice, self_18, !659 - mem_copy_val v918, v917 - v919 = get_local __ptr slice, self_18, !660 - v920 = get_local __ptr slice, slice_18, !661 - mem_copy_val v920, v919 - v921 = get_local __ptr slice, slice_18, !662 - v922 = asm(ptr: v921) -> __ptr { ptr, u64 } ptr { - } - v923 = get_local __ptr { ptr, u64 }, __aggr_memcpy_023 - mem_copy_val v923, v922 - v924 = get_local __ptr { ptr, u64 }, __anon_050, !659 - mem_copy_val v924, v923 - v925 = get_elem_ptr v924, __ptr ptr, v37, !663 - v926 = load v925, !659 - v927 = get_local __ptr slice, _result_____________________________, !664 - v928 = get_local __ptr slice, __tmp_arg103 - mem_copy_val v928, v927 - v929 = call len_30(v928) - retd v926 v929, !665 - - block43(): - v930 = get_local __ptr slice, _method_name, !666 - v931 = get_global __ptr string<8>, __const_global14 - v932 = cast_ptr v931 to ptr, !667 - v933 = get_local __ptr { ptr, u64 }, __anon_30, !667 - v934 = const u64 0 - v935 = get_elem_ptr v933, __ptr ptr, v934 - store v932 to v935, !667 - v936 = const u64 1 - v937 = get_elem_ptr v933, __ptr u64, v936 - v938 = const u64 8 - store v938 to v937, !667 - v939 = get_local __ptr slice, __anon_31, !667 - mem_copy_bytes v939, v933, 16 - v940 = get_local __ptr slice, __tmp_arg29 - mem_copy_val v940, v930 - v941 = get_local __ptr slice, __tmp_arg30 - mem_copy_val v941, v939 - v942 = call eq_11(v940, v941) - cbr v942, block45(), block46(), !668 - - block45(): - v943 = get_local __ptr { ptr }, _buffer, !669 - v944 = get_local __ptr slice, __ret_val4 - v945 = const u64 8 - v946 = call read_bytes_8(v943, v945, v944) - v947 = get_local __ptr slice, data4, !672 - mem_copy_val v947, v944 - v948 = get_local __ptr slice, data4, !673 - v949 = get_local __ptr slice, self_19, !674 - mem_copy_val v949, v948 - v950 = get_local __ptr slice, self_19, !675 - v951 = get_local __ptr slice, slice_19, !676 - mem_copy_val v951, v950 - v952 = get_local __ptr slice, slice_19, !677 - v953 = asm(ptr: v952) -> __ptr { ptr, u64 } ptr { - } - v954 = get_local __ptr { ptr, u64 }, __aggr_memcpy_024 - mem_copy_val v954, v953 - v955 = get_local __ptr { ptr, u64 }, __anon_051, !674 - mem_copy_val v955, v954 - v956 = get_elem_ptr v955, __ptr ptr, v37, !678 - v957 = load v956, !674 - v958 = asm(s: v957) -> __ptr string<8> s { - } - v959 = get_local __ptr string<8>, __aggr_memcpy_025 - mem_copy_val v959, v958 - v960 = get_local __ptr { string<8> }, __anon_017, !679 - v961 = const u64 0 - v962 = get_elem_ptr v960, __ptr string<8>, v961, !680 - mem_copy_val v962, v959 - v963 = get_local __ptr { string<8> }, args_______________, !681 - mem_copy_val v963, v960 - v964 = get_local __ptr { string<8> }, args_______________, !682 - v965 = const u64 0 - v966 = get_elem_ptr v964, __ptr string<8>, v965, !683 - v967 = get_local __ptr string<8>, v_14, !686 - mem_copy_val v967, v966 - v968 = get_local __ptr string<8>, v_14, !688 - v969 = get_local __ptr string<8>, _result______________________________, !689 - mem_copy_val v969, v968 - v970 = get_local __ptr string<8>, _result______________________________, !690 - v971 = get_local __ptr string<8>, item_15, !693 - mem_copy_val v971, v970 - v972 = get_local __ptr string<8>, item_15, !694 - v973 = get_local __ptr { { ptr, u64, u64 } }, __ret_val23 - v974 = call new_21(v973) - v975 = get_local __ptr string<8>, __tmp_arg146 - mem_copy_val v975, v972 - v976 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg147 - mem_copy_val v976, v973 - v977 = get_local __ptr { { ptr, u64, u64 } }, __ret_val90 - v978 = call abi_encode_125(v975, v976, v977) - v979 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !695 - mem_copy_val v979, v977 - v980 = get_local __ptr { { ptr, u64, u64 } }, buffer16, !696 - v981 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg74 - mem_copy_val v981, v980 - v982 = get_local __ptr slice, __ret_val52 - v983 = call as_raw_slice_22(v981, v982) - v984 = get_local __ptr slice, _result_______________________________, !697 - mem_copy_val v984, v982 - v985 = get_local __ptr slice, _result_______________________________, !698 - v986 = get_local __ptr slice, self_20, !701 - mem_copy_val v986, v985 - v987 = get_local __ptr slice, self_20, !702 - v988 = get_local __ptr slice, slice_20, !703 - mem_copy_val v988, v987 - v989 = get_local __ptr slice, slice_20, !704 - v990 = asm(ptr: v989) -> __ptr { ptr, u64 } ptr { - } - v991 = get_local __ptr { ptr, u64 }, __aggr_memcpy_026 - mem_copy_val v991, v990 - v992 = get_local __ptr { ptr, u64 }, __anon_052, !701 - mem_copy_val v992, v991 - v993 = get_elem_ptr v992, __ptr ptr, v37, !705 - v994 = load v993, !701 - v995 = get_local __ptr slice, _result_______________________________, !706 - v996 = get_local __ptr slice, __tmp_arg104 - mem_copy_val v996, v995 - v997 = call len_30(v996) - retd v994 v997, !707 - - block46(): - v998 = get_local __ptr slice, _method_name, !708 - v999 = get_global __ptr string<13>, __const_global15 - v1000 = cast_ptr v999 to ptr, !709 - v1001 = get_local __ptr { ptr, u64 }, __anon_32, !709 - v1002 = const u64 0 - v1003 = get_elem_ptr v1001, __ptr ptr, v1002 - store v1000 to v1003, !709 - v1004 = const u64 1 - v1005 = get_elem_ptr v1001, __ptr u64, v1004 - v1006 = const u64 13 - store v1006 to v1005, !709 - v1007 = get_local __ptr slice, __anon_33, !709 - mem_copy_bytes v1007, v1001, 16 - v1008 = get_local __ptr slice, __tmp_arg31 - mem_copy_val v1008, v998 - v1009 = get_local __ptr slice, __tmp_arg32 - mem_copy_val v1009, v1007 - v1010 = call eq_11(v1008, v1009) - cbr v1010, block48(), block49(), !710 - - block48(): - v1011 = get_local __ptr { ptr }, _buffer, !711 - v1012 = get_local __ptr { u64 }, __ret_val91 - v1013 = call abi_decode_128(v1011, v1012) - v1014 = get_local __ptr { { u64 } }, __anon_018, !714 - v1015 = const u64 0 - v1016 = get_elem_ptr v1014, __ptr { u64 }, v1015, !715 - mem_copy_val v1016, v1012 - v1017 = get_local __ptr { { u64 } }, args________________, !716 - mem_copy_val v1017, v1014 - v1018 = get_local __ptr { { u64 } }, args________________, !717 - v1019 = const u64 0 - v1020 = get_elem_ptr v1018, __ptr { u64 }, v1019, !718 - v1021 = get_local __ptr { u64 }, v_15, !721 - mem_copy_val v1021, v1020 - v1022 = get_local __ptr { u64 }, v_15, !723 - v1023 = get_local __ptr { u64 }, _result________________________________, !724 - mem_copy_val v1023, v1022 - v1024 = get_local __ptr { u64 }, _result________________________________, !725 - v1025 = get_local __ptr { u64 }, item_16, !728 - mem_copy_val v1025, v1024 - v1026 = get_local __ptr { u64 }, item_16, !729 - v1027 = get_local __ptr { { ptr, u64, u64 } }, __ret_val24 - v1028 = call new_21(v1027) - v1029 = get_local __ptr { u64 }, __tmp_arg148 - mem_copy_val v1029, v1026 - v1030 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg149 - mem_copy_val v1030, v1027 - v1031 = get_local __ptr { { ptr, u64, u64 } }, __ret_val92 - v1032 = call abi_encode_131(v1029, v1030, v1031) - v1033 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !730 - mem_copy_val v1033, v1031 - v1034 = get_local __ptr { { ptr, u64, u64 } }, buffer17, !731 - v1035 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg75 - mem_copy_val v1035, v1034 - v1036 = get_local __ptr slice, __ret_val53 - v1037 = call as_raw_slice_22(v1035, v1036) - v1038 = get_local __ptr slice, _result_________________________________, !732 - mem_copy_val v1038, v1036 - v1039 = get_local __ptr slice, _result_________________________________, !733 - v1040 = get_local __ptr slice, self_21, !736 - mem_copy_val v1040, v1039 - v1041 = get_local __ptr slice, self_21, !737 - v1042 = get_local __ptr slice, slice_21, !738 - mem_copy_val v1042, v1041 - v1043 = get_local __ptr slice, slice_21, !739 - v1044 = asm(ptr: v1043) -> __ptr { ptr, u64 } ptr { - } - v1045 = get_local __ptr { ptr, u64 }, __aggr_memcpy_027 - mem_copy_val v1045, v1044 - v1046 = get_local __ptr { ptr, u64 }, __anon_053, !736 - mem_copy_val v1046, v1045 - v1047 = get_elem_ptr v1046, __ptr ptr, v37, !740 - v1048 = load v1047, !736 - v1049 = get_local __ptr slice, _result_________________________________, !741 - v1050 = get_local __ptr slice, __tmp_arg105 - mem_copy_val v1050, v1049 - v1051 = call len_30(v1050) - retd v1048 v1051, !742 - - block49(): - v1052 = get_local __ptr slice, _method_name, !743 - v1053 = get_global __ptr string<17>, __const_global16 - v1054 = cast_ptr v1053 to ptr, !744 - v1055 = get_local __ptr { ptr, u64 }, __anon_34, !744 - v1056 = const u64 0 - v1057 = get_elem_ptr v1055, __ptr ptr, v1056 - store v1054 to v1057, !744 - v1058 = const u64 1 - v1059 = get_elem_ptr v1055, __ptr u64, v1058 - v1060 = const u64 17 - store v1060 to v1059, !744 - v1061 = get_local __ptr slice, __anon_35, !744 - mem_copy_bytes v1061, v1055, 16 - v1062 = get_local __ptr slice, __tmp_arg33 - mem_copy_val v1062, v1052 - v1063 = get_local __ptr slice, __tmp_arg34 - mem_copy_val v1063, v1061 - v1064 = call eq_11(v1062, v1063) - cbr v1064, block51(), block52(), !745 - - block51(): - v1065 = get_local __ptr { ptr }, _buffer, !746 - v1066 = get_local __ptr { u64, u64 }, __ret_val94 - v1067 = call abi_decode_134(v1065, v1066) - v1068 = get_local __ptr { { u64, u64 } }, __anon_019, !749 - v1069 = const u64 0 - v1070 = get_elem_ptr v1068, __ptr { u64, u64 }, v1069, !750 - mem_copy_val v1070, v1066 - v1071 = get_local __ptr { { u64, u64 } }, args_________________, !751 - mem_copy_val v1071, v1068 - v1072 = get_local __ptr { { u64, u64 } }, args_________________, !752 - v1073 = const u64 0 - v1074 = get_elem_ptr v1072, __ptr { u64, u64 }, v1073, !753 - v1075 = get_local __ptr { u64, u64 }, v_16, !756 - mem_copy_val v1075, v1074 - v1076 = get_local __ptr { u64, u64 }, v_16, !758 - v1077 = get_local __ptr { u64, u64 }, _result__________________________________, !759 - mem_copy_val v1077, v1076 - v1078 = get_local __ptr { u64, u64 }, _result__________________________________, !760 - v1079 = get_local __ptr { u64, u64 }, item_17, !763 - mem_copy_val v1079, v1078 - v1080 = get_local __ptr { u64, u64 }, item_17, !764 - v1081 = get_local __ptr { { ptr, u64, u64 } }, __ret_val25 - v1082 = call new_21(v1081) - v1083 = get_local __ptr { u64, u64 }, __tmp_arg156 - mem_copy_val v1083, v1080 - v1084 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg157 - mem_copy_val v1084, v1081 - v1085 = get_local __ptr { { ptr, u64, u64 } }, __ret_val98 - v1086 = call abi_encode_159(v1083, v1084, v1085) - v1087 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !765 - mem_copy_val v1087, v1085 - v1088 = get_local __ptr { { ptr, u64, u64 } }, buffer18, !766 - v1089 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg76 - mem_copy_val v1089, v1088 - v1090 = get_local __ptr slice, __ret_val54 - v1091 = call as_raw_slice_22(v1089, v1090) - v1092 = get_local __ptr slice, _result___________________________________, !767 - mem_copy_val v1092, v1090 - v1093 = get_local __ptr slice, _result___________________________________, !768 - v1094 = get_local __ptr slice, self_22, !771 - mem_copy_val v1094, v1093 - v1095 = get_local __ptr slice, self_22, !772 - v1096 = get_local __ptr slice, slice_22, !773 - mem_copy_val v1096, v1095 - v1097 = get_local __ptr slice, slice_22, !774 - v1098 = asm(ptr: v1097) -> __ptr { ptr, u64 } ptr { - } - v1099 = get_local __ptr { ptr, u64 }, __aggr_memcpy_028 - mem_copy_val v1099, v1098 - v1100 = get_local __ptr { ptr, u64 }, __anon_054, !771 - mem_copy_val v1100, v1099 - v1101 = get_elem_ptr v1100, __ptr ptr, v37, !775 - v1102 = load v1101, !771 - v1103 = get_local __ptr slice, _result___________________________________, !776 - v1104 = get_local __ptr slice, __tmp_arg106 - mem_copy_val v1104, v1103 - v1105 = call len_30(v1104) - retd v1102 v1105, !777 - - block52(): - v1106 = get_local __ptr slice, _method_name, !778 - v1107 = get_global __ptr string<21>, __const_global17 - v1108 = cast_ptr v1107 to ptr, !779 - v1109 = get_local __ptr { ptr, u64 }, __anon_36, !779 - v1110 = const u64 0 - v1111 = get_elem_ptr v1109, __ptr ptr, v1110 - store v1108 to v1111, !779 - v1112 = const u64 1 - v1113 = get_elem_ptr v1109, __ptr u64, v1112 - v1114 = const u64 21 - store v1114 to v1113, !779 - v1115 = get_local __ptr slice, __anon_37, !779 - mem_copy_bytes v1115, v1109, 16 - v1116 = get_local __ptr slice, __tmp_arg35 - mem_copy_val v1116, v1106 - v1117 = get_local __ptr slice, __tmp_arg36 - mem_copy_val v1117, v1115 - v1118 = call eq_11(v1116, v1117) - cbr v1118, block54(), block55(), !780 - - block54(): - v1119 = get_local __ptr { ptr }, _buffer, !781 - v1120 = get_local __ptr { u64, u64, u64 }, __ret_val100 - v1121 = call abi_decode_162(v1119, v1120) - v1122 = get_local __ptr { { u64, u64, u64 } }, __anon_020, !784 - v1123 = const u64 0 - v1124 = get_elem_ptr v1122, __ptr { u64, u64, u64 }, v1123, !785 - mem_copy_val v1124, v1120 - v1125 = get_local __ptr { { u64, u64, u64 } }, args__________________, !786 - mem_copy_val v1125, v1122 - v1126 = get_local __ptr { { u64, u64, u64 } }, args__________________, !787 - v1127 = const u64 0 - v1128 = get_elem_ptr v1126, __ptr { u64, u64, u64 }, v1127, !788 - v1129 = get_local __ptr { u64, u64, u64 }, v_17, !791 - mem_copy_val v1129, v1128 - v1130 = get_local __ptr { u64, u64, u64 }, v_17, !793 - v1131 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !794 - mem_copy_val v1131, v1130 - v1132 = get_local __ptr { u64, u64, u64 }, _result____________________________________, !795 - v1133 = get_local __ptr { u64, u64, u64 }, item_18, !798 - mem_copy_val v1133, v1132 - v1134 = get_local __ptr { u64, u64, u64 }, item_18, !799 - v1135 = get_local __ptr { { ptr, u64, u64 } }, __ret_val26 - v1136 = call new_21(v1135) - v1137 = get_local __ptr { u64, u64, u64 }, __tmp_arg152 - mem_copy_val v1137, v1134 - v1138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg153 - mem_copy_val v1138, v1135 - v1139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val96 - v1140 = call abi_encode_143(v1137, v1138, v1139) - v1141 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !800 - mem_copy_val v1141, v1139 - v1142 = get_local __ptr { { ptr, u64, u64 } }, buffer19, !801 - v1143 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg77 - mem_copy_val v1143, v1142 - v1144 = get_local __ptr slice, __ret_val55 - v1145 = call as_raw_slice_22(v1143, v1144) - v1146 = get_local __ptr slice, _result_____________________________________, !802 - mem_copy_val v1146, v1144 - v1147 = get_local __ptr slice, _result_____________________________________, !803 - v1148 = get_local __ptr slice, self_23, !806 - mem_copy_val v1148, v1147 - v1149 = get_local __ptr slice, self_23, !807 - v1150 = get_local __ptr slice, slice_23, !808 - mem_copy_val v1150, v1149 - v1151 = get_local __ptr slice, slice_23, !809 - v1152 = asm(ptr: v1151) -> __ptr { ptr, u64 } ptr { - } - v1153 = get_local __ptr { ptr, u64 }, __aggr_memcpy_029 - mem_copy_val v1153, v1152 - v1154 = get_local __ptr { ptr, u64 }, __anon_055, !806 - mem_copy_val v1154, v1153 - v1155 = get_elem_ptr v1154, __ptr ptr, v37, !810 - v1156 = load v1155, !806 - v1157 = get_local __ptr slice, _result_____________________________________, !811 - v1158 = get_local __ptr slice, __tmp_arg107 - mem_copy_val v1158, v1157 - v1159 = call len_30(v1158) - retd v1156 v1159, !812 - - block55(): - v1160 = get_local __ptr slice, _method_name, !813 - v1161 = get_global __ptr string<10>, __const_global18 - v1162 = cast_ptr v1161 to ptr, !814 - v1163 = get_local __ptr { ptr, u64 }, __anon_38, !814 - v1164 = const u64 0 - v1165 = get_elem_ptr v1163, __ptr ptr, v1164 - store v1162 to v1165, !814 - v1166 = const u64 1 - v1167 = get_elem_ptr v1163, __ptr u64, v1166 - v1168 = const u64 10 - store v1168 to v1167, !814 - v1169 = get_local __ptr slice, __anon_39, !814 - mem_copy_bytes v1169, v1163, 16 - v1170 = get_local __ptr slice, __tmp_arg37 - mem_copy_val v1170, v1160 - v1171 = get_local __ptr slice, __tmp_arg38 - mem_copy_val v1171, v1169 - v1172 = call eq_11(v1170, v1171) - cbr v1172, block57(), block58(), !815 - - block57(): - v1173 = get_local __ptr { () }, __anon_021, !818 - v1174 = const u64 0 - v1175 = get_elem_ptr v1173, __ptr (), v1174, !819 - v1176 = const unit () - store v1176 to v1175, !820 - v1177 = get_local __ptr { () }, args___________________, !821 - mem_copy_val v1177, v1173 - v1178 = asm() -> ptr zero, !822 { - } - v1179 = const u64 0, !823 - retd v1178 v1179, !824 - - block58(): - v1180 = get_local __ptr slice, _method_name, !825 - v1181 = get_global __ptr string<10>, __const_global19 - v1182 = cast_ptr v1181 to ptr, !826 - v1183 = get_local __ptr { ptr, u64 }, __anon_40, !826 - v1184 = const u64 0 - v1185 = get_elem_ptr v1183, __ptr ptr, v1184 - store v1182 to v1185, !826 - v1186 = const u64 1 - v1187 = get_elem_ptr v1183, __ptr u64, v1186 - v1188 = const u64 10 - store v1188 to v1187, !826 - v1189 = get_local __ptr slice, __anon_41, !826 - mem_copy_bytes v1189, v1183, 16 - v1190 = get_local __ptr slice, __tmp_arg39 - mem_copy_val v1190, v1180 - v1191 = get_local __ptr slice, __tmp_arg40 - mem_copy_val v1191, v1189 - v1192 = call eq_11(v1190, v1191) - cbr v1192, block60(), block61(), !827 - - block60(): - v1193 = get_local __ptr { ptr }, _buffer, !828 - v1194 = get_elem_ptr v1193, __ptr ptr, v19, !833 - v1195 = load v1194, !834 - v1196 = asm(ptr: v1195, val) -> u64 val, !835 { - lw val ptr i0, !58 - } - v1197 = load v1194, !834 - v1198 = const u64 8, !834 - v1199 = add v1197, v1198, !834 - store v1199 to v1194, !836 - v1200 = get_local __ptr { u64 }, __anon_001, !837 - v1201 = const u64 0 - v1202 = get_elem_ptr v1200, __ptr u64, v1201, !838 - store v1196 to v1202, !839 - v1203 = get_local __ptr { { u64 } }, __anon_022, !840 - v1204 = const u64 0 - v1205 = get_elem_ptr v1203, __ptr { u64 }, v1204, !841 - mem_copy_val v1205, v1200 - v1206 = get_local __ptr { { u64 } }, args____________________, !842 - mem_copy_val v1206, v1203 - v1207 = get_local __ptr { { u64 } }, args____________________, !843 - v1208 = const u64 0 - v1209 = get_elem_ptr v1207, __ptr { u64 }, v1208, !844 - v1210 = get_local __ptr { u64 }, v_19, !847 - mem_copy_val v1210, v1209 - v1211 = get_local __ptr { u64 }, v_19, !848 - v1212 = get_local __ptr { u64 }, _result_______________________________________, !849 - mem_copy_val v1212, v1211 - v1213 = get_local __ptr { u64 }, _result_______________________________________, !850 - v1214 = get_local __ptr { u64 }, item_19, !853 - mem_copy_val v1214, v1213 - v1215 = get_local __ptr { u64 }, item_19, !854 - v1216 = get_local __ptr { { ptr, u64, u64 } }, __ret_val27 - v1217 = call new_21(v1216) - v1218 = get_local __ptr { u64 }, __tmp_arg150 - mem_copy_val v1218, v1215 - v1219 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg151 - mem_copy_val v1219, v1216 - v1220 = get_local __ptr { { ptr, u64, u64 } }, __ret_val93 - v1221 = call abi_encode_131(v1218, v1219, v1220) - v1222 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !855 - mem_copy_val v1222, v1220 - v1223 = get_local __ptr { { ptr, u64, u64 } }, buffer20, !856 - v1224 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg78 - mem_copy_val v1224, v1223 - v1225 = get_local __ptr slice, __ret_val56 - v1226 = call as_raw_slice_22(v1224, v1225) - v1227 = get_local __ptr slice, _result________________________________________, !857 - mem_copy_val v1227, v1225 - v1228 = get_local __ptr slice, _result________________________________________, !858 - v1229 = get_local __ptr slice, self_24, !861 - mem_copy_val v1229, v1228 - v1230 = get_local __ptr slice, self_24, !862 - v1231 = get_local __ptr slice, slice_24, !863 - mem_copy_val v1231, v1230 - v1232 = get_local __ptr slice, slice_24, !864 - v1233 = asm(ptr: v1232) -> __ptr { ptr, u64 } ptr { - } - v1234 = get_local __ptr { ptr, u64 }, __aggr_memcpy_030 - mem_copy_val v1234, v1233 - v1235 = get_local __ptr { ptr, u64 }, __anon_056, !861 - mem_copy_val v1235, v1234 - v1236 = get_elem_ptr v1235, __ptr ptr, v37, !865 - v1237 = load v1236, !861 - v1238 = get_local __ptr slice, _result________________________________________, !866 - v1239 = get_local __ptr slice, __tmp_arg108 - mem_copy_val v1239, v1238 - v1240 = call len_30(v1239) - retd v1237 v1240, !867 - - block61(): - v1241 = get_local __ptr slice, _method_name, !868 - v1242 = get_global __ptr string<10>, __const_global20 - v1243 = cast_ptr v1242 to ptr, !869 - v1244 = get_local __ptr { ptr, u64 }, __anon_42, !869 - v1245 = const u64 0 - v1246 = get_elem_ptr v1244, __ptr ptr, v1245 - store v1243 to v1246, !869 - v1247 = const u64 1 - v1248 = get_elem_ptr v1244, __ptr u64, v1247 - v1249 = const u64 10 - store v1249 to v1248, !869 - v1250 = get_local __ptr slice, __anon_43, !869 - mem_copy_bytes v1250, v1244, 16 - v1251 = get_local __ptr slice, __tmp_arg41 - mem_copy_val v1251, v1241 - v1252 = get_local __ptr slice, __tmp_arg42 - mem_copy_val v1252, v1250 - v1253 = call eq_11(v1251, v1252) - cbr v1253, block63(), block64(), !870 - - block63(): - v1254 = get_local __ptr { ptr }, _buffer, !871 - v1255 = get_local __ptr { u64, u64 }, __ret_val95 - v1256 = call abi_decode_134(v1254, v1255) - v1257 = get_local __ptr { { u64, u64 } }, __anon_023, !874 - v1258 = const u64 0 - v1259 = get_elem_ptr v1257, __ptr { u64, u64 }, v1258, !875 - mem_copy_val v1259, v1255 - v1260 = get_local __ptr { { u64, u64 } }, args_____________________, !876 - mem_copy_val v1260, v1257 - v1261 = get_local __ptr { { u64, u64 } }, args_____________________, !877 - v1262 = const u64 0 - v1263 = get_elem_ptr v1261, __ptr { u64, u64 }, v1262, !878 - v1264 = get_local __ptr { u64, u64 }, v_20, !881 - mem_copy_val v1264, v1263 - v1265 = get_local __ptr { u64, u64 }, v_20, !882 - v1266 = get_local __ptr { u64, u64 }, _result_________________________________________, !883 - mem_copy_val v1266, v1265 - v1267 = get_local __ptr { u64, u64 }, _result_________________________________________, !884 - v1268 = get_local __ptr { u64, u64 }, item_20, !887 - mem_copy_val v1268, v1267 - v1269 = get_local __ptr { u64, u64 }, item_20, !888 - v1270 = get_local __ptr { { ptr, u64, u64 } }, __ret_val28 - v1271 = call new_21(v1270) - v1272 = get_local __ptr { u64, u64 }, __tmp_arg158 - mem_copy_val v1272, v1269 - v1273 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg159 - mem_copy_val v1273, v1270 - v1274 = get_local __ptr { { ptr, u64, u64 } }, __ret_val99 - v1275 = call abi_encode_159(v1272, v1273, v1274) - v1276 = get_local __ptr { { ptr, u64, u64 } }, buffer21, !889 - mem_copy_val v1276, v1274 - v1277 = get_local __ptr { { ptr, u64, u64 } }, buffer21, !890 - v1278 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg79 - mem_copy_val v1278, v1277 - v1279 = get_local __ptr slice, __ret_val57 - v1280 = call as_raw_slice_22(v1278, v1279) - v1281 = get_local __ptr slice, _result__________________________________________, !891 - mem_copy_val v1281, v1279 - v1282 = get_local __ptr slice, _result__________________________________________, !892 - v1283 = get_local __ptr slice, self_25, !895 - mem_copy_val v1283, v1282 - v1284 = get_local __ptr slice, self_25, !896 - v1285 = get_local __ptr slice, slice_25, !897 - mem_copy_val v1285, v1284 - v1286 = get_local __ptr slice, slice_25, !898 - v1287 = asm(ptr: v1286) -> __ptr { ptr, u64 } ptr { - } - v1288 = get_local __ptr { ptr, u64 }, __aggr_memcpy_031 - mem_copy_val v1288, v1287 - v1289 = get_local __ptr { ptr, u64 }, __anon_057, !895 - mem_copy_val v1289, v1288 - v1290 = get_elem_ptr v1289, __ptr ptr, v37, !899 - v1291 = load v1290, !895 - v1292 = get_local __ptr slice, _result__________________________________________, !900 - v1293 = get_local __ptr slice, __tmp_arg109 - mem_copy_val v1293, v1292 - v1294 = call len_30(v1293) - retd v1291 v1294, !901 - - block64(): - v1295 = get_local __ptr slice, _method_name, !902 - v1296 = get_global __ptr string<10>, __const_global21 - v1297 = cast_ptr v1296 to ptr, !903 - v1298 = get_local __ptr { ptr, u64 }, __anon_44, !903 - v1299 = const u64 0 - v1300 = get_elem_ptr v1298, __ptr ptr, v1299 - store v1297 to v1300, !903 - v1301 = const u64 1 - v1302 = get_elem_ptr v1298, __ptr u64, v1301 - v1303 = const u64 10 - store v1303 to v1302, !903 - v1304 = get_local __ptr slice, __anon_45, !903 - mem_copy_bytes v1304, v1298, 16 - v1305 = get_local __ptr slice, __tmp_arg43 - mem_copy_val v1305, v1295 - v1306 = get_local __ptr slice, __tmp_arg44 - mem_copy_val v1306, v1304 - v1307 = call eq_11(v1305, v1306) - cbr v1307, block66(), block67(), !904 - - block66(): - v1308 = get_local __ptr { ptr }, _buffer, !905 - v1309 = get_local __ptr { u64, u64, u64 }, __ret_val101 - v1310 = call abi_decode_162(v1308, v1309) - v1311 = get_local __ptr { { u64, u64, u64 } }, __anon_024, !908 - v1312 = const u64 0 - v1313 = get_elem_ptr v1311, __ptr { u64, u64, u64 }, v1312, !909 - mem_copy_val v1313, v1309 - v1314 = get_local __ptr { { u64, u64, u64 } }, args______________________, !910 - mem_copy_val v1314, v1311 - v1315 = get_local __ptr { { u64, u64, u64 } }, args______________________, !911 - v1316 = const u64 0 - v1317 = get_elem_ptr v1315, __ptr { u64, u64, u64 }, v1316, !912 - v1318 = get_local __ptr { u64, u64, u64 }, v_21, !915 - mem_copy_val v1318, v1317 - v1319 = get_local __ptr { u64, u64, u64 }, v_21, !916 - v1320 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !917 - mem_copy_val v1320, v1319 - v1321 = get_local __ptr { u64, u64, u64 }, _result___________________________________________, !918 - v1322 = get_local __ptr { u64, u64, u64 }, item_21, !921 - mem_copy_val v1322, v1321 - v1323 = get_local __ptr { u64, u64, u64 }, item_21, !922 - v1324 = get_local __ptr { { ptr, u64, u64 } }, __ret_val29 - v1325 = call new_21(v1324) - v1326 = get_local __ptr { u64, u64, u64 }, __tmp_arg154 - mem_copy_val v1326, v1323 - v1327 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg155 - mem_copy_val v1327, v1324 - v1328 = get_local __ptr { { ptr, u64, u64 } }, __ret_val97 - v1329 = call abi_encode_143(v1326, v1327, v1328) - v1330 = get_local __ptr { { ptr, u64, u64 } }, buffer22, !923 - mem_copy_val v1330, v1328 - v1331 = get_local __ptr { { ptr, u64, u64 } }, buffer22, !924 - v1332 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg80 - mem_copy_val v1332, v1331 - v1333 = get_local __ptr slice, __ret_val58 - v1334 = call as_raw_slice_22(v1332, v1333) - v1335 = get_local __ptr slice, _result____________________________________________, !925 - mem_copy_val v1335, v1333 - v1336 = get_local __ptr slice, _result____________________________________________, !926 - v1337 = get_local __ptr slice, self_26, !929 - mem_copy_val v1337, v1336 - v1338 = get_local __ptr slice, self_26, !930 - v1339 = get_local __ptr slice, slice_26, !931 - mem_copy_val v1339, v1338 - v1340 = get_local __ptr slice, slice_26, !932 - v1341 = asm(ptr: v1340) -> __ptr { ptr, u64 } ptr { - } - v1342 = get_local __ptr { ptr, u64 }, __aggr_memcpy_032 - mem_copy_val v1342, v1341 - v1343 = get_local __ptr { ptr, u64 }, __anon_058, !929 - mem_copy_val v1343, v1342 - v1344 = get_elem_ptr v1343, __ptr ptr, v37, !933 - v1345 = load v1344, !929 - v1346 = get_local __ptr slice, _result____________________________________________, !934 - v1347 = get_local __ptr slice, __tmp_arg110 - mem_copy_val v1347, v1346 - v1348 = call len_30(v1347) - retd v1345 v1348, !935 - - block67(): - v1349 = get_local __ptr slice, _method_name, !936 - v1350 = get_global __ptr string<10>, __const_global22 - v1351 = cast_ptr v1350 to ptr, !937 - v1352 = get_local __ptr { ptr, u64 }, __anon_46, !937 - v1353 = const u64 0 - v1354 = get_elem_ptr v1352, __ptr ptr, v1353 - store v1351 to v1354, !937 - v1355 = const u64 1 - v1356 = get_elem_ptr v1352, __ptr u64, v1355 - v1357 = const u64 10 - store v1357 to v1356, !937 - v1358 = get_local __ptr slice, __anon_47, !937 - mem_copy_bytes v1358, v1352, 16 - v1359 = get_local __ptr slice, __tmp_arg45 - mem_copy_val v1359, v1349 - v1360 = get_local __ptr slice, __tmp_arg46 - mem_copy_val v1360, v1358 - v1361 = call eq_11(v1359, v1360) - cbr v1361, block69(), block70(), !938 - - block69(): - v1362 = get_local __ptr { ptr }, _buffer, !939 - v1363 = get_local __ptr { u64, u64, u64, u64 }, __ret_val102 - v1364 = call abi_decode_168(v1362, v1363) - v1365 = get_local __ptr { { u64, u64, u64, u64 } }, __anon_025, !942 - v1366 = const u64 0 - v1367 = get_elem_ptr v1365, __ptr { u64, u64, u64, u64 }, v1366, !943 - mem_copy_val v1367, v1363 - v1368 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !944 - mem_copy_val v1368, v1365 - v1369 = get_local __ptr { { u64, u64, u64, u64 } }, args_______________________, !945 - v1370 = const u64 0 - v1371 = get_elem_ptr v1369, __ptr { u64, u64, u64, u64 }, v1370, !946 - v1372 = get_local __ptr { u64, u64, u64, u64 }, v_22, !949 - mem_copy_val v1372, v1371 - v1373 = get_local __ptr { u64, u64, u64, u64 }, v_22, !951 - v1374 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !952 - mem_copy_val v1374, v1373 - v1375 = get_local __ptr { u64, u64, u64, u64 }, _result_____________________________________________, !953 - v1376 = get_local __ptr { u64, u64, u64, u64 }, item_22, !956 - mem_copy_val v1376, v1375 - v1377 = get_local __ptr { u64, u64, u64, u64 }, item_22, !957 - v1378 = get_local __ptr { { ptr, u64, u64 } }, __ret_val30 - v1379 = call new_21(v1378) - v1380 = get_local __ptr { u64, u64, u64, u64 }, __tmp_arg160 - mem_copy_val v1380, v1377 - v1381 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg161 - mem_copy_val v1381, v1378 - v1382 = get_local __ptr { { ptr, u64, u64 } }, __ret_val103 - v1383 = call abi_encode_171(v1380, v1381, v1382) - v1384 = get_local __ptr { { ptr, u64, u64 } }, buffer23, !958 - mem_copy_val v1384, v1382 - v1385 = get_local __ptr { { ptr, u64, u64 } }, buffer23, !959 - v1386 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg81 - mem_copy_val v1386, v1385 - v1387 = get_local __ptr slice, __ret_val59 - v1388 = call as_raw_slice_22(v1386, v1387) - v1389 = get_local __ptr slice, _result______________________________________________, !960 - mem_copy_val v1389, v1387 - v1390 = get_local __ptr slice, _result______________________________________________, !961 - v1391 = get_local __ptr slice, self_27, !964 - mem_copy_val v1391, v1390 - v1392 = get_local __ptr slice, self_27, !965 - v1393 = get_local __ptr slice, slice_27, !966 - mem_copy_val v1393, v1392 - v1394 = get_local __ptr slice, slice_27, !967 - v1395 = asm(ptr: v1394) -> __ptr { ptr, u64 } ptr { - } - v1396 = get_local __ptr { ptr, u64 }, __aggr_memcpy_033 - mem_copy_val v1396, v1395 - v1397 = get_local __ptr { ptr, u64 }, __anon_059, !964 - mem_copy_val v1397, v1396 - v1398 = get_elem_ptr v1397, __ptr ptr, v37, !968 - v1399 = load v1398, !964 - v1400 = get_local __ptr slice, _result______________________________________________, !969 - v1401 = get_local __ptr slice, __tmp_arg111 - mem_copy_val v1401, v1400 - v1402 = call len_30(v1401) - retd v1399 v1402, !970 - - block70(): - v1403 = get_local __ptr slice, _method_name, !971 - v1404 = get_global __ptr string<6>, __const_global23 - v1405 = cast_ptr v1404 to ptr, !972 - v1406 = get_local __ptr { ptr, u64 }, __anon_48, !972 - v1407 = const u64 0 - v1408 = get_elem_ptr v1406, __ptr ptr, v1407 - store v1405 to v1408, !972 - v1409 = const u64 1 - v1410 = get_elem_ptr v1406, __ptr u64, v1409 - v1411 = const u64 6 - store v1411 to v1410, !972 - v1412 = get_local __ptr slice, __anon_49, !972 - mem_copy_bytes v1412, v1406, 16 - v1413 = get_local __ptr slice, __tmp_arg47 - mem_copy_val v1413, v1403 - v1414 = get_local __ptr slice, __tmp_arg48 - mem_copy_val v1414, v1412 - v1415 = call eq_11(v1413, v1414) - cbr v1415, block72(), block73(), !973 - - block72(): - v1416 = get_local __ptr { ptr }, _buffer, !974 - v1417 = call read_72(v1416), !979 - v1418 = asm(input: v1417) -> u64 input, !983 { - } - v1419 = call read_72(v1416), !986 - v1420 = asm(input: v1419) -> u64 input, !989 { - } - v1421 = const u64 8, !990 - v1422 = lsh v1418, v1421, !993 - v1423 = const u64 65535, !995 - v1424 = and v1422, v1423, !996 - v1425 = or v1424, v1420, !999 - v1426 = get_local __ptr { u64 }, __anon_026, !1000 - v1427 = const u64 0 - v1428 = get_elem_ptr v1426, __ptr u64, v1427, !1001 - store v1425 to v1428, !1002 - v1429 = get_local __ptr { u64 }, args________________________, !1003 - mem_copy_val v1429, v1426 - v1430 = get_local __ptr { u64 }, args________________________, !1004 - v1431 = const u64 0 - v1432 = get_elem_ptr v1430, __ptr u64, v1431, !1005 - v1433 = load v1432 - v1434 = get_local __ptr { { ptr, u64, u64 } }, __ret_val31 - v1435 = call new_21(v1434) - v1436 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg162 - mem_copy_val v1436, v1434 - v1437 = get_local __ptr { { ptr, u64, u64 } }, __ret_val104 - v1438 = call abi_encode_181(v1433, v1436, v1437) - v1439 = get_local __ptr { { ptr, u64, u64 } }, buffer24, !1008 - mem_copy_val v1439, v1437 - v1440 = get_local __ptr { { ptr, u64, u64 } }, buffer24, !1009 - v1441 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg82 - mem_copy_val v1441, v1440 - v1442 = get_local __ptr slice, __ret_val60 - v1443 = call as_raw_slice_22(v1441, v1442) - v1444 = get_local __ptr slice, _result________________________________________________, !1010 - mem_copy_val v1444, v1442 - v1445 = get_local __ptr slice, _result________________________________________________, !1011 - v1446 = get_local __ptr slice, self_28, !1014 - mem_copy_val v1446, v1445 - v1447 = get_local __ptr slice, self_28, !1015 - v1448 = get_local __ptr slice, slice_28, !1016 - mem_copy_val v1448, v1447 - v1449 = get_local __ptr slice, slice_28, !1017 - v1450 = asm(ptr: v1449) -> __ptr { ptr, u64 } ptr { - } - v1451 = get_local __ptr { ptr, u64 }, __aggr_memcpy_034 - mem_copy_val v1451, v1450 - v1452 = get_local __ptr { ptr, u64 }, __anon_060, !1014 - mem_copy_val v1452, v1451 - v1453 = get_elem_ptr v1452, __ptr ptr, v37, !1018 - v1454 = load v1453, !1014 - v1455 = get_local __ptr slice, _result________________________________________________, !1019 - v1456 = get_local __ptr slice, __tmp_arg112 - mem_copy_val v1456, v1455 - v1457 = call len_30(v1456) - retd v1454 v1457, !1020 - - block73(): - v1458 = get_local __ptr slice, _method_name, !1021 - v1459 = get_global __ptr string<7>, __const_global24 - v1460 = cast_ptr v1459 to ptr, !1022 - v1461 = get_local __ptr { ptr, u64 }, __anon_50, !1022 - v1462 = const u64 0 - v1463 = get_elem_ptr v1461, __ptr ptr, v1462 - store v1460 to v1463, !1022 - v1464 = const u64 1 - v1465 = get_elem_ptr v1461, __ptr u64, v1464 - v1466 = const u64 7 - store v1466 to v1465, !1022 - v1467 = get_local __ptr slice, __anon_51, !1022 - mem_copy_bytes v1467, v1461, 16 - v1468 = get_local __ptr slice, __tmp_arg49 - mem_copy_val v1468, v1458 - v1469 = get_local __ptr slice, __tmp_arg50 - mem_copy_val v1469, v1467 - v1470 = call eq_11(v1468, v1469) - cbr v1470, block75(), block76(), !1023 - - block75(): - v1471 = get_local __ptr { ptr }, _buffer, !1024 - v1472 = get_local __ptr u256, __ret_val105 - v1473 = call abi_decode_184(v1471, v1472) - v1474 = get_local __ptr { u256 }, __anon_027, !1027 - v1475 = const u64 0 - v1476 = get_elem_ptr v1474, __ptr u256, v1475, !1028 - mem_copy_val v1476, v1472 - v1477 = get_local __ptr { u256 }, args_________________________, !1029 - mem_copy_val v1477, v1474 - v1478 = get_local __ptr { u256 }, args_________________________, !1030 - v1479 = const u64 0 - v1480 = get_elem_ptr v1478, __ptr u256, v1479, !1031 - v1481 = get_local __ptr u256, v_24, !1034 - mem_copy_val v1481, v1480 - v1482 = get_local __ptr u256, v_24, !1036 - v1483 = get_local __ptr u256, _result_________________________________________________, !1037 - mem_copy_val v1483, v1482 - v1484 = get_local __ptr u256, _result_________________________________________________, !1038 - v1485 = get_local __ptr u256, item_24, !1041 - mem_copy_val v1485, v1484 - v1486 = get_local __ptr u256, item_24, !1042 - v1487 = get_local __ptr { { ptr, u64, u64 } }, __ret_val32 - v1488 = call new_21(v1487) - v1489 = get_local __ptr u256, __tmp_arg163 - mem_copy_val v1489, v1486 - v1490 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg164 - mem_copy_val v1490, v1487 - v1491 = get_local __ptr { { ptr, u64, u64 } }, __ret_val106 - v1492 = call abi_encode_188(v1489, v1490, v1491) - v1493 = get_local __ptr { { ptr, u64, u64 } }, buffer25, !1043 - mem_copy_val v1493, v1491 - v1494 = get_local __ptr { { ptr, u64, u64 } }, buffer25, !1044 - v1495 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg83 - mem_copy_val v1495, v1494 - v1496 = get_local __ptr slice, __ret_val61 - v1497 = call as_raw_slice_22(v1495, v1496) - v1498 = get_local __ptr slice, _result__________________________________________________, !1045 - mem_copy_val v1498, v1496 - v1499 = get_local __ptr slice, _result__________________________________________________, !1046 - v1500 = get_local __ptr slice, self_29, !1049 - mem_copy_val v1500, v1499 - v1501 = get_local __ptr slice, self_29, !1050 - v1502 = get_local __ptr slice, slice_29, !1051 - mem_copy_val v1502, v1501 - v1503 = get_local __ptr slice, slice_29, !1052 - v1504 = asm(ptr: v1503) -> __ptr { ptr, u64 } ptr { - } - v1505 = get_local __ptr { ptr, u64 }, __aggr_memcpy_035 - mem_copy_val v1505, v1504 - v1506 = get_local __ptr { ptr, u64 }, __anon_061, !1049 - mem_copy_val v1506, v1505 - v1507 = get_elem_ptr v1506, __ptr ptr, v37, !1053 - v1508 = load v1507, !1049 - v1509 = get_local __ptr slice, _result__________________________________________________, !1054 - v1510 = get_local __ptr slice, __tmp_arg113 - mem_copy_val v1510, v1509 - v1511 = call len_30(v1510) - retd v1508 v1511, !1055 - - block76(): - v1512 = get_local __ptr slice, _method_name, !1056 - v1513 = get_global __ptr string<6>, __const_global25 - v1514 = cast_ptr v1513 to ptr, !1057 - v1515 = get_local __ptr { ptr, u64 }, __anon_52, !1057 - v1516 = const u64 0 - v1517 = get_elem_ptr v1515, __ptr ptr, v1516 - store v1514 to v1517, !1057 - v1518 = const u64 1 - v1519 = get_elem_ptr v1515, __ptr u64, v1518 - v1520 = const u64 6 - store v1520 to v1519, !1057 - v1521 = get_local __ptr slice, __anon_53, !1057 - mem_copy_bytes v1521, v1515, 16 - v1522 = get_local __ptr slice, __tmp_arg51 - mem_copy_val v1522, v1512 - v1523 = get_local __ptr slice, __tmp_arg52 - mem_copy_val v1523, v1521 - v1524 = call eq_11(v1522, v1523) - cbr v1524, block78(), block79(), !1058 - - block78(): - v1525 = get_local __ptr { ptr }, _buffer, !1059 - v1526 = call abi_decode_191(v1525), !1062 - v1527 = get_local __ptr { u64 }, __anon_028, !1063 - v1528 = const u64 0 - v1529 = get_elem_ptr v1527, __ptr u64, v1528, !1064 - store v1526 to v1529, !1065 - v1530 = get_local __ptr { u64 }, args__________________________, !1066 - mem_copy_val v1530, v1527 - v1531 = get_local __ptr { u64 }, args__________________________, !1067 - v1532 = const u64 0 - v1533 = get_elem_ptr v1531, __ptr u64, v1532, !1068 - v1534 = load v1533 - v1535 = get_local __ptr { { ptr, u64, u64 } }, __ret_val33 - v1536 = call new_21(v1535) - v1537 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg165 - mem_copy_val v1537, v1535 - v1538 = get_local __ptr { { ptr, u64, u64 } }, __ret_val107 - v1539 = call abi_encode_198(v1534, v1537, v1538) - v1540 = get_local __ptr { { ptr, u64, u64 } }, buffer26, !1071 - mem_copy_val v1540, v1538 - v1541 = get_local __ptr { { ptr, u64, u64 } }, buffer26, !1072 - v1542 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg84 - mem_copy_val v1542, v1541 - v1543 = get_local __ptr slice, __ret_val62 - v1544 = call as_raw_slice_22(v1542, v1543) - v1545 = get_local __ptr slice, _result____________________________________________________, !1073 - mem_copy_val v1545, v1543 - v1546 = get_local __ptr slice, _result____________________________________________________, !1074 - v1547 = get_local __ptr slice, self_30, !1077 - mem_copy_val v1547, v1546 - v1548 = get_local __ptr slice, self_30, !1078 - v1549 = get_local __ptr slice, slice_30, !1079 - mem_copy_val v1549, v1548 - v1550 = get_local __ptr slice, slice_30, !1080 - v1551 = asm(ptr: v1550) -> __ptr { ptr, u64 } ptr { - } - v1552 = get_local __ptr { ptr, u64 }, __aggr_memcpy_036 - mem_copy_val v1552, v1551 - v1553 = get_local __ptr { ptr, u64 }, __anon_062, !1077 - mem_copy_val v1553, v1552 - v1554 = get_elem_ptr v1553, __ptr ptr, v37, !1081 - v1555 = load v1554, !1077 - v1556 = get_local __ptr slice, _result____________________________________________________, !1082 - v1557 = get_local __ptr slice, __tmp_arg114 - mem_copy_val v1557, v1556 - v1558 = call len_30(v1557) - retd v1555 v1558, !1083 - - block79(): - v1559 = get_local __ptr slice, _method_name, !1084 - v1560 = get_global __ptr string<6>, __const_global26 - v1561 = cast_ptr v1560 to ptr, !1085 - v1562 = get_local __ptr { ptr, u64 }, __anon_54, !1085 - v1563 = const u64 0 - v1564 = get_elem_ptr v1562, __ptr ptr, v1563 - store v1561 to v1564, !1085 - v1565 = const u64 1 - v1566 = get_elem_ptr v1562, __ptr u64, v1565 - v1567 = const u64 6 - store v1567 to v1566, !1085 - v1568 = get_local __ptr slice, __anon_55, !1085 - mem_copy_bytes v1568, v1562, 16 - v1569 = get_local __ptr slice, __tmp_arg53 - mem_copy_val v1569, v1559 - v1570 = get_local __ptr slice, __tmp_arg54 - mem_copy_val v1570, v1568 - v1571 = call eq_11(v1569, v1570) - cbr v1571, block81(), block82(), !1086 - - block81(): - v1572 = get_local __ptr { ptr }, _buffer, !1087 - v1573 = get_elem_ptr v1572, __ptr ptr, v19, !1090 - v1574 = load v1573, !1091 - v1575 = asm(ptr: v1574, val) -> u64 val, !1092 { - lw val ptr i0, !58 - } - v1576 = load v1573, !1091 - v1577 = const u64 8, !1091 - v1578 = add v1576, v1577, !1091 - store v1578 to v1573, !1093 - v1579 = get_local __ptr { u64 }, __anon_029, !1094 - v1580 = get_elem_ptr v1579, __ptr u64, v1201, !1095 - store v1575 to v1580, !1096 - v1581 = get_local __ptr { u64 }, args___________________________, !1097 - mem_copy_val v1581, v1579 - v1582 = get_local __ptr { u64 }, args___________________________, !1098 - v1583 = const u64 0 - v1584 = get_elem_ptr v1582, __ptr u64, v1583, !1099 - v1585 = load v1584 - v1586 = get_local __ptr { { ptr, u64, u64 } }, __ret_val34 - v1587 = call new_21(v1586) - v1588 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg57 - mem_copy_val v1588, v1586 - v1589 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v1590 = call abi_encode_20(v1585, v1588, v1589) - v1591 = get_local __ptr { { ptr, u64, u64 } }, buffer27, !1102 - mem_copy_val v1591, v1589 - v1592 = get_local __ptr { { ptr, u64, u64 } }, buffer27, !1103 - v1593 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg85 - mem_copy_val v1593, v1592 - v1594 = get_local __ptr slice, __ret_val63 - v1595 = call as_raw_slice_22(v1593, v1594) - v1596 = get_local __ptr slice, _result______________________________________________________, !1104 - mem_copy_val v1596, v1594 - v1597 = get_local __ptr slice, _result______________________________________________________, !1105 - v1598 = get_local __ptr slice, self_31, !1108 - mem_copy_val v1598, v1597 - v1599 = get_local __ptr slice, self_31, !1109 - v1600 = get_local __ptr slice, slice_31, !1110 - mem_copy_val v1600, v1599 - v1601 = get_local __ptr slice, slice_31, !1111 - v1602 = asm(ptr: v1601) -> __ptr { ptr, u64 } ptr { - } - v1603 = get_local __ptr { ptr, u64 }, __aggr_memcpy_037 - mem_copy_val v1603, v1602 - v1604 = get_local __ptr { ptr, u64 }, __anon_063, !1108 - mem_copy_val v1604, v1603 - v1605 = get_elem_ptr v1604, __ptr ptr, v37, !1112 - v1606 = load v1605, !1108 - v1607 = get_local __ptr slice, _result______________________________________________________, !1113 - v1608 = get_local __ptr slice, __tmp_arg115 - mem_copy_val v1608, v1607 - v1609 = call len_30(v1608) - retd v1606 v1609, !1114 - - block82(): - v1610 = get_local __ptr slice, _method_name, !1115 - v1611 = get_global __ptr string<5>, __const_global27 - v1612 = cast_ptr v1611 to ptr, !1116 - v1613 = get_local __ptr { ptr, u64 }, __anon_56, !1116 - v1614 = const u64 0 - v1615 = get_elem_ptr v1613, __ptr ptr, v1614 - store v1612 to v1615, !1116 - v1616 = const u64 1 - v1617 = get_elem_ptr v1613, __ptr u64, v1616 - v1618 = const u64 5 - store v1618 to v1617, !1116 - v1619 = get_local __ptr slice, __anon_57, !1116 - mem_copy_bytes v1619, v1613, 16 - v1620 = get_local __ptr slice, __tmp_arg55 - mem_copy_val v1620, v1610 - v1621 = get_local __ptr slice, __tmp_arg56 - mem_copy_val v1621, v1619 - v1622 = call eq_11(v1620, v1621) - cbr v1622, block84(), block85(), !1117 - - block84(): - v1623 = get_local __ptr { ptr }, _buffer, !1118 - v1624 = call read_72(v1623), !1123 - v1625 = get_local __ptr { u8 }, __anon_030, !1124 - v1626 = const u64 0 - v1627 = get_elem_ptr v1625, __ptr u8, v1626, !1125 - store v1624 to v1627, !1126 - v1628 = get_local __ptr { u8 }, args____________________________, !1127 - mem_copy_val v1628, v1625 - v1629 = get_local __ptr { u8 }, args____________________________, !1128 - v1630 = const u64 0 - v1631 = get_elem_ptr v1629, __ptr u8, v1630, !1129 - v1632 = load v1631 - v1633 = get_local __ptr { { ptr, u64, u64 } }, __ret_val35 - v1634 = call new_21(v1633) - v1635 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg166 - mem_copy_val v1635, v1633 - v1636 = get_local __ptr { { ptr, u64, u64 } }, __ret_val108 - v1637 = call abi_encode_206(v1632, v1635, v1636) - v1638 = get_local __ptr { { ptr, u64, u64 } }, buffer28, !1132 - mem_copy_val v1638, v1636 - v1639 = get_local __ptr { { ptr, u64, u64 } }, buffer28, !1133 - v1640 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg86 - mem_copy_val v1640, v1639 - v1641 = get_local __ptr slice, __ret_val64 - v1642 = call as_raw_slice_22(v1640, v1641) - v1643 = get_local __ptr slice, _result________________________________________________________, !1134 - mem_copy_val v1643, v1641 - v1644 = get_local __ptr slice, _result________________________________________________________, !1135 - v1645 = get_local __ptr slice, self_32, !1138 - mem_copy_val v1645, v1644 - v1646 = get_local __ptr slice, self_32, !1139 - v1647 = get_local __ptr slice, slice_32, !1140 - mem_copy_val v1647, v1646 - v1648 = get_local __ptr slice, slice_32, !1141 - v1649 = asm(ptr: v1648) -> __ptr { ptr, u64 } ptr { - } - v1650 = get_local __ptr { ptr, u64 }, __aggr_memcpy_038 - mem_copy_val v1650, v1649 - v1651 = get_local __ptr { ptr, u64 }, __anon_064, !1138 - mem_copy_val v1651, v1650 - v1652 = get_elem_ptr v1651, __ptr ptr, v37, !1142 - v1653 = load v1652, !1138 - v1654 = get_local __ptr slice, _result________________________________________________________, !1143 - v1655 = get_local __ptr slice, __tmp_arg116 - mem_copy_val v1655, v1654 - v1656 = call len_30(v1655) - retd v1653 v1656, !1144 - - block85(): - v1657 = const u64 123, !1145 - revert v1657, !1146 - } - - pub fn read_bytes_8(self !1147: __ptr { ptr }, count !1148: u64, __ret_value: __ptr slice) -> (), !1151 { - local mut slice __aggr_memcpy_0 - local { ptr, u64 } __anon_0 - local slice slice - - entry(self: __ptr { ptr }, count: u64, __ret_value: __ptr slice): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr ptr, v0, !53 - v2 = get_local __ptr { ptr, u64 }, __anon_0, !1152 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr ptr, v3, !1152 - mem_copy_val v4, v1 - v5 = const u64 1 - v6 = get_elem_ptr v2, __ptr u64, v5, !1152 - store count to v6, !1152 - v7 = asm(ptr: v2) -> __ptr slice ptr { - } - v8 = get_local __ptr slice, __aggr_memcpy_0 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, slice, !1153 - mem_copy_val v9, v8 - v10 = load v1 - v11 = add v10, count - store v11 to v1, !1154 - v12 = get_local __ptr slice, slice, !1155 - mem_copy_val __ret_value, v12 - v13 = const unit () - ret () v13 - } - - pub fn eq_11(self: __ptr slice, other: __ptr slice) -> bool, !1159 { - local slice __tmp_arg - local slice __tmp_arg0 - local slice __tmp_arg1 - local slice __tmp_arg2 - local slice __tmp_arg3 - local slice other_ - local slice self_ - - entry(self: __ptr slice, other: __ptr slice): - v0 = get_local __ptr slice, self_ - mem_copy_val v0, self - v1 = get_local __ptr slice, other_ - mem_copy_val v1, other - v2 = get_local __ptr slice, self_, !1160 - v3 = get_local __ptr slice, __tmp_arg - mem_copy_val v3, v2 - v4 = call len_14(v3) - v5 = get_local __ptr slice, other_, !1161 - v6 = get_local __ptr slice, __tmp_arg0 - mem_copy_val v6, v5 - v7 = call len_14(v6) - v8 = cmp eq v4 v7, !1166 - v9 = const bool false, !1167 - v10 = cmp eq v8 v9, !1170 - v11 = const bool false, !1171 - cbr v10, block2(v11), block1(), !1162 - - block1(): - v12 = get_local __ptr slice, self_, !1172 - v13 = get_local __ptr slice, __tmp_arg2 - mem_copy_val v13, v12 - v14 = call as_ptr_15(v13) - v15 = get_local __ptr slice, other_, !1173 - v16 = get_local __ptr slice, __tmp_arg3 - mem_copy_val v16, v15 - v17 = call as_ptr_15(v16) - v18 = get_local __ptr slice, self_, !1174 - v19 = get_local __ptr slice, __tmp_arg1 - mem_copy_val v19, v18 - v20 = call len_14(v19) - v21 = asm(r1: v14, r2: v17, r3: v20, r4) -> bool r4, !1175 { - meq r4 r1 r2 r3, !1176 - } - br block2(v21) - - block2(v22: bool): - ret bool v22 - } - - pub fn len_14(self: __ptr slice) -> u64, !1180 { - local slice self_ - - entry(self: __ptr slice): - v0 = get_local __ptr slice, self_ - mem_copy_val v0, self - v1 = get_local __ptr slice, self_, !1181 - v2 = asm(s: v1) -> __ptr { ptr, u64 } s { - } - v3 = const u64 1 - v4 = get_elem_ptr v2, __ptr u64, v3 - v5 = load v4 - ret u64 v5 - } - - pub fn as_ptr_15(self: __ptr slice) -> ptr, !1184 { - local slice self_ - - entry(self: __ptr slice): - v0 = get_local __ptr slice, self_ - mem_copy_val v0, self - v1 = get_local __ptr slice, self_, !1185 - v2 = asm(s: v1) -> __ptr { ptr, u64 } s { - } - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr ptr, v3 - v5 = load v4 - ret ptr v5 - } - - pub fn abi_decode_18(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 0]) -> (), !1190 { - local [u8; 0] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 0] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 0]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 0, !1191 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1193 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1194 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 0], __anon_0, !1195 - mem_clear_val v13 - v14 = get_local __ptr [u8; 0], array, !1196 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 0], array, !1197 - v16 = cast_ptr v15 to __ptr [u64; 0] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 0 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1199 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1200 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !1201 - br while(v30) - - while(v31: u64): - v32 = const u64 0 - v33 = cmp lt v31 v32, !1204 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !1205 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1206 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1207 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !1210 - v51 = load v50, !1211 - v52 = asm(ptr: v51, val) -> u64 val, !1212 { - lw val ptr i0, !58 - } - v53 = load v50, !1211 - v54 = const u64 8, !1211 - v55 = add v53, v54, !1211 - store v55 to v50, !1213 - store v52 to v48, !1214 - v56 = const u64 1, !1215 - v57 = add v31, v56, !1218 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_20(self !1219: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1222 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local { ptr, u64, u64 } __anon_1 - local { { ptr, u64, u64 } } __anon_2 - local { { ptr, u64, u64 } } buffer_ - - entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1223 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v5, v4 - v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v6, v5 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr ptr, v7 - v9 = load v8 - v10 = const u64 1 - v11 = get_elem_ptr v6, __ptr u64, v10 - v12 = load v11 - v13 = const u64 2 - v14 = get_elem_ptr v6, __ptr u64, v13 - v15 = load v14 - v16 = const u64 8 - v17 = add v15, v16 - v18 = cmp gt v17 v12 - cbr v18, block1(), block0(v9, v12) - - block0(v19: ptr, v20: u64): - v21 = add v19, v15 - v22 = cast_ptr v21 to __ptr u64 - store self to v22 - v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 - v24 = const u64 0 - v25 = get_elem_ptr v23, __ptr ptr, v24 - store v19 to v25 - v26 = const u64 1 - v27 = get_elem_ptr v23, __ptr u64, v26 - store v20 to v27 - v28 = const u64 2 - v29 = get_elem_ptr v23, __ptr u64, v28 - store v17 to v29 - v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { - } - v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v31, v30 - v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !1225 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 - mem_copy_val v34, v31 - mem_copy_val __ret_value, v32 - v35 = const unit () - ret () v35 - - block1(): - v36 = const u64 2 - v37 = mul v12, v36 - v38 = add v37, v16 - v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v39, v38) - } - - pub fn new_21(__ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1228 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local { ptr, u64, u64 } __anon_0 - local { { ptr, u64, u64 } } __anon_1 - - entry(__ret_value: __ptr { { ptr, u64, u64 } }): - v0 = const u64 1024 - v1 = asm(cap: v0) -> ptr hp { - aloc cap - } - v2 = get_local __ptr { ptr, u64, u64 }, __anon_0 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr ptr, v3 - store v1 to v4 - v5 = const u64 1 - v6 = get_elem_ptr v2, __ptr u64, v5 - store v0 to v6 - v7 = const u64 2 - v8 = get_elem_ptr v2, __ptr u64, v7 - v9 = const u64 0 - store v9 to v8 - v10 = asm(buffer: v2) -> __ptr { ptr, u64, u64 } buffer { - } - v11 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v11, v10 - v12 = get_local __ptr { { ptr, u64, u64 } }, __anon_1, !1229 - v13 = const u64 0 - v14 = get_elem_ptr v12, __ptr { ptr, u64, u64 }, v13 - mem_copy_val v14, v11 - mem_copy_val __ret_value, v12 - v15 = const unit () - ret () v15 - } - - pub fn as_raw_slice_22(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice) -> (), !1232 { - local mut slice __aggr_memcpy_00 - local { ptr, u64 } __anon_1 - local { { ptr, u64, u64 } } self_ - - entry(self: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, self_, !1233 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - v7 = load v6 - v8 = const u64 2 - v9 = get_elem_ptr v4, __ptr u64, v8 - v10 = load v9 - v11 = get_local __ptr { ptr, u64 }, __anon_1 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr ptr, v12 - v14 = get_elem_ptr v13, __ptr ptr, - store v7 to v14 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15 - v17 = get_elem_ptr v16, __ptr u64, - store v10 to v17 - v18 = asm(s: v11) -> __ptr slice s { - } - v19 = get_local __ptr slice, __aggr_memcpy_00 - mem_copy_val v19, v18 - mem_copy_val __ret_value, v19 - v20 = const unit () - ret () v20 - } - - pub fn abi_encode_29(self: __ptr [u64; 0], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1236 { - local { { ptr, u64, u64 } } __ret_val - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 0] self_ - - entry(self: __ptr [u64; 0], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr [u64; 0], self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 - mem_copy_val v1, buffer - v2 = const u64 0, !1238 - br while(v2) - - while(v3: u64): - v4 = const u64 0 - v5 = cmp lt v3 v4, !1241 - cbr v5, while_body(), end_while() - - while_body(): - v6 = get_local __ptr [u64; 0], self_, !1242 - v7 = get_elem_ptr v6, __ptr u64, v3, !1243 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 - mem_copy_val v12, v10 - v13 = const u64 1, !1246 - v14 = add v3, v13, !1249 - br while(v14) - - end_while(): - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 - mem_copy_val __ret_value, v15 - v16 = const unit () - ret () v16 - } - - pub fn len_30(self: __ptr slice) -> u64, !1253 { - local slice slice_ - - entry(self: __ptr slice): - v0 = get_local __ptr slice, slice_, !1256 - mem_copy_val v0, self - v1 = get_local __ptr slice, slice_, !1257 - v2 = asm(ptr: v1) -> __ptr { ptr, u64 } ptr { - } - v3 = const u64 1 - v4 = get_elem_ptr v2, __ptr u64, v3 - v5 = load v4 - ret u64 v5 - } - - pub fn abi_decode_34(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 1]) -> (), !1258 { - local [u8; 1] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 1] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 1]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 1, !1191 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1259 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1260 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 1], __anon_0, !1195 - mem_clear_val v13 - v14 = get_local __ptr [u8; 1], array, !1196 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 1], array, !1197 - v16 = cast_ptr v15 to __ptr [u64; 1] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 1 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1261 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1262 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !1201 - br while(v30) - - while(v31: u64): - v32 = const u64 1 - v33 = cmp lt v31 v32, !1263 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !1205 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1264 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1265 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !1266 - v51 = load v50, !1267 - v52 = asm(ptr: v51, val) -> u64 val, !1268 { - lw val ptr i0, !58 - } - v53 = load v50, !1267 - v54 = const u64 8, !1267 - v55 = add v53, v54, !1267 - store v55 to v50, !1269 - store v52 to v48, !1214 - v56 = const u64 1, !1215 - v57 = add v31, v56, !1270 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_37(self: __ptr [u64; 1], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1271 { - local { { ptr, u64, u64 } } __ret_val - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 1] self_ - - entry(self: __ptr [u64; 1], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr [u64; 1], self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 - mem_copy_val v1, buffer - v2 = const u64 0, !1238 - br while(v2) - - while(v3: u64): - v4 = const u64 1 - v5 = cmp lt v3 v4, !1272 - cbr v5, while_body(), end_while() - - while_body(): - v6 = get_local __ptr [u64; 1], self_, !1242 - v7 = get_elem_ptr v6, __ptr u64, v3, !1243 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 - mem_copy_val v12, v10 - v13 = const u64 1, !1246 - v14 = add v3, v13, !1273 - br while(v14) - - end_while(): - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 - mem_copy_val __ret_value, v15 - v16 = const unit () - ret () v16 - } - - pub fn abi_decode_40(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 16]) -> (), !1274 { - local [u8; 16] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 16] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 16]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 16, !1191 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1275 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1276 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 16], __anon_0, !1195 - mem_clear_val v13 - v14 = get_local __ptr [u8; 16], array, !1196 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 16], array, !1197 - v16 = cast_ptr v15 to __ptr [u64; 16] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 16 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1277 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1278 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !1201 - br while(v30) - - while(v31: u64): - v32 = const u64 16 - v33 = cmp lt v31 v32, !1279 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !1205 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1280 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1281 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !1282 - v51 = load v50, !1283 - v52 = asm(ptr: v51, val) -> u64 val, !1284 { - lw val ptr i0, !58 - } - v53 = load v50, !1283 - v54 = const u64 8, !1283 - v55 = add v53, v54, !1283 - store v55 to v50, !1285 - store v52 to v48, !1214 - v56 = const u64 1, !1215 - v57 = add v31, v56, !1286 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_43(self: __ptr [u64; 16], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1287 { - local { { ptr, u64, u64 } } __ret_val - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 16] self_ - - entry(self: __ptr [u64; 16], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr [u64; 16], self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 - mem_copy_val v1, buffer - v2 = const u64 0, !1238 - br while(v2) - - while(v3: u64): - v4 = const u64 16 - v5 = cmp lt v3 v4, !1288 - cbr v5, while_body(), end_while() - - while_body(): - v6 = get_local __ptr [u64; 16], self_, !1242 - v7 = get_elem_ptr v6, __ptr u64, v3, !1243 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 - mem_copy_val v12, v10 - v13 = const u64 1, !1246 - v14 = add v3, v13, !1289 - br while(v14) - - end_while(): - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 - mem_copy_val __ret_value, v15 - v16 = const unit () - ret () v16 - } - - pub fn abi_decode_46(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 32]) -> (), !1290 { - local [u8; 32] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 32] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 32]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 32, !1191 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1291 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1292 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 32], __anon_0, !1195 - mem_clear_val v13 - v14 = get_local __ptr [u8; 32], array, !1196 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 32], array, !1197 - v16 = cast_ptr v15 to __ptr [u64; 32] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 32 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1293 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1294 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !1201 - br while(v30) - - while(v31: u64): - v32 = const u64 32 - v33 = cmp lt v31 v32, !1295 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !1205 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1296 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1297 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !1298 - v51 = load v50, !1299 - v52 = asm(ptr: v51, val) -> u64 val, !1300 { - lw val ptr i0, !58 - } - v53 = load v50, !1299 - v54 = const u64 8, !1299 - v55 = add v53, v54, !1299 - store v55 to v50, !1301 - store v52 to v48, !1214 - v56 = const u64 1, !1215 - v57 = add v31, v56, !1302 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_49(self: __ptr [u64; 32], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1303 { - local { { ptr, u64, u64 } } __ret_val - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 32] self_ - - entry(self: __ptr [u64; 32], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr [u64; 32], self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 - mem_copy_val v1, buffer - v2 = const u64 0, !1238 - br while(v2) - - while(v3: u64): - v4 = const u64 32 - v5 = cmp lt v3 v4, !1304 - cbr v5, while_body(), end_while() - - while_body(): - v6 = get_local __ptr [u64; 32], self_, !1242 - v7 = get_elem_ptr v6, __ptr u64, v3, !1243 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 - mem_copy_val v12, v10 - v13 = const u64 1, !1246 - v14 = add v3, v13, !1305 - br while(v14) - - end_while(): - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 - mem_copy_val __ret_value, v15 - v16 = const unit () - ret () v16 - } - - pub fn abi_decode_52(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 64]) -> (), !1306 { - local [u8; 64] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 64] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 64]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 64, !1191 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1307 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1308 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 64], __anon_0, !1195 - mem_clear_val v13 - v14 = get_local __ptr [u8; 64], array, !1196 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 64], array, !1197 - v16 = cast_ptr v15 to __ptr [u64; 64] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 64 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1309 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1310 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !1201 - br while(v30) - - while(v31: u64): - v32 = const u64 64 - v33 = cmp lt v31 v32, !1311 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !1205 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1312 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1313 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !1314 - v51 = load v50, !1315 - v52 = asm(ptr: v51, val) -> u64 val, !1316 { - lw val ptr i0, !58 - } - v53 = load v50, !1315 - v54 = const u64 8, !1315 - v55 = add v53, v54, !1315 - store v55 to v50, !1317 - store v52 to v48, !1214 - v56 = const u64 1, !1215 - v57 = add v31, v56, !1318 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_55(self: __ptr [u64; 64], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1319 { - local { { ptr, u64, u64 } } __ret_val - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 64] self_ - - entry(self: __ptr [u64; 64], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr [u64; 64], self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 - mem_copy_val v1, buffer - v2 = const u64 0, !1238 - br while(v2) - - while(v3: u64): - v4 = const u64 64 - v5 = cmp lt v3 v4, !1320 - cbr v5, while_body(), end_while() - - while_body(): - v6 = get_local __ptr [u64; 64], self_, !1242 - v7 = get_elem_ptr v6, __ptr u64, v3, !1243 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 - mem_copy_val v12, v10 - v13 = const u64 1, !1246 - v14 = add v3, v13, !1321 - br while(v14) - - end_while(): - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 - mem_copy_val __ret_value, v15 - v16 = const unit () - ret () v16 - } - - pub fn abi_decode_58(buffer !1186: __ptr { ptr }, __ret_value: __ptr [u64; 8]) -> (), !1322 { - local [u8; 8] __anon_0 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local slice __ret_val5 - local slice __ret_val6 - local slice __ret_val7 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local mut [u8; 8] array - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr [u64; 8]): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v2, v0 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = const u64 8, !1191 - v5 = call abi_encode_20(v4, v2, v3) - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1323 - mem_copy_val v6, v3 - v7 = get_local __ptr { { ptr, u64, u64 } }, buffer, !1324 - v8 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v8, v7 - v9 = get_local __ptr slice, __ret_val5 - v10 = call as_raw_slice_22(v8, v9) - v11 = get_local __ptr slice, __log_arg - mem_copy_val v11, v9 - v12 = const u64 1515152261580153489 - log __ptr slice v11, v12 - v13 = get_local __ptr [u8; 8], __anon_0, !1195 - mem_clear_val v13 - v14 = get_local __ptr [u8; 8], array, !1196 - mem_copy_val v14, v13 - v15 = get_local __ptr [u8; 8], array, !1197 - v16 = cast_ptr v15 to __ptr [u64; 8] - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v18 = call new_21(v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v19, v17 - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = const u64 8 - v22 = call abi_encode_20(v21, v19, v20) - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1325 - mem_copy_val v23, v20 - v24 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1326 - v25 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v25, v24 - v26 = get_local __ptr slice, __ret_val6 - v27 = call as_raw_slice_22(v25, v26) - v28 = get_local __ptr slice, __log_arg0 - mem_copy_val v28, v26 - v29 = const u64 1515152261580153489 - log __ptr slice v28, v29 - v30 = const u64 0, !1201 - br while(v30) - - while(v31: u64): - v32 = const u64 8 - v33 = cmp lt v31 v32, !1327 - cbr v33, while_body(), end_while() - - while_body(): - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v35 = call new_21(v34) - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v38 = const u64 2, !1205 - v39 = call abi_encode_20(v38, v36, v37) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1328 - mem_copy_val v40, v37 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1329 - v42 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, __ret_val7 - v44 = call as_raw_slice_22(v42, v43) - v45 = get_local __ptr slice, __log_arg1 - mem_copy_val v45, v43 - v46 = const u64 1515152261580153489 - log __ptr slice v45, v46 - v47 = const u64 8 - v48 = asm(idx: v31, elem_ir_type_size: v47, ptr: v16, offset_temp, ptr_out) -> __ptr u64 ptr_out { - mul offset_temp idx elem_ir_type_size - add ptr_out ptr offset_temp - } - v49 = const u64 0 - v50 = get_elem_ptr buffer, __ptr ptr, v49, !1330 - v51 = load v50, !1331 - v52 = asm(ptr: v51, val) -> u64 val, !1332 { - lw val ptr i0, !58 - } - v53 = load v50, !1331 - v54 = const u64 8, !1331 - v55 = add v53, v54, !1331 - store v55 to v50, !1333 - store v52 to v48, !1214 - v56 = const u64 1, !1215 - v57 = add v31, v56, !1334 - br while(v57) - - end_while(): - mem_copy_val __ret_value, v16 - v58 = const unit () - ret () v58 - } - - pub fn abi_encode_61(self: __ptr [u64; 8], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1335 { - local { { ptr, u64, u64 } } __ret_val - local mut { { ptr, u64, u64 } } buffer__ - local [u64; 8] self_ - - entry(self: __ptr [u64; 8], buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr [u64; 8], self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1237 - mem_copy_val v1, buffer - v2 = const u64 0, !1238 - br while(v2) - - while(v3: u64): - v4 = const u64 8 - v5 = cmp lt v3 v4, !1336 - cbr v5, while_body(), end_while() - - while_body(): - v6 = get_local __ptr [u64; 8], self_, !1242 - v7 = get_elem_ptr v6, __ptr u64, v3, !1243 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1244 - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1245 - mem_copy_val v12, v10 - v13 = const u64 1, !1246 - v14 = add v3, v13, !1337 - br while(v14) - - end_while(): - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1250 - mem_copy_val __ret_value, v15 - v16 = const unit () - ret () v16 - } - - pub fn abi_decode_64(buffer !1338: __ptr { ptr }, __ret_value: __ptr b256) -> (), !1341 { - local mut b256 __aggr_memcpy_0 - local b256 v - - entry(buffer: __ptr { ptr }, __ret_value: __ptr b256): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1344 - v2 = load v1, !1345 - v3 = asm(ptr: v2) -> __ptr b256 ptr { - } - v4 = get_local __ptr b256, __aggr_memcpy_0 - mem_copy_val v4, v3 - v5 = get_local __ptr b256, v, !1347 - mem_copy_val v5, v4 - v6 = load v1, !1345 - v7 = const u64 32, !1345 - v8 = add v6, v7, !1345 - store v8 to v1, !1349 - v9 = get_local __ptr b256, v, !1351 - mem_copy_val __ret_value, v9 - v10 = const unit () - ret () v10 - } - - pub fn abi_encode_68(self: __ptr b256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1354 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local b256 __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local b256 self_ - - entry(self: __ptr b256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr b256, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1355 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr b256, self_, !1356 - v18 = const u64 32 - v19 = add v16, v18 - v20 = cmp gt v19 v13 - cbr v20, block1(), block0(v10, v13) - - block0(v21: ptr, v22: u64): - v23 = get_local __ptr b256, __anon_1 - mem_copy_val v23, v17 - v24 = add v21, v16 - v25 = cast_ptr v24 to __ptr u8 - mem_copy_bytes v25, v23, 32 - v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v27 = const u64 0 - v28 = get_elem_ptr v26, __ptr ptr, v27 - store v21 to v28 - v29 = const u64 1 - v30 = get_elem_ptr v26, __ptr u64, v29 - store v22 to v30 - v31 = const u64 2 - v32 = get_elem_ptr v26, __ptr u64, v31 - store v19 to v32 - v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { - } - v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1357 - v36 = const u64 0 - v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 - mem_copy_val v37, v34 - mem_copy_val __ret_value, v35 - v38 = const unit () - ret () v38 - - block1(): - v39 = const u64 2 - v40 = mul v13, v39 - v41 = add v40, v18 - v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v42, v41) - } - - pub fn read_72(self !1358: __ptr { ptr }) -> u8, !1361 { - entry(self: __ptr { ptr }): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr ptr, v0, !53 - v2 = load v1 - v3 = asm(ptr: v2, val) -> u8 val, !1362 { - lb val ptr i0, !1363 - } - v4 = load v1 - v5 = const u64 1 - v6 = add v4, v5 - store v6 to v1, !1364 - ret u8 v3 - } - - pub fn abi_encode_77(self !1365: bool, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1368 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local { ptr, u64, u64 } __anon_1 - local { { ptr, u64, u64 } } __anon_2 - local { { ptr, u64, u64 } } buffer_ - - entry(self: bool, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1369 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v5, v4 - v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v6, v5 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr ptr, v7 - v9 = load v8 - v10 = const u64 1 - v11 = get_elem_ptr v6, __ptr u64, v10 - v12 = load v11 - v13 = const u64 2 - v14 = get_elem_ptr v6, __ptr u64, v13 - v15 = load v14 - v16 = const u64 1 - v17 = add v15, v16 - v18 = cmp gt v17 v12 - cbr v18, block1(), block0(v9, v12) - - block0(v19: ptr, v20: u64): - v21 = add v19, v15 - v22 = cast_ptr v21 to __ptr bool - store self to v22 - v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 - v24 = const u64 0 - v25 = get_elem_ptr v23, __ptr ptr, v24 - store v19 to v25 - v26 = const u64 1 - v27 = get_elem_ptr v23, __ptr u64, v26 - store v20 to v27 - v28 = const u64 2 - v29 = get_elem_ptr v23, __ptr u64, v28 - store v17 to v29 - v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { - } - v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v31, v30 - v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !1370 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 - mem_copy_val v34, v31 - mem_copy_val __ret_value, v32 - v35 = const unit () - ret () v35 - - block1(): - v36 = const u64 2 - v37 = mul v12, v36 - v38 = add v37, v16 - v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v39, v38) - } - - pub fn abi_decode_80(buffer !1371: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 ) }) -> (), !1374 { - local { u64, ( u64 ) } __anon_0 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 ) }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1377 - v2 = load v1, !1378 - v3 = asm(ptr: v2, val) -> u64 val, !1379 { - lw val ptr i0, !58 - } - v4 = load v1, !1378 - v5 = const u64 8, !1378 - v6 = add v4, v5, !1378 - store v6 to v1, !1380 - v7 = const u64 0, !1381 - v8 = cmp eq v3 v7, !1384 - cbr v8, block0(), block1(), !1382 - - block0(): - v9 = get_local __ptr { u64, ( u64 ) }, __anon_0, !1385 - v10 = const u64 0 - v11 = get_elem_ptr v9, __ptr u64, v10, !1385 - v12 = const u64 0, !1385 - store v12 to v11, !1385 - v13 = load v1, !1388 - v14 = asm(ptr: v13, val) -> u64 val, !1389 { - lw val ptr i0, !58 - } - v15 = load v1, !1388 - v16 = const u64 8, !1388 - v17 = add v15, v16, !1388 - store v17 to v1, !1390 - v18 = const u64 1 - v19 = const u64 0 - v20 = get_elem_ptr v9, __ptr u64, v18, v19, !1385 - store v14 to v20, !1385 - mem_copy_val __ret_value, v9 - v21 = const unit () - ret () v21 - - block1(): - v22 = const u64 0, !1391 - revert v22, !1392 - } - - pub fn abi_encode_83(self: __ptr { u64, ( u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1394 { - local { u64, ( u64 ) } __matched_value_1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - - entry(self: __ptr { u64, ( u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { u64, ( u64 ) }, __matched_value_1, !1395 - mem_copy_val v1, self - v2 = const u64 0 - v3 = get_elem_ptr self, __ptr u64, v2 - v4 = load v3 - v5 = const u64 0, !1396 - v6 = cmp eq v4 v5, !1399 - cbr v6, block0(), block1(), !1397 - - block0(): - v7 = get_local __ptr { u64, ( u64 ) }, __matched_value_1, !1396 - v8 = const u64 1 - v9 = const u64 0 - v10 = get_elem_ptr v7, __ptr u64, v8, v9 - v11 = load v10 - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1400 - v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v14 = const u64 0, !1401 - v15 = call abi_encode_20(v14, v12, v13) - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1402 - mem_copy_val v16, v13 - v17 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v18 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v19 = call abi_encode_20(v11, v17, v18) - v20 = const u64 0 - v21 = const u64 0 - v22 = get_elem_ptr v18, __ptr ptr, v20, v21 - v23 = load v22 - v24 = const u64 0 - v25 = const u64 1 - v26 = get_elem_ptr v18, __ptr u64, v24, v25 - v27 = load v26 - v28 = const u64 0 - v29 = const u64 2 - v30 = get_elem_ptr v18, __ptr u64, v28, v29 - v31 = load v30 - v32 = const u64 0 - v33 = const u64 0 - v34 = get_elem_ptr __ret_value, __ptr ptr, v32, v33 - store v23 to v34 - v35 = const u64 0 - v36 = const u64 1 - v37 = get_elem_ptr __ret_value, __ptr u64, v35, v36 - store v27 to v37 - v38 = const u64 0 - v39 = const u64 2 - v40 = get_elem_ptr __ret_value, __ptr u64, v38, v39 - store v31 to v40 - v41 = const unit () - ret () v41 - - block1(): - v42 = const u64 14757395258967588866, !1395 - revert v42, !1395 - } - - pub fn abi_decode_86(buffer !1403: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 ) }) -> (), !1406 { - local { u64, ( u64 | u64 ) } __anon_0 - local { u64, ( u64 | u64 ) } __anon_1 - local { u64, ( u64 | u64 ) } __tmp_block_arg - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 ) }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1409 - v2 = load v1, !1410 - v3 = asm(ptr: v2, val) -> u64 val, !1411 { - lw val ptr i0, !58 - } - v4 = load v1, !1410 - v5 = const u64 8, !1410 - v6 = add v4, v5, !1410 - store v6 to v1, !1412 - v7 = const u64 0, !1413 - v8 = cmp eq v3 v7, !1416 - cbr v8, block0(), block1(), !1414 - - block0(): - v9 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_0, !1417 - v10 = const u64 0 - v11 = get_elem_ptr v9, __ptr u64, v10, !1417 - v12 = const u64 0, !1417 - store v12 to v11, !1417 - v13 = load v1, !1420 - v14 = asm(ptr: v13, val) -> u64 val, !1421 { - lw val ptr i0, !58 - } - v15 = load v1, !1420 - v16 = const u64 8, !1420 - v17 = add v15, v16, !1420 - store v17 to v1, !1422 - v18 = const u64 1 - v19 = const u64 0 - v20 = get_elem_ptr v9, __ptr u64, v18, v19, !1417 - store v14 to v20, !1417 - v21 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg - mem_copy_val v21, v9 - br block5(v21) - - block1(): - v22 = const u64 1, !1423 - v23 = cmp eq v3 v22, !1426 - cbr v23, block2(), block3(), !1424 - - block2(): - v24 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_1, !1417 - v25 = const u64 0 - v26 = get_elem_ptr v24, __ptr u64, v25, !1417 - v27 = const u64 1, !1417 - store v27 to v26, !1417 - v28 = load v1, !1428 - v29 = asm(ptr: v28, val) -> u64 val, !1429 { - lw val ptr i0, !58 - } - v30 = load v1, !1428 - v31 = const u64 8, !1428 - v32 = add v30, v31, !1428 - store v32 to v1, !1430 - v33 = const u64 1 - v34 = const u64 1 - v35 = get_elem_ptr v24, __ptr u64, v33, v34, !1417 - store v29 to v35, !1417 - v36 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_block_arg - mem_copy_val v36, v24 - br block5(v36) - - block3(): - v37 = const u64 0, !1431 - revert v37, !1432 - - block5(v38: __ptr { u64, ( u64 | u64 ) }): - mem_copy_val __ret_value, v38 - v39 = const unit () - ret () v39 - } - - pub fn abi_encode_89(self: __ptr { u64, ( u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1434 { - local { u64, ( u64 | u64 ) } __matched_value_1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer____ - - entry(self: __ptr { u64, ( u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1435 - mem_copy_val v1, self - v2 = const u64 0 - v3 = get_elem_ptr self, __ptr u64, v2 - v4 = load v3 - v5 = const u64 0, !1436 - v6 = cmp eq v4 v5, !1439 - cbr v6, block0(), block1(), !1437 - - block0(): - v7 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1436 - v8 = const u64 1 - v9 = const u64 0 - v10 = get_elem_ptr v7, __ptr u64, v8, v9 - v11 = load v10 - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1440 - v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v14 = const u64 0, !1441 - v15 = call abi_encode_20(v14, v12, v13) - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1442 - mem_copy_val v16, v13 - v17 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v18 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v19 = call abi_encode_20(v11, v17, v18) - v20 = const u64 0 - v21 = const u64 0 - v22 = get_elem_ptr v18, __ptr ptr, v20, v21 - v23 = load v22 - v24 = const u64 0 - v25 = const u64 1 - v26 = get_elem_ptr v18, __ptr u64, v24, v25 - v27 = load v26 - v28 = const u64 0 - v29 = const u64 2 - v30 = get_elem_ptr v18, __ptr u64, v28, v29 - v31 = load v30 - br block5(v31, v27, v23) - - block1(): - v32 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1436 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr u64, v33, !1436 - v35 = load v34 - v36 = const u64 1, !1436 - v37 = cmp eq v35 v36, !1445 - cbr v37, block2(), block3(), !1443 - - block2(): - v38 = get_local __ptr { u64, ( u64 | u64 ) }, __matched_value_1, !1436 - v39 = const u64 1 - v40 = const u64 1 - v41 = get_elem_ptr v38, __ptr u64, v39, v40 - v42 = load v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1446 - v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v45 = const u64 1, !1447 - v46 = call abi_encode_20(v45, v43, v44) - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1448 - mem_copy_val v47, v44 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer____ - v49 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v50 = call abi_encode_20(v42, v48, v49) - v51 = const u64 0 - v52 = const u64 0 - v53 = get_elem_ptr v49, __ptr ptr, v51, v52 - v54 = load v53 - v55 = const u64 0 - v56 = const u64 1 - v57 = get_elem_ptr v49, __ptr u64, v55, v56 - v58 = load v57 - v59 = const u64 0 - v60 = const u64 2 - v61 = get_elem_ptr v49, __ptr u64, v59, v60 - v62 = load v61 - br block5(v62, v58, v54) - - block3(): - v63 = const u64 14757395258967588866, !1435 - revert v63, !1435 - - block5(v64: u64, v65: u64, v66: ptr): - v67 = const u64 0 - v68 = const u64 0 - v69 = get_elem_ptr __ret_value, __ptr ptr, v67, v68 - store v66 to v69 - v70 = const u64 0 - v71 = const u64 1 - v72 = get_elem_ptr __ret_value, __ptr u64, v70, v71 - store v65 to v72 - v73 = const u64 0 - v74 = const u64 2 - v75 = get_elem_ptr __ret_value, __ptr u64, v73, v74 - store v64 to v75 - v76 = const unit () - ret () v76 - } - - pub fn abi_decode_92(buffer !1449: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 | u64 ) }) -> (), !1452 { - local { u64, ( u64 | u64 | u64 ) } __anon_0 - local { u64, ( u64 | u64 | u64 ) } __anon_1 - local { u64, ( u64 | u64 | u64 ) } __anon_2 - local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg - local { u64, ( u64 | u64 | u64 ) } __tmp_block_arg0 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, ( u64 | u64 | u64 ) }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1455 - v2 = load v1, !1456 - v3 = asm(ptr: v2, val) -> u64 val, !1457 { - lw val ptr i0, !58 - } - v4 = load v1, !1456 - v5 = const u64 8, !1456 - v6 = add v4, v5, !1456 - store v6 to v1, !1458 - v7 = const u64 0, !1459 - v8 = cmp eq v3 v7, !1462 - cbr v8, block0(), block1(), !1460 - - block0(): - v9 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_0, !1463 - v10 = const u64 0 - v11 = get_elem_ptr v9, __ptr u64, v10, !1463 - v12 = const u64 0, !1463 - store v12 to v11, !1463 - v13 = load v1, !1466 - v14 = asm(ptr: v13, val) -> u64 val, !1467 { - lw val ptr i0, !58 - } - v15 = load v1, !1466 - v16 = const u64 8, !1466 - v17 = add v15, v16, !1466 - store v17 to v1, !1468 - v18 = const u64 1 - v19 = const u64 0 - v20 = get_elem_ptr v9, __ptr u64, v18, v19, !1463 - store v14 to v20, !1463 - v21 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg0 - mem_copy_val v21, v9 - br block8(v21) - - block1(): - v22 = const u64 1, !1469 - v23 = cmp eq v3 v22, !1472 - cbr v23, block2(), block3(), !1470 - - block2(): - v24 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_1, !1463 - v25 = const u64 0 - v26 = get_elem_ptr v24, __ptr u64, v25, !1463 - v27 = const u64 1, !1463 - store v27 to v26, !1463 - v28 = load v1, !1475 - v29 = asm(ptr: v28, val) -> u64 val, !1476 { - lw val ptr i0, !58 - } - v30 = load v1, !1475 - v31 = const u64 8, !1475 - v32 = add v30, v31, !1475 - store v32 to v1, !1477 - v33 = const u64 1 - v34 = const u64 1 - v35 = get_elem_ptr v24, __ptr u64, v33, v34, !1463 - store v29 to v35, !1463 - v36 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg - mem_copy_val v36, v24 - br block7(v36) - - block3(): - v37 = const u64 2, !1478 - v38 = cmp eq v3 v37, !1481 - cbr v38, block4(), block5(), !1479 - - block4(): - v39 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_2, !1463 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr u64, v40, !1463 - v42 = const u64 2, !1463 - store v42 to v41, !1463 - v43 = load v1, !1484 - v44 = asm(ptr: v43, val) -> u64 val, !1485 { - lw val ptr i0, !58 - } - v45 = load v1, !1484 - v46 = const u64 8, !1484 - v47 = add v45, v46, !1484 - store v47 to v1, !1486 - v48 = const u64 1 - v49 = const u64 2 - v50 = get_elem_ptr v39, __ptr u64, v48, v49, !1463 - store v44 to v50, !1463 - v51 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg - mem_copy_val v51, v39 - br block7(v51) - - block5(): - v52 = const u64 0, !1487 - revert v52, !1488 - - block7(v53: __ptr { u64, ( u64 | u64 | u64 ) }): - v54 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_block_arg0 - mem_copy_val v54, v53 - br block8(v54) - - block8(v55: __ptr { u64, ( u64 | u64 | u64 ) }): - mem_copy_val __ret_value, v55 - v56 = const unit () - ret () v56 - } - - pub fn abi_encode_95(self: __ptr { u64, ( u64 | u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1490 { - local { u64, ( u64 | u64 | u64 ) } __matched_value_1 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer____ - local { { ptr, u64, u64 } } buffer______ - - entry(self: __ptr { u64, ( u64 | u64 | u64 ) }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1491 - mem_copy_val v1, self - v2 = const u64 0 - v3 = get_elem_ptr self, __ptr u64, v2 - v4 = load v3 - v5 = const u64 0, !1492 - v6 = cmp eq v4 v5, !1495 - cbr v6, block0(), block1(), !1493 - - block0(): - v7 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 - v8 = const u64 1 - v9 = const u64 0 - v10 = get_elem_ptr v7, __ptr u64, v8, v9 - v11 = load v10 - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1496 - v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v14 = const u64 0, !1497 - v15 = call abi_encode_20(v14, v12, v13) - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1498 - mem_copy_val v16, v13 - v17 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v18 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v19 = call abi_encode_20(v11, v17, v18) - v20 = const u64 0 - v21 = const u64 0 - v22 = get_elem_ptr v18, __ptr ptr, v20, v21 - v23 = load v22 - v24 = const u64 0 - v25 = const u64 1 - v26 = get_elem_ptr v18, __ptr u64, v24, v25 - v27 = load v26 - v28 = const u64 0 - v29 = const u64 2 - v30 = get_elem_ptr v18, __ptr u64, v28, v29 - v31 = load v30 - br block8(v31, v27, v23) - - block1(): - v32 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr u64, v33, !1492 - v35 = load v34 - v36 = const u64 1, !1492 - v37 = cmp eq v35 v36, !1501 - cbr v37, block2(), block3(), !1499 - - block2(): - v38 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 - v39 = const u64 1 - v40 = const u64 1 - v41 = get_elem_ptr v38, __ptr u64, v39, v40 - v42 = load v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1502 - v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v45 = const u64 1, !1503 - v46 = call abi_encode_20(v45, v43, v44) - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1504 - mem_copy_val v47, v44 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer____ - v49 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v50 = call abi_encode_20(v42, v48, v49) - v51 = const u64 0 - v52 = const u64 0 - v53 = get_elem_ptr v49, __ptr ptr, v51, v52 - v54 = load v53 - v55 = const u64 0 - v56 = const u64 1 - v57 = get_elem_ptr v49, __ptr u64, v55, v56 - v58 = load v57 - v59 = const u64 0 - v60 = const u64 2 - v61 = get_elem_ptr v49, __ptr u64, v59, v60 - v62 = load v61 - br block7(v62, v58, v54) - - block3(): - v63 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr u64, v64, !1492 - v66 = load v65 - v67 = const u64 2, !1492 - v68 = cmp eq v66 v67, !1507 - cbr v68, block4(), block5(), !1505 - - block4(): - v69 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __matched_value_1, !1492 - v70 = const u64 1 - v71 = const u64 2 - v72 = get_elem_ptr v69, __ptr u64, v70, v71 - v73 = load v72 - v74 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1508 - v75 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v76 = const u64 2, !1509 - v77 = call abi_encode_20(v76, v74, v75) - v78 = get_local __ptr { { ptr, u64, u64 } }, buffer______, !1510 - mem_copy_val v78, v75 - v79 = get_local __ptr { { ptr, u64, u64 } }, buffer______ - v80 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v81 = call abi_encode_20(v73, v79, v80) - v82 = const u64 0 - v83 = const u64 0 - v84 = get_elem_ptr v80, __ptr ptr, v82, v83 - v85 = load v84 - v86 = const u64 0 - v87 = const u64 1 - v88 = get_elem_ptr v80, __ptr u64, v86, v87 - v89 = load v88 - v90 = const u64 0 - v91 = const u64 2 - v92 = get_elem_ptr v80, __ptr u64, v90, v91 - v93 = load v92 - br block7(v93, v89, v85) - - block5(): - v94 = const u64 14757395258967588866, !1491 - revert v94, !1491 - - block7(v95: u64, v96: u64, v97: ptr): - br block8(v95, v96, v97) - - block8(v98: u64, v99: u64, v100: ptr): - v101 = const u64 0 - v102 = const u64 0 - v103 = get_elem_ptr __ret_value, __ptr ptr, v101, v102 - store v100 to v103 - v104 = const u64 0 - v105 = const u64 1 - v106 = get_elem_ptr __ret_value, __ptr u64, v104, v105 - store v99 to v106 - v107 = const u64 0 - v108 = const u64 2 - v109 = get_elem_ptr __ret_value, __ptr u64, v107, v108 - store v98 to v109 - v110 = const unit () - ret () v110 - } - - pub fn abi_encode_101(self: __ptr string<0>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1513 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local string<0> __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local string<0> self_ - - entry(self: __ptr string<0>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr string<0>, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr string<0>, self_, !1515 - v18 = cmp gt v16 v13 - cbr v18, block1(), block0(v10, v13) - - block0(v19: ptr, v20: u64): - v21 = get_local __ptr string<0>, __anon_1 - mem_copy_val v21, v17 - v22 = add v19, v16 - v23 = cast_ptr v22 to __ptr u8 - mem_copy_bytes v23, v21, 0 - v24 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v25 = const u64 0 - v26 = get_elem_ptr v24, __ptr ptr, v25 - store v19 to v26 - v27 = const u64 1 - v28 = get_elem_ptr v24, __ptr u64, v27 - store v20 to v28 - v29 = const u64 2 - v30 = get_elem_ptr v24, __ptr u64, v29 - store v16 to v30 - v31 = asm(buffer: v24) -> __ptr { ptr, u64, u64 } buffer { - } - v32 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v32, v31 - v33 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 - v34 = const u64 0 - v35 = get_elem_ptr v33, __ptr { ptr, u64, u64 }, v34 - mem_copy_val v35, v32 - mem_copy_val __ret_value, v33 - v36 = const unit () - ret () v36 - - block1(): - v37 = const u64 2 - v38 = mul v13, v37 - v39 = asm(new_cap: v38, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v39, v38) - } - - pub fn abi_encode_107(self: __ptr string<1>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1517 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local string<1> __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local string<1> self_ - - entry(self: __ptr string<1>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr string<1>, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr string<1>, self_, !1515 - v18 = const u64 1 - v19 = add v16, v18 - v20 = cmp gt v19 v13 - cbr v20, block1(), block0(v10, v13) - - block0(v21: ptr, v22: u64): - v23 = get_local __ptr string<1>, __anon_1 - mem_copy_val v23, v17 - v24 = add v21, v16 - v25 = cast_ptr v24 to __ptr u8 - mem_copy_bytes v25, v23, 1 - v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v27 = const u64 0 - v28 = get_elem_ptr v26, __ptr ptr, v27 - store v21 to v28 - v29 = const u64 1 - v30 = get_elem_ptr v26, __ptr u64, v29 - store v22 to v30 - v31 = const u64 2 - v32 = get_elem_ptr v26, __ptr u64, v31 - store v19 to v32 - v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { - } - v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 - v36 = const u64 0 - v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 - mem_copy_val v37, v34 - mem_copy_val __ret_value, v35 - v38 = const unit () - ret () v38 - - block1(): - v39 = const u64 2 - v40 = mul v13, v39 - v41 = add v40, v18 - v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v42, v41) - } - - pub fn abi_encode_113(self: __ptr string<16>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1518 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local string<16> __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local string<16> self_ - - entry(self: __ptr string<16>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr string<16>, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr string<16>, self_, !1515 - v18 = const u64 16 - v19 = add v16, v18 - v20 = cmp gt v19 v13 - cbr v20, block1(), block0(v10, v13) - - block0(v21: ptr, v22: u64): - v23 = get_local __ptr string<16>, __anon_1 - mem_copy_val v23, v17 - v24 = add v21, v16 - v25 = cast_ptr v24 to __ptr u8 - mem_copy_bytes v25, v23, 16 - v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v27 = const u64 0 - v28 = get_elem_ptr v26, __ptr ptr, v27 - store v21 to v28 - v29 = const u64 1 - v30 = get_elem_ptr v26, __ptr u64, v29 - store v22 to v30 - v31 = const u64 2 - v32 = get_elem_ptr v26, __ptr u64, v31 - store v19 to v32 - v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { - } - v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 - v36 = const u64 0 - v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 - mem_copy_val v37, v34 - mem_copy_val __ret_value, v35 - v38 = const unit () - ret () v38 - - block1(): - v39 = const u64 2 - v40 = mul v13, v39 - v41 = add v40, v18 - v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v42, v41) - } - - pub fn abi_encode_119(self: __ptr string<32>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1519 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local string<32> __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local string<32> self_ - - entry(self: __ptr string<32>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr string<32>, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr string<32>, self_, !1515 - v18 = const u64 32 - v19 = add v16, v18 - v20 = cmp gt v19 v13 - cbr v20, block1(), block0(v10, v13) - - block0(v21: ptr, v22: u64): - v23 = get_local __ptr string<32>, __anon_1 - mem_copy_val v23, v17 - v24 = add v21, v16 - v25 = cast_ptr v24 to __ptr u8 - mem_copy_bytes v25, v23, 32 - v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v27 = const u64 0 - v28 = get_elem_ptr v26, __ptr ptr, v27 - store v21 to v28 - v29 = const u64 1 - v30 = get_elem_ptr v26, __ptr u64, v29 - store v22 to v30 - v31 = const u64 2 - v32 = get_elem_ptr v26, __ptr u64, v31 - store v19 to v32 - v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { - } - v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 - v36 = const u64 0 - v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 - mem_copy_val v37, v34 - mem_copy_val __ret_value, v35 - v38 = const unit () - ret () v38 - - block1(): - v39 = const u64 2 - v40 = mul v13, v39 - v41 = add v40, v18 - v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v42, v41) - } - - pub fn abi_encode_125(self: __ptr string<8>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1520 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local string<8> __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local string<8> self_ - - entry(self: __ptr string<8>, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr string<8>, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1514 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr string<8>, self_, !1515 - v18 = const u64 8 - v19 = add v16, v18 - v20 = cmp gt v19 v13 - cbr v20, block1(), block0(v10, v13) - - block0(v21: ptr, v22: u64): - v23 = get_local __ptr string<8>, __anon_1 - mem_copy_val v23, v17 - v24 = add v21, v16 - v25 = cast_ptr v24 to __ptr u8 - mem_copy_bytes v25, v23, 8 - v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v27 = const u64 0 - v28 = get_elem_ptr v26, __ptr ptr, v27 - store v21 to v28 - v29 = const u64 1 - v30 = get_elem_ptr v26, __ptr u64, v29 - store v22 to v30 - v31 = const u64 2 - v32 = get_elem_ptr v26, __ptr u64, v31 - store v19 to v32 - v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { - } - v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1516 - v36 = const u64 0 - v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 - mem_copy_val v37, v34 - mem_copy_val __ret_value, v35 - v38 = const unit () - ret () v38 - - block1(): - v39 = const u64 2 - v40 = mul v13, v39 - v41 = add v40, v18 - v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v42, v41) - } - - pub fn abi_decode_128(buffer !1371: __ptr { ptr }, __ret_value: __ptr { u64 }) -> (), !1522 { - local { u64 } __anon_0 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64 }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1525 - v2 = load v1, !1526 - v3 = asm(ptr: v2, val) -> u64 val, !1527 { - lw val ptr i0, !58 - } - v4 = load v1, !1526 - v5 = const u64 8, !1526 - v6 = add v4, v5, !1526 - store v6 to v1, !1528 - v7 = get_local __ptr { u64 }, __anon_0, !1529 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr u64, v8 - store v3 to v9, !1529 - mem_copy_val __ret_value, v7 - v10 = const unit () - ret () v10 - } - - pub fn abi_encode_131(self: __ptr { u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1531 { - local { { ptr, u64, u64 } } __ret_val - - entry(self: __ptr { u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr u64, v0, !1532 - v2 = load v1 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = call abi_encode_20(v2, buffer, v3) - v5 = const u64 0 - v6 = const u64 0 - v7 = get_elem_ptr v3, __ptr ptr, v5, v6 - v8 = load v7 - v9 = const u64 0 - v10 = const u64 1 - v11 = get_elem_ptr v3, __ptr u64, v9, v10 - v12 = load v11 - v13 = const u64 0 - v14 = const u64 2 - v15 = get_elem_ptr v3, __ptr u64, v13, v14 - v16 = load v15 - v17 = const u64 0 - v18 = const u64 0 - v19 = get_elem_ptr __ret_value, __ptr ptr, v17, v18 - store v8 to v19 - v20 = const u64 0 - v21 = const u64 1 - v22 = get_elem_ptr __ret_value, __ptr u64, v20, v21 - store v12 to v22 - v23 = const u64 0 - v24 = const u64 2 - v25 = get_elem_ptr __ret_value, __ptr u64, v23, v24 - store v16 to v25 - v26 = const unit () - ret () v26 - } - - pub fn abi_decode_134(buffer !1403: __ptr { ptr }, __ret_value: __ptr { u64, u64 }) -> (), !1534 { - local { u64, u64 } __anon_0 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, u64 }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1537 - v2 = load v1, !1538 - v3 = asm(ptr: v2, val) -> u64 val, !1539 { - lw val ptr i0, !58 - } - v4 = load v1, !1538 - v5 = const u64 8, !1538 - v6 = add v4, v5, !1538 - store v6 to v1, !1540 - v7 = load v1, !1543 - v8 = asm(ptr: v7, val) -> u64 val, !1544 { - lw val ptr i0, !58 - } - v9 = load v1, !1543 - v10 = const u64 8, !1543 - v11 = add v9, v10, !1543 - store v11 to v1, !1545 - v12 = get_local __ptr { u64, u64 }, __anon_0, !1546 - v13 = const u64 0 - v14 = get_elem_ptr v12, __ptr u64, v13 - store v3 to v14, !1546 - v15 = const u64 1 - v16 = get_elem_ptr v12, __ptr u64, v15 - store v8 to v16, !1546 - mem_copy_val __ret_value, v12 - v17 = const unit () - ret () v17 - } - - pub fn abi_encode_143(self: __ptr { u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1548 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer___ - - entry(self: __ptr { u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr u64, v0, !1549 - v2 = load v1 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = call abi_encode_20(v2, buffer, v3) - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1550 - mem_copy_val v5, v3 - v6 = const u64 1 - v7 = get_elem_ptr self, __ptr u64, v6, !1551 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !1552 - mem_copy_val v12, v10 - v13 = const u64 2 - v14 = get_elem_ptr self, __ptr u64, v13, !1553 - v15 = load v14 - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___ - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v18 = call abi_encode_20(v15, v16, v17) - v19 = const u64 0 - v20 = const u64 0 - v21 = get_elem_ptr v17, __ptr ptr, v19, v20 - v22 = load v21 - v23 = const u64 0 - v24 = const u64 1 - v25 = get_elem_ptr v17, __ptr u64, v23, v24 - v26 = load v25 - v27 = const u64 0 - v28 = const u64 2 - v29 = get_elem_ptr v17, __ptr u64, v27, v28 - v30 = load v29 - v31 = const u64 0 - v32 = const u64 0 - v33 = get_elem_ptr __ret_value, __ptr ptr, v31, v32 - store v22 to v33 - v34 = const u64 0 - v35 = const u64 1 - v36 = get_elem_ptr __ret_value, __ptr u64, v34, v35 - store v26 to v36 - v37 = const u64 0 - v38 = const u64 2 - v39 = get_elem_ptr __ret_value, __ptr u64, v37, v38 - store v30 to v39 - v40 = const unit () - ret () v40 - } - - pub fn abi_encode_159(self: __ptr { u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1556 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } buffer__ - - entry(self: __ptr { u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr u64, v0, !1557 - v2 = load v1 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = call abi_encode_20(v2, buffer, v3) - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1558 - mem_copy_val v5, v3 - v6 = const u64 1 - v7 = get_elem_ptr self, __ptr u64, v6, !1559 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v11 = call abi_encode_20(v8, v9, v10) - v12 = const u64 0 - v13 = const u64 0 - v14 = get_elem_ptr v10, __ptr ptr, v12, v13 - v15 = load v14 - v16 = const u64 0 - v17 = const u64 1 - v18 = get_elem_ptr v10, __ptr u64, v16, v17 - v19 = load v18 - v20 = const u64 0 - v21 = const u64 2 - v22 = get_elem_ptr v10, __ptr u64, v20, v21 - v23 = load v22 - v24 = const u64 0 - v25 = const u64 0 - v26 = get_elem_ptr __ret_value, __ptr ptr, v24, v25 - store v15 to v26 - v27 = const u64 0 - v28 = const u64 1 - v29 = get_elem_ptr __ret_value, __ptr u64, v27, v28 - store v19 to v29 - v30 = const u64 0 - v31 = const u64 2 - v32 = get_elem_ptr __ret_value, __ptr u64, v30, v31 - store v23 to v32 - v33 = const unit () - ret () v33 - } - - pub fn abi_decode_162(buffer !1560: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64 }) -> (), !1563 { - local { u64, u64, u64 } __anon_0 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64 }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1566 - v2 = load v1, !1567 - v3 = asm(ptr: v2, val) -> u64 val, !1568 { - lw val ptr i0, !58 - } - v4 = load v1, !1567 - v5 = const u64 8, !1567 - v6 = add v4, v5, !1567 - store v6 to v1, !1569 - v7 = load v1, !1572 - v8 = asm(ptr: v7, val) -> u64 val, !1573 { - lw val ptr i0, !58 - } - v9 = load v1, !1572 - v10 = const u64 8, !1572 - v11 = add v9, v10, !1572 - store v11 to v1, !1574 - v12 = load v1, !1577 - v13 = asm(ptr: v12, val) -> u64 val, !1578 { - lw val ptr i0, !58 - } - v14 = load v1, !1577 - v15 = const u64 8, !1577 - v16 = add v14, v15, !1577 - store v16 to v1, !1579 - v17 = get_local __ptr { u64, u64, u64 }, __anon_0, !1580 - v18 = const u64 0 - v19 = get_elem_ptr v17, __ptr u64, v18, !1580 - store v3 to v19, !1580 - v20 = const u64 1 - v21 = get_elem_ptr v17, __ptr u64, v20, !1580 - store v8 to v21, !1580 - v22 = const u64 2 - v23 = get_elem_ptr v17, __ptr u64, v22, !1580 - store v13 to v23, !1580 - mem_copy_val __ret_value, v17 - v24 = const unit () - ret () v24 - } - - pub fn abi_decode_168(buffer !1581: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64, u64 }) -> (), !1584 { - local { u64, u64, u64, u64 } __anon_0 - - entry(buffer: __ptr { ptr }, __ret_value: __ptr { u64, u64, u64, u64 }): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1587 - v2 = load v1, !1588 - v3 = asm(ptr: v2, val) -> u64 val, !1589 { - lw val ptr i0, !58 - } - v4 = load v1, !1588 - v5 = const u64 8, !1588 - v6 = add v4, v5, !1588 - store v6 to v1, !1590 - v7 = load v1, !1593 - v8 = asm(ptr: v7, val) -> u64 val, !1594 { - lw val ptr i0, !58 - } - v9 = load v1, !1593 - v10 = const u64 8, !1593 - v11 = add v9, v10, !1593 - store v11 to v1, !1595 - v12 = load v1, !1598 - v13 = asm(ptr: v12, val) -> u64 val, !1599 { - lw val ptr i0, !58 - } - v14 = load v1, !1598 - v15 = const u64 8, !1598 - v16 = add v14, v15, !1598 - store v16 to v1, !1600 - v17 = load v1, !1603 - v18 = asm(ptr: v17, val) -> u64 val, !1604 { - lw val ptr i0, !58 - } - v19 = load v1, !1603 - v20 = const u64 8, !1603 - v21 = add v19, v20, !1603 - store v21 to v1, !1605 - v22 = get_local __ptr { u64, u64, u64, u64 }, __anon_0, !1606 - v23 = const u64 0 - v24 = get_elem_ptr v22, __ptr u64, v23, !1606 - store v3 to v24, !1606 - v25 = const u64 1 - v26 = get_elem_ptr v22, __ptr u64, v25, !1606 - store v8 to v26, !1606 - v27 = const u64 2 - v28 = get_elem_ptr v22, __ptr u64, v27, !1606 - store v13 to v28, !1606 - v29 = const u64 3 - v30 = get_elem_ptr v22, __ptr u64, v29, !1606 - store v18 to v30, !1606 - mem_copy_val __ret_value, v22 - v31 = const unit () - ret () v31 - } - - pub fn abi_encode_171(self: __ptr { u64, u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1609 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer___ - local { { ptr, u64, u64 } } buffer____ - - entry(self: __ptr { u64, u64, u64, u64 }, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = const u64 0 - v1 = get_elem_ptr self, __ptr u64, v0, !1610 - v2 = load v1 - v3 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v4 = call abi_encode_20(v2, buffer, v3) - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1611 - mem_copy_val v5, v3 - v6 = const u64 1 - v7 = get_elem_ptr self, __ptr u64, v6, !1612 - v8 = load v7 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v10 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v11 = call abi_encode_20(v8, v9, v10) - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !1613 - mem_copy_val v12, v10 - v13 = const u64 2 - v14 = get_elem_ptr self, __ptr u64, v13, !1614 - v15 = load v14 - v16 = get_local __ptr { { ptr, u64, u64 } }, buffer___ - v17 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v18 = call abi_encode_20(v15, v16, v17) - v19 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1615 - mem_copy_val v19, v17 - v20 = const u64 3 - v21 = get_elem_ptr self, __ptr u64, v20, !1616 - v22 = load v21 - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer____ - v24 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v25 = call abi_encode_20(v22, v23, v24) - v26 = const u64 0 - v27 = const u64 0 - v28 = get_elem_ptr v24, __ptr ptr, v26, v27 - v29 = load v28 - v30 = const u64 0 - v31 = const u64 1 - v32 = get_elem_ptr v24, __ptr u64, v30, v31 - v33 = load v32 - v34 = const u64 0 - v35 = const u64 2 - v36 = get_elem_ptr v24, __ptr u64, v34, v35 - v37 = load v36 - v38 = const u64 0 - v39 = const u64 0 - v40 = get_elem_ptr __ret_value, __ptr ptr, v38, v39 - store v29 to v40 - v41 = const u64 0 - v42 = const u64 1 - v43 = get_elem_ptr __ret_value, __ptr u64, v41, v42 - store v33 to v43 - v44 = const u64 0 - v45 = const u64 2 - v46 = get_elem_ptr __ret_value, __ptr u64, v44, v45 - store v37 to v46 - v47 = const unit () - ret () v47 - } - - pub fn abi_encode_181(self !1617: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1620 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local u64 __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - - entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1621 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v5, v4 - v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v6, v5 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr ptr, v7 - v9 = load v8 - v10 = const u64 1 - v11 = get_elem_ptr v6, __ptr u64, v10 - v12 = load v11 - v13 = const u64 2 - v14 = get_elem_ptr v6, __ptr u64, v13 - v15 = load v14 - v16 = const u64 2 - v17 = add v15, v16 - v18 = cmp gt v17 v12 - cbr v18, block1(), block0(v9, v12) - - block0(v19: ptr, v20: u64): - v21 = get_local __ptr u64, __anon_1 - store self to v21 - v22 = const u64 6 - v23 = add v21, v22 - v24 = cast_ptr v23 to __ptr u8 - v25 = add v19, v15 - v26 = cast_ptr v25 to __ptr u8 - mem_copy_bytes v26, v24, 2 - v27 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v28 = const u64 0 - v29 = get_elem_ptr v27, __ptr ptr, v28 - store v19 to v29 - v30 = const u64 1 - v31 = get_elem_ptr v27, __ptr u64, v30 - store v20 to v31 - v32 = const u64 2 - v33 = get_elem_ptr v27, __ptr u64, v32 - store v17 to v33 - v34 = asm(buffer: v27) -> __ptr { ptr, u64, u64 } buffer { - } - v35 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v35, v34 - v36 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1622 - v37 = const u64 0 - v38 = get_elem_ptr v36, __ptr { ptr, u64, u64 }, v37 - mem_copy_val v38, v35 - mem_copy_val __ret_value, v36 - v39 = const unit () - ret () v39 - - block1(): - v40 = const u64 2 - v41 = mul v12, v40 - v42 = add v41, v16 - v43 = asm(new_cap: v42, old_ptr: v9, len: v15) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v43, v42) - } - - pub fn abi_decode_184(buffer !1623: __ptr { ptr }, __ret_value: __ptr u256) -> (), !1626 { - local mut u256 __aggr_memcpy_0 - local u256 v - - entry(buffer: __ptr { ptr }, __ret_value: __ptr u256): - v0 = const u64 0 - v1 = get_elem_ptr buffer, __ptr ptr, v0, !1629 - v2 = load v1, !1630 - v3 = asm(ptr: v2) -> __ptr u256 ptr { - } - v4 = get_local __ptr u256, __aggr_memcpy_0 - mem_copy_val v4, v3 - v5 = get_local __ptr u256, v, !1631 - mem_copy_val v5, v4 - v6 = load v1, !1630 - v7 = const u64 32, !1630 - v8 = add v6, v7, !1630 - store v8 to v1, !1632 - v9 = get_local __ptr u256, v, !1633 - mem_copy_val __ret_value, v9 - v10 = const unit () - ret () v10 - } - - pub fn abi_encode_188(self: __ptr u256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1636 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local u256 __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - local u256 self_ - - entry(self: __ptr u256, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr u256, self_ - mem_copy_val v0, self - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v1, buffer - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1637 - v3 = const u64 0 - v4 = get_elem_ptr v2, __ptr { ptr, u64, u64 }, v3, !1224 - v5 = asm(buffer: v4) -> __ptr { ptr, u64, u64 } buffer { - } - v6 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v6, v5 - v7 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v7, v6 - v8 = const u64 0 - v9 = get_elem_ptr v7, __ptr ptr, v8 - v10 = load v9 - v11 = const u64 1 - v12 = get_elem_ptr v7, __ptr u64, v11 - v13 = load v12 - v14 = const u64 2 - v15 = get_elem_ptr v7, __ptr u64, v14 - v16 = load v15 - v17 = get_local __ptr u256, self_, !1638 - v18 = const u64 32 - v19 = add v16, v18 - v20 = cmp gt v19 v13 - cbr v20, block1(), block0(v10, v13) - - block0(v21: ptr, v22: u64): - v23 = get_local __ptr u256, __anon_1 - mem_copy_val v23, v17 - v24 = add v21, v16 - v25 = cast_ptr v24 to __ptr u8 - mem_copy_bytes v25, v23, 32 - v26 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v27 = const u64 0 - v28 = get_elem_ptr v26, __ptr ptr, v27 - store v21 to v28 - v29 = const u64 1 - v30 = get_elem_ptr v26, __ptr u64, v29 - store v22 to v30 - v31 = const u64 2 - v32 = get_elem_ptr v26, __ptr u64, v31 - store v19 to v32 - v33 = asm(buffer: v26) -> __ptr { ptr, u64, u64 } buffer { - } - v34 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1639 - v36 = const u64 0 - v37 = get_elem_ptr v35, __ptr { ptr, u64, u64 }, v36 - mem_copy_val v37, v34 - mem_copy_val __ret_value, v35 - v38 = const unit () - ret () v38 - - block1(): - v39 = const u64 2 - v40 = mul v13, v39 - v41 = add v40, v18 - v42 = asm(new_cap: v41, old_ptr: v10, len: v16) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v42, v41) - } - - pub fn abi_decode_191(buffer !1640: __ptr { ptr }) -> u64, !1643 { - entry(buffer: __ptr { ptr }): - v0 = call read_72(buffer), !1646 - v1 = asm(input: v0) -> u64 input, !1649 { - } - v2 = call read_72(buffer), !1652 - v3 = asm(input: v2) -> u64 input, !1655 { - } - v4 = call read_72(buffer), !1658 - v5 = asm(input: v4) -> u64 input, !1661 { - } - v6 = call read_72(buffer), !1664 - v7 = asm(input: v6) -> u64 input, !1667 { - } - v8 = const u64 24, !1668 - v9 = lsh v1, v8, !1671 - v10 = const u64 4294967295, !1672 - v11 = and v9, v10, !1671 - v12 = const u64 16, !1673 - v13 = lsh v3, v12, !1676 - v14 = and v13, v10, !1676 - v15 = or v11, v14, !1679 - v16 = const u64 8, !1680 - v17 = lsh v5, v16, !1683 - v18 = and v17, v10, !1683 - v19 = or v15, v18, !1686 - v20 = or v19, v7, !1689 - ret u64 v20 - } - - pub fn abi_encode_198(self !1690: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1693 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local u64 __anon_1 - local { ptr, u64, u64 } __anon_2 - local { { ptr, u64, u64 } } __anon_3 - local { { ptr, u64, u64 } } buffer_ - - entry(self: u64, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1694 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v5, v4 - v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v6, v5 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr ptr, v7 - v9 = load v8 - v10 = const u64 1 - v11 = get_elem_ptr v6, __ptr u64, v10 - v12 = load v11 - v13 = const u64 2 - v14 = get_elem_ptr v6, __ptr u64, v13 - v15 = load v14 - v16 = const u64 4 - v17 = add v15, v16 - v18 = cmp gt v17 v12 - cbr v18, block1(), block0(v9, v12) - - block0(v19: ptr, v20: u64): - v21 = get_local __ptr u64, __anon_1 - store self to v21 - v22 = const u64 4 - v23 = add v21, v22 - v24 = cast_ptr v23 to __ptr u8 - v25 = add v19, v15 - v26 = cast_ptr v25 to __ptr u8 - mem_copy_bytes v26, v24, 4 - v27 = get_local __ptr { ptr, u64, u64 }, __anon_2 - v28 = const u64 0 - v29 = get_elem_ptr v27, __ptr ptr, v28 - store v19 to v29 - v30 = const u64 1 - v31 = get_elem_ptr v27, __ptr u64, v30 - store v20 to v31 - v32 = const u64 2 - v33 = get_elem_ptr v27, __ptr u64, v32 - store v17 to v33 - v34 = asm(buffer: v27) -> __ptr { ptr, u64, u64 } buffer { - } - v35 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v35, v34 - v36 = get_local __ptr { { ptr, u64, u64 } }, __anon_3, !1695 - v37 = const u64 0 - v38 = get_elem_ptr v36, __ptr { ptr, u64, u64 }, v37 - mem_copy_val v38, v35 - mem_copy_val __ret_value, v36 - v39 = const unit () - ret () v39 - - block1(): - v40 = const u64 2 - v41 = mul v12, v40 - v42 = add v41, v16 - v43 = asm(new_cap: v42, old_ptr: v9, len: v15) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v43, v42) - } - - pub fn abi_encode_206(self !1696: u8, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }) -> (), !1699 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { ptr, u64, u64 } __aggr_memcpy_00 - local { ptr, u64, u64 } __anon_0 - local { ptr, u64, u64 } __anon_1 - local { { ptr, u64, u64 } } __anon_2 - local { { ptr, u64, u64 } } buffer_ - - entry(self: u8, buffer: __ptr { { ptr, u64, u64 } }, __ret_value: __ptr { { ptr, u64, u64 } }): - v0 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - mem_copy_val v0, buffer - v1 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1700 - v2 = const u64 0 - v3 = get_elem_ptr v1, __ptr { ptr, u64, u64 }, v2, !1224 - v4 = asm(buffer: v3) -> __ptr { ptr, u64, u64 } buffer { - } - v5 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v5, v4 - v6 = get_local __ptr { ptr, u64, u64 }, __anon_0 - mem_copy_val v6, v5 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr ptr, v7 - v9 = load v8 - v10 = const u64 1 - v11 = get_elem_ptr v6, __ptr u64, v10 - v12 = load v11 - v13 = const u64 2 - v14 = get_elem_ptr v6, __ptr u64, v13 - v15 = load v14 - v16 = const u64 1 - v17 = add v15, v16 - v18 = cmp gt v17 v12 - cbr v18, block1(), block0(v9, v12) - - block0(v19: ptr, v20: u64): - v21 = add v19, v15 - v22 = cast_ptr v21 to __ptr u8 - store self to v22 - v23 = get_local __ptr { ptr, u64, u64 }, __anon_1 - v24 = const u64 0 - v25 = get_elem_ptr v23, __ptr ptr, v24 - store v19 to v25 - v26 = const u64 1 - v27 = get_elem_ptr v23, __ptr u64, v26 - store v20 to v27 - v28 = const u64 2 - v29 = get_elem_ptr v23, __ptr u64, v28 - store v17 to v29 - v30 = asm(buffer: v23) -> __ptr { ptr, u64, u64 } buffer { - } - v31 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_00 - mem_copy_val v31, v30 - v32 = get_local __ptr { { ptr, u64, u64 } }, __anon_2, !1701 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr { ptr, u64, u64 }, v33 - mem_copy_val v34, v31 - mem_copy_val __ret_value, v32 - v35 = const unit () - ret () v35 - - block1(): - v36 = const u64 2 - v37 = mul v12, v36 - v38 = add v37, v16 - v39 = asm(new_cap: v38, old_ptr: v9, len: v15) -> __ptr u8 hp { - aloc new_cap - mcp hp old_ptr len - } - br block0(v39, v38) - } - - entry fn cost_of_in_bool() -> (), !1705 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { bool } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local slice __ret_val14 - local slice __ret_val15 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { b256, u64, u64 } __tmp_arg10 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { { ptr, u64, u64 } } __tmp_arg8 - local slice __tmp_arg9 - local { bool } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { bool } item_ - local slice method_name_ - local slice params - local slice second_parameter - local { bool } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1706 - v2 = get_global __ptr string<7>, __const_global28 - v3 = cast_ptr v2 to ptr, !1707 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !1707 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !1707 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 7 - store v9 to v8, !1707 - v10 = get_local __ptr slice, __anon_1, !1707 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { bool }, __anon_2 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr bool, v12 - v14 = const bool false, !1708 - store v14 to v13 - v15 = get_local __ptr b256, contract_id_, !1709 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !1709 - mem_copy_val v16, v10 - v17 = get_local __ptr { bool }, args_, !1709 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, asset_id_, !1709 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !1711 - v20 = get_local __ptr slice, __tmp_arg9 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val14 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !1713 - mem_copy_val v23, v21 - v24 = get_local __ptr { bool }, args_, !1715 - v25 = get_local __ptr { bool }, item_, !1718 - mem_copy_val v25, v24 - v26 = get_local __ptr { bool }, item_, !1719 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { bool }, self_, !1722 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1723 - mem_copy_val v30, v27 - v31 = get_local __ptr { bool }, self_, !1725 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr bool, v32, !1727 - v34 = load v33, !1728 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1730 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 - mem_copy_val v36, v35 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v38 = call abi_encode_77(v34, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1732 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1734 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1735 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1736 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val8 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !1738 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !1740 - v48 = get_local __ptr slice, first_parameter, !1742 - v49 = get_local __ptr slice, self_0, !1745 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !1746 - v51 = get_local __ptr slice, slice_, !1747 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !1748 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !1745 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !1749 - v58 = load v57, !1745 - v59 = asm(a: v58) -> u64 a, !1751 { - } - v60 = get_local __ptr slice, second_parameter, !1753 - v61 = get_local __ptr slice, self_1, !1756 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !1757 - v63 = get_local __ptr slice, slice_0, !1758 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !1759 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !1756 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !1760 - v69 = load v68, !1756 - v70 = asm(a: v69) -> u64 a, !1762 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !1764 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !1765 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !1766 - store v59 to v75, !1767 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !1768 - store v70 to v77, !1769 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val15 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !1771 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1773 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1774 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val9 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !1776 - v96 = get_local __ptr slice, self_2, !1779 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !1780 - v98 = get_local __ptr slice, slice_1, !1781 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !1782 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !1779 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !1783 - v104 = load v103, !1779 - v105 = get_local __ptr b256, asset_id_, !1785 - v106 = get_local __ptr b256, __anon_10, !1709 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !1709 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !1787 - v111 = asm() -> ptr ret, !1789 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1791 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1792 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val10 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !1796 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !1797 - store v111 to v127, !1798 - v128 = get_local __ptr { ptr }, buffer, !1800 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1802 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1803 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val11 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !1805 - v143 = call read_72(v142), !1808 - v144 = const u8 0, !353 - v145 = cmp eq v143 v144, !1809 - cbr v145, abi_decode_71_block5(), abi_decode_71_block1(), !1810 - - abi_decode_71_block1(): - v146 = const u8 1, !359 - v147 = cmp eq v143 v146, !1811 - cbr v147, abi_decode_71_block5(), abi_decode_71_block3(), !1812 - - abi_decode_71_block3(): - v148 = const u64 0, !365 - revert v148, !1813 - - abi_decode_71_block5(): - v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v150 = call new_21(v149) - v151 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v151, v149 - v152 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v153 = const u64 103, !1814 - v154 = call abi_encode_20(v153, v151, v152) - v155 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1815 - mem_copy_val v155, v152 - v156 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1816 - v157 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v157, v156 - v158 = get_local __ptr slice, __ret_val12 - v159 = call as_raw_slice_22(v157, v158) - v160 = get_local __ptr slice, __log_arg2 - mem_copy_val v160, v158 - v161 = const u64 1515152261580153489 - log __ptr slice v160, v161 - v162 = const unit () - ret () v162 - } - - pub fn encode_208(item: __ptr slice, __ret_value: __ptr slice) -> (), !1819 { - local mut { ptr, u64, u64 } __aggr_memcpy_0 - local mut { u64, u64 } __aggr_memcpy_00 - local mut slice __aggr_memcpy_01 - local mut { ptr, u64, u64 } __aggr_memcpy_02 - local { ptr, u64, u64 } __anon_0 - local { u64, u64 } __anon_1 - local slice __anon_2 - local { ptr, u64, u64 } __anon_3 - local { { ptr, u64, u64 } } __anon_4 - local { { ptr, u64, u64 } } __ret_val - local slice __ret_val0 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } buffer - local { { ptr, u64, u64 } } buffer_ - local slice item_ - local slice self_ - - entry(item: __ptr slice, __ret_value: __ptr slice): - v0 = get_local __ptr slice, item_ - mem_copy_val v0, item - v1 = get_local __ptr slice, item_, !109 - v2 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v3 = call new_21(v2) - v4 = get_local __ptr slice, self_, !1820 - mem_copy_val v4, v1 - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1820 - mem_copy_val v5, v2 - v6 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1822 - v7 = const u64 0 - v8 = get_elem_ptr v6, __ptr { ptr, u64, u64 }, v7, !1823 - v9 = asm(buffer: v8) -> __ptr { ptr, u64, u64 } buffer { - } - v10 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_0 - mem_copy_val v10, v9 - v11 = get_local __ptr { ptr, u64, u64 }, __anon_0, !1820 - mem_copy_val v11, v10 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr ptr, v12, !1820 - v14 = load v13, !1820 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15, !1820 - v17 = load v16, !1820 - v18 = const u64 2 - v19 = get_elem_ptr v11, __ptr u64, v18, !1820 - v20 = load v19, !1820 - v21 = get_local __ptr slice, self_, !1825 - v22 = get_local __ptr slice, __aggr_memcpy_01 - mem_copy_val v22, v21 - v23 = asm(item: v21) -> __ptr { u64, u64 } item { - } - v24 = get_local __ptr { u64, u64 }, __aggr_memcpy_00 - mem_copy_val v24, v23 - v25 = get_local __ptr { u64, u64 }, __anon_1, !1820 - mem_copy_val v25, v24 - v26 = const u64 1 - v27 = get_elem_ptr v25, __ptr u64, v26, !1820 - v28 = load v27, !1820 - v29 = const u64 8 - v30 = add v28, v29, !1820 - v31 = add v20, v30, !1820 - v32 = cmp gt v31 v17, !1820 - cbr v32, abi_encode_209_block1(), abi_encode_209_block0(v14, v17), !1820 - - abi_encode_209_block0(v33: ptr, v34: u64): - v35 = get_local __ptr slice, __anon_2, !1820 - mem_copy_val v35, v22 - v36 = add v33, v20, !1820 - v37 = cast_ptr v36 to __ptr u8, !1820 - v38 = asm(item_ptr: v35, len: v20, addr: v37, data_ptr, item_len, new_len) -> u64 new_len, !1820 { - lw item_len item_ptr i1 - sw addr item_len i0 - addi addr addr i8 - lw data_ptr item_ptr i0 - mcp addr data_ptr item_len - addi new_len len i8 - add new_len new_len item_len - } - v39 = get_local __ptr { ptr, u64, u64 }, __anon_3, !1820 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr ptr, v40, !1820 - store v33 to v41, !1820 - v42 = const u64 1 - v43 = get_elem_ptr v39, __ptr u64, v42, !1820 - store v34 to v43, !1820 - v44 = const u64 2 - v45 = get_elem_ptr v39, __ptr u64, v44, !1820 - store v38 to v45, !1820 - v46 = asm(buffer: v39) -> __ptr { ptr, u64, u64 } buffer { - } - v47 = get_local __ptr { ptr, u64, u64 }, __aggr_memcpy_02 - mem_copy_val v47, v46 - v48 = get_local __ptr { { ptr, u64, u64 } }, __anon_4, !1827 - v49 = const u64 0 - v50 = get_elem_ptr v48, __ptr { ptr, u64, u64 }, v49, !1820 - mem_copy_val v50, v47 - v51 = get_local __ptr { { ptr, u64, u64 } }, buffer, !111 - mem_copy_val v51, v48 - v52 = get_local __ptr { { ptr, u64, u64 } }, buffer, !113 - v53 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v53, v52 - v54 = get_local __ptr slice, __ret_val0 - v55 = call as_raw_slice_22(v53, v54) - mem_copy_val __ret_value, v54 - v56 = const unit () - ret () v56 - - abi_encode_209_block1(): - v57 = const u64 2 - v58 = mul v17, v57, !1820 - v59 = add v58, v30, !1820 - v60 = asm(new_cap: v59, old_ptr: v14, len: v20) -> __ptr u8 hp, !1820 { - aloc new_cap - mcp hp old_ptr len - } - br abi_encode_209_block0(v60, v59), !1820 - } - - pub fn encode_212(item: __ptr { b256, u64, u64 }, __ret_value: __ptr slice) -> (), !1828 { - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local { { ptr, u64, u64 } } buffer___ - local { { ptr, u64, u64 } } buffer____ - - entry(item: __ptr { b256, u64, u64 }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1829 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr b256, v3, !1831 - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v7 = call abi_encode_68(v4, v5, v6) - v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1833 - mem_copy_val v8, v6 - v9 = const u64 1 - v10 = get_elem_ptr item, __ptr u64, v9, !1835 - v11 = load v10, !1829 - v12 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v13 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v14 = call abi_encode_20(v11, v12, v13) - v15 = get_local __ptr { { ptr, u64, u64 } }, buffer___, !1837 - mem_copy_val v15, v13 - v16 = const u64 2 - v17 = get_elem_ptr item, __ptr u64, v16, !1839 - v18 = load v17, !1829 - v19 = get_local __ptr { { ptr, u64, u64 } }, buffer___ - v20 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v21 = call abi_encode_20(v18, v19, v20) - v22 = get_local __ptr { { ptr, u64, u64 } }, buffer____, !1841 - mem_copy_val v22, v20 - v23 = get_local __ptr { { ptr, u64, u64 } }, buffer____ - v24 = get_local __ptr slice, __ret_val2 - v25 = call as_raw_slice_22(v23, v24) - mem_copy_val __ret_value, v24 - v26 = const unit () - ret () v26 - } - - entry fn cost_of_in_u8() -> (), !1845 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u8 } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local slice __ret_val14 - local slice __ret_val15 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { b256, u64, u64 } __tmp_arg10 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { { ptr, u64, u64 } } __tmp_arg8 - local slice __tmp_arg9 - local { u8 } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { u8 } item_ - local slice method_name_ - local slice params - local slice second_parameter - local { u8 } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1846 - v2 = get_global __ptr string<5>, __const_global29 - v3 = cast_ptr v2 to ptr, !1847 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !1847 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !1847 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 5 - store v9 to v8, !1847 - v10 = get_local __ptr slice, __anon_1, !1847 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u8 }, __anon_2 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u8, v12 - v14 = const u8 0, !1848 - store v14 to v13 - v15 = get_local __ptr b256, contract_id_, !1849 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !1849 - mem_copy_val v16, v10 - v17 = get_local __ptr { u8 }, args_, !1849 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, asset_id_, !1849 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !1850 - v20 = get_local __ptr slice, __tmp_arg9 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val14 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !1851 - mem_copy_val v23, v21 - v24 = get_local __ptr { u8 }, args_, !1852 - v25 = get_local __ptr { u8 }, item_, !1853 - mem_copy_val v25, v24 - v26 = get_local __ptr { u8 }, item_, !1854 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { u8 }, self_, !1855 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1856 - mem_copy_val v30, v27 - v31 = get_local __ptr { u8 }, self_, !1857 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr u8, v32, !1858 - v34 = load v33, !1859 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1860 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 - mem_copy_val v36, v35 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v38 = call abi_encode_206(v34, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1861 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1862 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1863 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1864 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val8 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !1865 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !1866 - v48 = get_local __ptr slice, first_parameter, !1867 - v49 = get_local __ptr slice, self_0, !1868 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !1869 - v51 = get_local __ptr slice, slice_, !1870 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !1871 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !1868 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !1872 - v58 = load v57, !1868 - v59 = asm(a: v58) -> u64 a, !1873 { - } - v60 = get_local __ptr slice, second_parameter, !1874 - v61 = get_local __ptr slice, self_1, !1875 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !1876 - v63 = get_local __ptr slice, slice_0, !1877 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !1878 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !1875 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !1879 - v69 = load v68, !1875 - v70 = asm(a: v69) -> u64 a, !1880 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !1881 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !1882 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !1883 - store v59 to v75, !1884 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !1885 - store v70 to v77, !1886 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val15 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !1887 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1888 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1889 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val9 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !1890 - v96 = get_local __ptr slice, self_2, !1891 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !1892 - v98 = get_local __ptr slice, slice_1, !1893 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !1894 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !1891 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !1895 - v104 = load v103, !1891 - v105 = get_local __ptr b256, asset_id_, !1896 - v106 = get_local __ptr b256, __anon_10, !1849 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !1849 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !1897 - v111 = asm() -> ptr ret, !1898 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1899 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1900 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val10 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !1901 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !1902 - store v111 to v127, !1903 - v128 = get_local __ptr { ptr }, buffer, !1904 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1905 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1906 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val11 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !1907 - v143 = call read_72(v142), !1908 - v144 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v145 = call new_21(v144) - v146 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v146, v144 - v147 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v148 = const u64 103, !1814 - v149 = call abi_encode_20(v148, v146, v147) - v150 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1909 - mem_copy_val v150, v147 - v151 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1910 - v152 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v152, v151 - v153 = get_local __ptr slice, __ret_val12 - v154 = call as_raw_slice_22(v152, v153) - v155 = get_local __ptr slice, __log_arg2 - mem_copy_val v155, v153 - v156 = const u64 1515152261580153489 - log __ptr slice v155, v156 - v157 = const unit () - ret () v157 - } - - entry fn cost_of_in_u16() -> (), !1914 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64 } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local slice __ret_val14 - local slice __ret_val15 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { b256, u64, u64 } __tmp_arg10 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { { ptr, u64, u64 } } __tmp_arg8 - local slice __tmp_arg9 - local { u64 } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { u64 } item_ - local slice method_name_ - local slice params - local slice second_parameter - local { u64 } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1915 - v2 = get_global __ptr string<6>, __const_global30 - v3 = cast_ptr v2 to ptr, !1916 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !1916 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !1916 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 6 - store v9 to v8, !1916 - v10 = get_local __ptr slice, __anon_1, !1916 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64 }, __anon_2 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !1917 - store v14 to v13 - v15 = get_local __ptr b256, contract_id_, !1918 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !1918 - mem_copy_val v16, v10 - v17 = get_local __ptr { u64 }, args_, !1918 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, asset_id_, !1918 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !1919 - v20 = get_local __ptr slice, __tmp_arg9 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val14 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !1920 - mem_copy_val v23, v21 - v24 = get_local __ptr { u64 }, args_, !1921 - v25 = get_local __ptr { u64 }, item_, !1922 - mem_copy_val v25, v24 - v26 = get_local __ptr { u64 }, item_, !1923 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { u64 }, self_, !1924 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1925 - mem_copy_val v30, v27 - v31 = get_local __ptr { u64 }, self_, !1926 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr u64, v32, !1927 - v34 = load v33, !1928 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1929 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 - mem_copy_val v36, v35 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v38 = call abi_encode_181(v34, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1930 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !1931 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1932 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !1933 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val8 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !1934 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !1935 - v48 = get_local __ptr slice, first_parameter, !1936 - v49 = get_local __ptr slice, self_0, !1937 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !1938 - v51 = get_local __ptr slice, slice_, !1939 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !1940 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !1937 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !1941 - v58 = load v57, !1937 - v59 = asm(a: v58) -> u64 a, !1942 { - } - v60 = get_local __ptr slice, second_parameter, !1943 - v61 = get_local __ptr slice, self_1, !1944 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !1945 - v63 = get_local __ptr slice, slice_0, !1946 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !1947 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !1944 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !1948 - v69 = load v68, !1944 - v70 = asm(a: v69) -> u64 a, !1949 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !1950 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !1951 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !1952 - store v59 to v75, !1953 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !1954 - store v70 to v77, !1955 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val15 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !1956 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1957 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !1958 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val9 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !1959 - v96 = get_local __ptr slice, self_2, !1960 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !1961 - v98 = get_local __ptr slice, slice_1, !1962 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !1963 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !1960 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !1964 - v104 = load v103, !1960 - v105 = get_local __ptr b256, asset_id_, !1965 - v106 = get_local __ptr b256, __anon_10, !1918 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !1918 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !1966 - v111 = asm() -> ptr ret, !1967 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1968 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !1969 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val10 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !1970 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !1971 - store v111 to v127, !1972 - v128 = get_local __ptr { ptr }, buffer, !1973 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1974 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !1975 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val11 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !1976 - v143 = call read_72(v142), !1977 - v144 = call read_72(v142), !1978 - v145 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v146 = call new_21(v145) - v147 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v147, v145 - v148 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v149 = const u64 103, !1814 - v150 = call abi_encode_20(v149, v147, v148) - v151 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1979 - mem_copy_val v151, v148 - v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !1980 - v153 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v153, v152 - v154 = get_local __ptr slice, __ret_val12 - v155 = call as_raw_slice_22(v153, v154) - v156 = get_local __ptr slice, __log_arg2 - mem_copy_val v156, v154 - v157 = const u64 1515152261580153489 - log __ptr slice v156, v157 - v158 = const unit () - ret () v158 - } - - entry fn cost_of_in_u32() -> (), !1984 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64 } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local slice __ret_val14 - local slice __ret_val15 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { b256, u64, u64 } __tmp_arg10 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { { ptr, u64, u64 } } __tmp_arg8 - local slice __tmp_arg9 - local { u64 } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { u64 } item_ - local slice method_name_ - local slice params - local slice second_parameter - local { u64 } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !1985 - v2 = get_global __ptr string<6>, __const_global31 - v3 = cast_ptr v2 to ptr, !1986 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !1986 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !1986 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 6 - store v9 to v8, !1986 - v10 = get_local __ptr slice, __anon_1, !1986 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64 }, __anon_2 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !1987 - store v14 to v13 - v15 = get_local __ptr b256, contract_id_, !1988 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !1988 - mem_copy_val v16, v10 - v17 = get_local __ptr { u64 }, args_, !1988 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, asset_id_, !1988 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !1989 - v20 = get_local __ptr slice, __tmp_arg9 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val14 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !1990 - mem_copy_val v23, v21 - v24 = get_local __ptr { u64 }, args_, !1991 - v25 = get_local __ptr { u64 }, item_, !1992 - mem_copy_val v25, v24 - v26 = get_local __ptr { u64 }, item_, !1993 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { u64 }, self_, !1994 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1995 - mem_copy_val v30, v27 - v31 = get_local __ptr { u64 }, self_, !1996 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr u64, v32, !1997 - v34 = load v33, !1998 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !1999 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg8 - mem_copy_val v36, v35 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v38 = call abi_encode_198(v34, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2000 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2001 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2002 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2003 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val8 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !2004 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !2005 - v48 = get_local __ptr slice, first_parameter, !2006 - v49 = get_local __ptr slice, self_0, !2007 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !2008 - v51 = get_local __ptr slice, slice_, !2009 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !2010 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !2007 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !2011 - v58 = load v57, !2007 - v59 = asm(a: v58) -> u64 a, !2012 { - } - v60 = get_local __ptr slice, second_parameter, !2013 - v61 = get_local __ptr slice, self_1, !2014 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !2015 - v63 = get_local __ptr slice, slice_0, !2016 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !2017 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !2014 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !2018 - v69 = load v68, !2014 - v70 = asm(a: v69) -> u64 a, !2019 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2020 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !2021 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !2022 - store v59 to v75, !2023 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !2024 - store v70 to v77, !2025 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg10 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val15 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !2026 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2027 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2028 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val9 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !2029 - v96 = get_local __ptr slice, self_2, !2030 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !2031 - v98 = get_local __ptr slice, slice_1, !2032 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !2033 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !2030 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !2034 - v104 = load v103, !2030 - v105 = get_local __ptr b256, asset_id_, !2035 - v106 = get_local __ptr b256, __anon_10, !1988 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !1988 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !2036 - v111 = asm() -> ptr ret, !2037 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2038 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2039 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val10 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !2040 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !2041 - store v111 to v127, !2042 - v128 = get_local __ptr { ptr }, buffer, !2043 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2044 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2045 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val11 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !2046 - v143 = call abi_decode_191(v142), !2047 - v144 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v145 = call new_21(v144) - v146 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v146, v144 - v147 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v148 = const u64 103, !1814 - v149 = call abi_encode_20(v148, v146, v147) - v150 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2048 - mem_copy_val v150, v147 - v151 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2049 - v152 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v152, v151 - v153 = get_local __ptr slice, __ret_val12 - v154 = call as_raw_slice_22(v152, v153) - v155 = get_local __ptr slice, __log_arg2 - mem_copy_val v155, v153 - v156 = const u64 1515152261580153489 - log __ptr slice v155, v156 - v157 = const unit () - ret () v157 - } - - entry fn cost_of_in_u64() -> (), !2053 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64 } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { { ptr, u64, u64 } } __ret_val13 - local slice __ret_val14 - local slice __ret_val15 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { u64 } __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { u64 } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local b256 contract_id_ - local slice first_parameter - local { u64 } item_ - local slice method_name_ - local slice params - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2054 - v2 = get_global __ptr string<6>, __const_global32 - v3 = cast_ptr v2 to ptr, !2055 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !2055 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !2055 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 6 - store v9 to v8, !2055 - v10 = get_local __ptr slice, __anon_1, !2055 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64 }, __anon_2 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !2056 - store v14 to v13 - v15 = get_local __ptr b256, contract_id_, !2057 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !2057 - mem_copy_val v16, v10 - v17 = get_local __ptr { u64 }, args_, !2057 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, asset_id_, !2057 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !2058 - v20 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val14 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !2059 - mem_copy_val v23, v21 - v24 = get_local __ptr { u64 }, args_, !2060 - v25 = get_local __ptr { u64 }, item_, !2061 - mem_copy_val v25, v24 - v26 = get_local __ptr { u64 }, item_, !2062 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { u64 }, __tmp_arg8 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, __ret_val13 - v32 = call abi_encode_131(v29, v30, v31) - v33 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2063 - mem_copy_val v33, v31 - v34 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2064 - v35 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v35, v34 - v36 = get_local __ptr slice, __ret_val8 - v37 = call as_raw_slice_22(v35, v36) - v38 = get_local __ptr slice, second_parameter, !2065 - mem_copy_val v38, v36 - v39 = get_local __ptr b256, contract_id_, !2066 - v40 = get_local __ptr slice, first_parameter, !2067 - v41 = get_local __ptr slice, self_, !2068 - mem_copy_val v41, v40 - v42 = get_local __ptr slice, self_, !2069 - v43 = get_local __ptr slice, slice_, !2070 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, slice_, !2071 - v45 = asm(ptr: v44) -> __ptr { ptr, u64 } ptr { - } - v46 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v46, v45 - v47 = get_local __ptr { ptr, u64 }, __anon_01, !2068 - mem_copy_val v47, v46 - v48 = const u64 0 - v49 = get_elem_ptr v47, __ptr ptr, v48, !2072 - v50 = load v49, !2068 - v51 = asm(a: v50) -> u64 a, !2073 { - } - v52 = get_local __ptr slice, second_parameter, !2074 - v53 = get_local __ptr slice, self_0, !2075 - mem_copy_val v53, v52 - v54 = get_local __ptr slice, self_0, !2076 - v55 = get_local __ptr slice, slice_0, !2077 - mem_copy_val v55, v54 - v56 = get_local __ptr slice, slice_0, !2078 - v57 = asm(ptr: v56) -> __ptr { ptr, u64 } ptr { - } - v58 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v58, v57 - v59 = get_local __ptr { ptr, u64 }, __anon_02, !2075 - mem_copy_val v59, v58 - v60 = get_elem_ptr v59, __ptr ptr, v48, !2079 - v61 = load v60, !2075 - v62 = asm(a: v61) -> u64 a, !2080 { - } - v63 = get_local __ptr { b256, u64, u64 }, __anon_00, !2081 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr b256, v64, !2082 - mem_copy_val v65, v39 - v66 = const u64 1 - v67 = get_elem_ptr v63, __ptr u64, v66, !2083 - store v51 to v67, !2084 - v68 = const u64 2 - v69 = get_elem_ptr v63, __ptr u64, v68, !2085 - store v62 to v69, !2086 - v70 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v70, v63 - v71 = get_local __ptr slice, __ret_val15 - v72 = call encode_212(v70, v71) - v73 = get_local __ptr slice, params, !2087 - mem_copy_val v73, v71 - v74 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v75 = call new_21(v74) - v76 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v76, v74 - v77 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v78 = const u64 100, !1772 - v79 = call abi_encode_20(v78, v76, v77) - v80 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2088 - mem_copy_val v80, v77 - v81 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2089 - v82 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v82, v81 - v83 = get_local __ptr slice, __ret_val9 - v84 = call as_raw_slice_22(v82, v83) - v85 = get_local __ptr slice, __log_arg - mem_copy_val v85, v83 - v86 = const u64 1515152261580153489 - log __ptr slice v85, v86 - v87 = get_local __ptr slice, params, !2090 - v88 = get_local __ptr slice, self_1, !2091 - mem_copy_val v88, v87 - v89 = get_local __ptr slice, self_1, !2092 - v90 = get_local __ptr slice, slice_1, !2093 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, slice_1, !2094 - v92 = asm(ptr: v91) -> __ptr { ptr, u64 } ptr { - } - v93 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v93, v92 - v94 = get_local __ptr { ptr, u64 }, __anon_03, !2091 - mem_copy_val v94, v93 - v95 = get_elem_ptr v94, __ptr ptr, v48, !2095 - v96 = load v95, !2091 - v97 = get_local __ptr b256, asset_id_, !2096 - v98 = get_local __ptr b256, __anon_10, !2057 - mem_copy_val v98, v97 - v99 = get_local __ptr b256, __anon_10, !2057 - v100 = const u64 0 - v101 = const u64 18446744073709551615 - v102 = contract_call __ptr () v96, v100, v99, v101, !2097 - v103 = asm() -> ptr ret, !2098 { - } - v104 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v105 = call new_21(v104) - v106 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v106, v104 - v107 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v108 = const u64 101, !1790 - v109 = call abi_encode_20(v108, v106, v107) - v110 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2099 - mem_copy_val v110, v107 - v111 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2100 - v112 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v112, v111 - v113 = get_local __ptr slice, __ret_val10 - v114 = call as_raw_slice_22(v112, v113) - v115 = get_local __ptr slice, __log_arg0 - mem_copy_val v115, v113 - v116 = const u64 1515152261580153489 - log __ptr slice v115, v116 - v117 = get_local __ptr { ptr }, __anon_000, !2101 - v118 = const u64 0 - v119 = get_elem_ptr v117, __ptr ptr, v118, !2102 - store v103 to v119, !2103 - v120 = get_local __ptr { ptr }, buffer, !2104 - mem_copy_val v120, v117 - v121 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v122 = call new_21(v121) - v123 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v123, v121 - v124 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v125 = const u64 102, !1801 - v126 = call abi_encode_20(v125, v123, v124) - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2105 - mem_copy_val v127, v124 - v128 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2106 - v129 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v129, v128 - v130 = get_local __ptr slice, __ret_val11 - v131 = call as_raw_slice_22(v129, v130) - v132 = get_local __ptr slice, __log_arg1 - mem_copy_val v132, v130 - v133 = const u64 1515152261580153489 - log __ptr slice v132, v133 - v134 = get_local __ptr { ptr }, buffer, !2107 - v135 = const u64 0 - v136 = get_elem_ptr v134, __ptr ptr, v135, !2108 - v137 = load v136, !2109 - v138 = asm(ptr: v137, val) -> u64 val, !2110 { - lw val ptr i0, !58 - } - v139 = load v136, !2109 - v140 = const u64 8, !2109 - v141 = add v139, v140, !2109 - store v141 to v136, !2111 - v142 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v143 = call new_21(v142) - v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v144, v142 - v145 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v146 = const u64 103, !1814 - v147 = call abi_encode_20(v146, v144, v145) - v148 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2112 - mem_copy_val v148, v145 - v149 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2113 - v150 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v150, v149 - v151 = get_local __ptr slice, __ret_val12 - v152 = call as_raw_slice_22(v150, v151) - v153 = get_local __ptr slice, __log_arg2 - mem_copy_val v153, v151 - v154 = const u64 1515152261580153489 - log __ptr slice v153, v154 - v155 = const unit () - ret () v155 - } - - entry fn cost_of_in_u256() -> (), !2117 { - local u256 _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u256 } __anon_2 - local u256 __const = const u256 0x0000000000000000000000000000000000000000000000000000000000000000 - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local u256 __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local u256 __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { u256 } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { u256 } item_ - local slice method_name_ - local slice params - local u256 r - local slice second_parameter - local { u256 } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr u256, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2118 - v3 = get_global __ptr string<7>, __const_global33 - v4 = cast_ptr v3 to ptr, !2119 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2119 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2119 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 7 - store v10 to v9, !2119 - v11 = get_local __ptr slice, __anon_1, !2119 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr { u256 }, __anon_2 - v13 = const u64 0 - v14 = get_elem_ptr v12, __ptr u256, v13 - mem_copy_val v14, v0 - v15 = get_local __ptr b256, contract_id_, !2120 - mem_copy_val v15, v2 - v16 = get_local __ptr slice, method_name_, !2120 - mem_copy_val v16, v11 - v17 = get_local __ptr { u256 }, args_, !2120 - mem_copy_val v17, v12 - v18 = get_local __ptr b256, asset_id_, !2120 - mem_copy_val v18, v1 - v19 = get_local __ptr slice, method_name_, !2121 - v20 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val15 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !2122 - mem_copy_val v23, v21 - v24 = get_local __ptr { u256 }, args_, !2123 - v25 = get_local __ptr { u256 }, item_, !2124 - mem_copy_val v25, v24 - v26 = get_local __ptr { u256 }, item_, !2125 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { u256 }, self_, !2126 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2127 - mem_copy_val v30, v27 - v31 = get_local __ptr { u256 }, self_, !2128 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr u256, v32, !2129 - v34 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2130 - v35 = get_local __ptr u256, __tmp_arg8 - mem_copy_val v35, v33 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v38 = call abi_encode_188(v35, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2131 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2132 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2133 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2134 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val8 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !2135 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !2136 - v48 = get_local __ptr slice, first_parameter, !2137 - v49 = get_local __ptr slice, self_0, !2138 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !2139 - v51 = get_local __ptr slice, slice_, !2140 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !2141 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !2138 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !2142 - v58 = load v57, !2138 - v59 = asm(a: v58) -> u64 a, !2143 { - } - v60 = get_local __ptr slice, second_parameter, !2144 - v61 = get_local __ptr slice, self_1, !2145 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !2146 - v63 = get_local __ptr slice, slice_0, !2147 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !2148 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !2145 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !2149 - v69 = load v68, !2145 - v70 = asm(a: v69) -> u64 a, !2150 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2151 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !2152 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !2153 - store v59 to v75, !2154 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !2155 - store v70 to v77, !2156 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val16 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !2157 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2158 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2159 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val9 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !2160 - v96 = get_local __ptr slice, self_2, !2161 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !2162 - v98 = get_local __ptr slice, slice_1, !2163 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !2164 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !2161 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !2165 - v104 = load v103, !2161 - v105 = get_local __ptr b256, asset_id_, !2166 - v106 = get_local __ptr b256, __anon_10, !2120 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !2120 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !2167 - v111 = asm() -> ptr ret, !2168 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2169 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2170 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val10 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !2171 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !2172 - store v111 to v127, !2173 - v128 = get_local __ptr { ptr }, buffer, !2174 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2175 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2176 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val11 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !2177 - v143 = get_local __ptr u256, __ret_val13 - v144 = call abi_decode_184(v142, v143) - v145 = get_local __ptr u256, r, !2179 - mem_copy_val v145, v143 - v146 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v147 = call new_21(v146) - v148 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v148, v146 - v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v150 = const u64 103, !1814 - v151 = call abi_encode_20(v150, v148, v149) - v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2180 - mem_copy_val v152, v149 - v153 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2181 - v154 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v154, v153 - v155 = get_local __ptr slice, __ret_val12 - v156 = call as_raw_slice_22(v154, v155) - v157 = get_local __ptr slice, __log_arg2 - mem_copy_val v157, v155 - v158 = const u64 1515152261580153489 - log __ptr slice v157, v158 - v159 = get_local __ptr u256, r, !2183 - v160 = get_local __ptr u256, _, !2184 - mem_copy_val v160, v159 - v161 = const unit () - ret () v161 - } - - entry fn cost_of_in_b256() -> (), !2188 { - local b256 _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { b256 } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local b256 __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local b256 __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { b256 } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { b256 } item_ - local slice method_name_ - local slice params - local b256 r - local slice second_parameter - local { b256 } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2189 - v3 = get_global __ptr string<7>, __const_global34 - v4 = cast_ptr v3 to ptr, !2190 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2190 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2190 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 7 - store v10 to v9, !2190 - v11 = get_local __ptr slice, __anon_1, !2190 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr { b256 }, __anon_2 - v13 = const u64 0 - v14 = get_elem_ptr v12, __ptr b256, v13 - mem_copy_val v14, v0 - v15 = get_local __ptr b256, contract_id_, !2191 - mem_copy_val v15, v2 - v16 = get_local __ptr slice, method_name_, !2191 - mem_copy_val v16, v11 - v17 = get_local __ptr { b256 }, args_, !2191 - mem_copy_val v17, v12 - v18 = get_local __ptr b256, asset_id_, !2191 - mem_copy_val v18, v1 - v19 = get_local __ptr slice, method_name_, !2192 - v20 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val15 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !2193 - mem_copy_val v23, v21 - v24 = get_local __ptr { b256 }, args_, !2194 - v25 = get_local __ptr { b256 }, item_, !2195 - mem_copy_val v25, v24 - v26 = get_local __ptr { b256 }, item_, !2196 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { b256 }, self_, !2197 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2198 - mem_copy_val v30, v27 - v31 = get_local __ptr { b256 }, self_, !2199 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr b256, v32, !2200 - v34 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2201 - v35 = get_local __ptr b256, __tmp_arg8 - mem_copy_val v35, v33 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v38 = call abi_encode_68(v35, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2202 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2203 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2204 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2205 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val8 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !2206 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !2207 - v48 = get_local __ptr slice, first_parameter, !2208 - v49 = get_local __ptr slice, self_0, !2209 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !2210 - v51 = get_local __ptr slice, slice_, !2211 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !2212 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !2209 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !2213 - v58 = load v57, !2209 - v59 = asm(a: v58) -> u64 a, !2214 { - } - v60 = get_local __ptr slice, second_parameter, !2215 - v61 = get_local __ptr slice, self_1, !2216 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !2217 - v63 = get_local __ptr slice, slice_0, !2218 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !2219 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !2216 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !2220 - v69 = load v68, !2216 - v70 = asm(a: v69) -> u64 a, !2221 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2222 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !2223 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !2224 - store v59 to v75, !2225 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !2226 - store v70 to v77, !2227 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val16 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !2228 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2229 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2230 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val9 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !2231 - v96 = get_local __ptr slice, self_2, !2232 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !2233 - v98 = get_local __ptr slice, slice_1, !2234 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !2235 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !2232 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !2236 - v104 = load v103, !2232 - v105 = get_local __ptr b256, asset_id_, !2237 - v106 = get_local __ptr b256, __anon_10, !2191 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !2191 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !2238 - v111 = asm() -> ptr ret, !2239 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2240 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2241 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val10 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !2242 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !2243 - store v111 to v127, !2244 - v128 = get_local __ptr { ptr }, buffer, !2245 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2246 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2247 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val11 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !2248 - v143 = get_local __ptr b256, __ret_val13 - v144 = call abi_decode_64(v142, v143) - v145 = get_local __ptr b256, r, !2249 - mem_copy_val v145, v143 - v146 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v147 = call new_21(v146) - v148 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v148, v146 - v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v150 = const u64 103, !1814 - v151 = call abi_encode_20(v150, v148, v149) - v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2250 - mem_copy_val v152, v149 - v153 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2251 - v154 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v154, v153 - v155 = get_local __ptr slice, __ret_val12 - v156 = call as_raw_slice_22(v154, v155) - v157 = get_local __ptr slice, __log_arg2 - mem_copy_val v157, v155 - v158 = const u64 1515152261580153489 - log __ptr slice v157, v158 - v159 = get_local __ptr b256, r, !2252 - v160 = get_local __ptr b256, _, !2253 - mem_copy_val v160, v159 - v161 = const unit () - ret () v161 - } - - entry fn cost_of_in_str_0() -> (), !2257 { - local string<0> _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut string<0> __aggr_memcpy_03 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local { ptr, u64 } __anon_04 - local slice __anon_1 - local b256 __anon_10 - local string<0> __anon_2 - local { string<0> } __anon_3 - local string<0> __const = const string<0> "" - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local slice __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local string<0> __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { string<0> } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice data - local slice first_parameter - local { string<0> } item_ - local slice method_name_ - local slice params - local string<0> r - local slice second_parameter - local { string<0> } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice self_3 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_2 - - entry(): - v0 = get_local __ptr string<0>, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2258 - v3 = get_global __ptr string<8>, __const_global35 - v4 = cast_ptr v3 to ptr, !2259 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2259 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2259 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 8 - store v10 to v9, !2259 - v11 = get_local __ptr slice, __anon_1, !2259 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr string<0>, __anon_2 - mem_copy_val v12, v0 - v13 = get_local __ptr { string<0> }, __anon_3 - v14 = const u64 0 - v15 = get_elem_ptr v13, __ptr string<0>, v14 - mem_copy_val v15, v12 - v16 = get_local __ptr b256, contract_id_, !2260 - mem_copy_val v16, v2 - v17 = get_local __ptr slice, method_name_, !2260 - mem_copy_val v17, v11 - v18 = get_local __ptr { string<0> }, args_, !2260 - mem_copy_val v18, v13 - v19 = get_local __ptr b256, asset_id_, !2260 - mem_copy_val v19, v1 - v20 = get_local __ptr slice, method_name_, !2261 - v21 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v21, v20 - v22 = get_local __ptr slice, __ret_val15 - v23 = call encode_208(v21, v22) - v24 = get_local __ptr slice, first_parameter, !2262 - mem_copy_val v24, v22 - v25 = get_local __ptr { string<0> }, args_, !2263 - v26 = get_local __ptr { string<0> }, item_, !2264 - mem_copy_val v26, v25 - v27 = get_local __ptr { string<0> }, item_, !2265 - v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v29 = call new_21(v28) - v30 = get_local __ptr { string<0> }, self_, !2266 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2267 - mem_copy_val v31, v28 - v32 = get_local __ptr { string<0> }, self_, !2268 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr string<0>, v33, !2269 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2270 - v36 = get_local __ptr string<0>, __tmp_arg8 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v37, v35 - v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v39 = call abi_encode_101(v36, v37, v38) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2271 - mem_copy_val v40, v38 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2272 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2273 - mem_copy_val v42, v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2274 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v44, v43 - v45 = get_local __ptr slice, __ret_val9 - v46 = call as_raw_slice_22(v44, v45) - v47 = get_local __ptr slice, second_parameter, !2275 - mem_copy_val v47, v45 - v48 = get_local __ptr b256, contract_id_, !2276 - v49 = get_local __ptr slice, first_parameter, !2277 - v50 = get_local __ptr slice, self_0, !2278 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, self_0, !2279 - v52 = get_local __ptr slice, slice_, !2280 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, slice_, !2281 - v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { - } - v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v55, v54 - v56 = get_local __ptr { ptr, u64 }, __anon_01, !2278 - mem_copy_val v56, v55 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr ptr, v57, !2282 - v59 = load v58, !2278 - v60 = asm(a: v59) -> u64 a, !2283 { - } - v61 = get_local __ptr slice, second_parameter, !2284 - v62 = get_local __ptr slice, self_1, !2285 - mem_copy_val v62, v61 - v63 = get_local __ptr slice, self_1, !2286 - v64 = get_local __ptr slice, slice_0, !2287 - mem_copy_val v64, v63 - v65 = get_local __ptr slice, slice_0, !2288 - v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { - } - v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v67, v66 - v68 = get_local __ptr { ptr, u64 }, __anon_02, !2285 - mem_copy_val v68, v67 - v69 = get_elem_ptr v68, __ptr ptr, v57, !2289 - v70 = load v69, !2285 - v71 = asm(a: v70) -> u64 a, !2290 { - } - v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2291 - v73 = const u64 0 - v74 = get_elem_ptr v72, __ptr b256, v73, !2292 - mem_copy_val v74, v48 - v75 = const u64 1 - v76 = get_elem_ptr v72, __ptr u64, v75, !2293 - store v60 to v76, !2294 - v77 = const u64 2 - v78 = get_elem_ptr v72, __ptr u64, v77, !2295 - store v71 to v78, !2296 - v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v79, v72 - v80 = get_local __ptr slice, __ret_val16 - v81 = call encode_212(v79, v80) - v82 = get_local __ptr slice, params, !2297 - mem_copy_val v82, v80 - v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v84 = call new_21(v83) - v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v85, v83 - v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v87 = const u64 100, !1772 - v88 = call abi_encode_20(v87, v85, v86) - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2298 - mem_copy_val v89, v86 - v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2299 - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, __ret_val10 - v93 = call as_raw_slice_22(v91, v92) - v94 = get_local __ptr slice, __log_arg - mem_copy_val v94, v92 - v95 = const u64 1515152261580153489 - log __ptr slice v94, v95 - v96 = get_local __ptr slice, params, !2300 - v97 = get_local __ptr slice, self_2, !2301 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, self_2, !2302 - v99 = get_local __ptr slice, slice_1, !2303 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, slice_1, !2304 - v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { - } - v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v102, v101 - v103 = get_local __ptr { ptr, u64 }, __anon_03, !2301 - mem_copy_val v103, v102 - v104 = get_elem_ptr v103, __ptr ptr, v57, !2305 - v105 = load v104, !2301 - v106 = get_local __ptr b256, asset_id_, !2306 - v107 = get_local __ptr b256, __anon_10, !2260 - mem_copy_val v107, v106 - v108 = get_local __ptr b256, __anon_10, !2260 - v109 = const u64 0 - v110 = const u64 18446744073709551615 - v111 = contract_call __ptr () v105, v109, v108, v110, !2307 - v112 = asm() -> ptr ret, !2308 { - } - v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v114 = call new_21(v113) - v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v115, v113 - v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v117 = const u64 101, !1790 - v118 = call abi_encode_20(v117, v115, v116) - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2309 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2310 - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v121, v120 - v122 = get_local __ptr slice, __ret_val11 - v123 = call as_raw_slice_22(v121, v122) - v124 = get_local __ptr slice, __log_arg0 - mem_copy_val v124, v122 - v125 = const u64 1515152261580153489 - log __ptr slice v124, v125 - v126 = get_local __ptr { ptr }, __anon_000, !2311 - v127 = const u64 0 - v128 = get_elem_ptr v126, __ptr ptr, v127, !2312 - store v112 to v128, !2313 - v129 = get_local __ptr { ptr }, buffer, !2314 - mem_copy_val v129, v126 - v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v131 = call new_21(v130) - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v132, v130 - v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v134 = const u64 102, !1801 - v135 = call abi_encode_20(v134, v132, v133) - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2315 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2316 - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v138, v137 - v139 = get_local __ptr slice, __ret_val12 - v140 = call as_raw_slice_22(v138, v139) - v141 = get_local __ptr slice, __log_arg1 - mem_copy_val v141, v139 - v142 = const u64 1515152261580153489 - log __ptr slice v141, v142 - v143 = get_local __ptr { ptr }, buffer, !2317 - v144 = get_local __ptr slice, __ret_val - v145 = const u64 0 - v146 = call read_bytes_8(v143, v145, v144) - v147 = get_local __ptr slice, data, !2318 - mem_copy_val v147, v144 - v148 = get_local __ptr slice, data, !2319 - v149 = get_local __ptr slice, self_3, !2320 - mem_copy_val v149, v148 - v150 = get_local __ptr slice, self_3, !2321 - v151 = get_local __ptr slice, slice_2, !2322 - mem_copy_val v151, v150 - v152 = get_local __ptr slice, slice_2, !2323 - v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { - } - v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v154, v153 - v155 = get_local __ptr { ptr, u64 }, __anon_04, !2320 - mem_copy_val v155, v154 - v156 = get_elem_ptr v155, __ptr ptr, v57, !2324 - v157 = load v156, !2320 - v158 = asm(s: v157) -> __ptr string<0> s { - } - v159 = get_local __ptr string<0>, __aggr_memcpy_03 - mem_copy_val v159, v158 - v160 = get_local __ptr string<0>, r, !2325 - mem_copy_val v160, v159 - v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v162 = call new_21(v161) - v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v163, v161 - v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v165 = const u64 103, !1814 - v166 = call abi_encode_20(v165, v163, v164) - v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2326 - mem_copy_val v167, v164 - v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2327 - v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v169, v168 - v170 = get_local __ptr slice, __ret_val13 - v171 = call as_raw_slice_22(v169, v170) - v172 = get_local __ptr slice, __log_arg2 - mem_copy_val v172, v170 - v173 = const u64 1515152261580153489 - log __ptr slice v172, v173 - v174 = get_local __ptr string<0>, r, !2328 - v175 = get_local __ptr string<0>, _, !2329 - mem_copy_val v175, v174 - v176 = const unit () - ret () v176 - } - - entry fn cost_of_in_str_1() -> (), !2333 { - local string<1> _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut string<1> __aggr_memcpy_03 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local { ptr, u64 } __anon_04 - local slice __anon_1 - local b256 __anon_10 - local string<1> __anon_2 - local { string<1> } __anon_3 - local string<1> __const = const string<1> "1" - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local slice __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local string<1> __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { string<1> } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice data - local slice first_parameter - local { string<1> } item_ - local slice method_name_ - local slice params - local string<1> r - local slice second_parameter - local { string<1> } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice self_3 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_2 - - entry(): - v0 = get_local __ptr string<1>, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2334 - v3 = get_global __ptr string<8>, __const_global36 - v4 = cast_ptr v3 to ptr, !2335 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2335 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2335 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 8 - store v10 to v9, !2335 - v11 = get_local __ptr slice, __anon_1, !2335 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr string<1>, __anon_2 - mem_copy_val v12, v0 - v13 = get_local __ptr { string<1> }, __anon_3 - v14 = const u64 0 - v15 = get_elem_ptr v13, __ptr string<1>, v14 - mem_copy_val v15, v12 - v16 = get_local __ptr b256, contract_id_, !2336 - mem_copy_val v16, v2 - v17 = get_local __ptr slice, method_name_, !2336 - mem_copy_val v17, v11 - v18 = get_local __ptr { string<1> }, args_, !2336 - mem_copy_val v18, v13 - v19 = get_local __ptr b256, asset_id_, !2336 - mem_copy_val v19, v1 - v20 = get_local __ptr slice, method_name_, !2337 - v21 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v21, v20 - v22 = get_local __ptr slice, __ret_val15 - v23 = call encode_208(v21, v22) - v24 = get_local __ptr slice, first_parameter, !2338 - mem_copy_val v24, v22 - v25 = get_local __ptr { string<1> }, args_, !2339 - v26 = get_local __ptr { string<1> }, item_, !2340 - mem_copy_val v26, v25 - v27 = get_local __ptr { string<1> }, item_, !2341 - v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v29 = call new_21(v28) - v30 = get_local __ptr { string<1> }, self_, !2342 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2343 - mem_copy_val v31, v28 - v32 = get_local __ptr { string<1> }, self_, !2344 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr string<1>, v33, !2345 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2346 - v36 = get_local __ptr string<1>, __tmp_arg8 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v37, v35 - v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v39 = call abi_encode_107(v36, v37, v38) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2347 - mem_copy_val v40, v38 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2348 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2349 - mem_copy_val v42, v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2350 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v44, v43 - v45 = get_local __ptr slice, __ret_val9 - v46 = call as_raw_slice_22(v44, v45) - v47 = get_local __ptr slice, second_parameter, !2351 - mem_copy_val v47, v45 - v48 = get_local __ptr b256, contract_id_, !2352 - v49 = get_local __ptr slice, first_parameter, !2353 - v50 = get_local __ptr slice, self_0, !2354 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, self_0, !2355 - v52 = get_local __ptr slice, slice_, !2356 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, slice_, !2357 - v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { - } - v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v55, v54 - v56 = get_local __ptr { ptr, u64 }, __anon_01, !2354 - mem_copy_val v56, v55 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr ptr, v57, !2358 - v59 = load v58, !2354 - v60 = asm(a: v59) -> u64 a, !2359 { - } - v61 = get_local __ptr slice, second_parameter, !2360 - v62 = get_local __ptr slice, self_1, !2361 - mem_copy_val v62, v61 - v63 = get_local __ptr slice, self_1, !2362 - v64 = get_local __ptr slice, slice_0, !2363 - mem_copy_val v64, v63 - v65 = get_local __ptr slice, slice_0, !2364 - v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { - } - v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v67, v66 - v68 = get_local __ptr { ptr, u64 }, __anon_02, !2361 - mem_copy_val v68, v67 - v69 = get_elem_ptr v68, __ptr ptr, v57, !2365 - v70 = load v69, !2361 - v71 = asm(a: v70) -> u64 a, !2366 { - } - v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2367 - v73 = const u64 0 - v74 = get_elem_ptr v72, __ptr b256, v73, !2368 - mem_copy_val v74, v48 - v75 = const u64 1 - v76 = get_elem_ptr v72, __ptr u64, v75, !2369 - store v60 to v76, !2370 - v77 = const u64 2 - v78 = get_elem_ptr v72, __ptr u64, v77, !2371 - store v71 to v78, !2372 - v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v79, v72 - v80 = get_local __ptr slice, __ret_val16 - v81 = call encode_212(v79, v80) - v82 = get_local __ptr slice, params, !2373 - mem_copy_val v82, v80 - v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v84 = call new_21(v83) - v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v85, v83 - v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v87 = const u64 100, !1772 - v88 = call abi_encode_20(v87, v85, v86) - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2374 - mem_copy_val v89, v86 - v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2375 - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, __ret_val10 - v93 = call as_raw_slice_22(v91, v92) - v94 = get_local __ptr slice, __log_arg - mem_copy_val v94, v92 - v95 = const u64 1515152261580153489 - log __ptr slice v94, v95 - v96 = get_local __ptr slice, params, !2376 - v97 = get_local __ptr slice, self_2, !2377 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, self_2, !2378 - v99 = get_local __ptr slice, slice_1, !2379 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, slice_1, !2380 - v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { - } - v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v102, v101 - v103 = get_local __ptr { ptr, u64 }, __anon_03, !2377 - mem_copy_val v103, v102 - v104 = get_elem_ptr v103, __ptr ptr, v57, !2381 - v105 = load v104, !2377 - v106 = get_local __ptr b256, asset_id_, !2382 - v107 = get_local __ptr b256, __anon_10, !2336 - mem_copy_val v107, v106 - v108 = get_local __ptr b256, __anon_10, !2336 - v109 = const u64 0 - v110 = const u64 18446744073709551615 - v111 = contract_call __ptr () v105, v109, v108, v110, !2383 - v112 = asm() -> ptr ret, !2384 { - } - v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v114 = call new_21(v113) - v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v115, v113 - v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v117 = const u64 101, !1790 - v118 = call abi_encode_20(v117, v115, v116) - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2385 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2386 - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v121, v120 - v122 = get_local __ptr slice, __ret_val11 - v123 = call as_raw_slice_22(v121, v122) - v124 = get_local __ptr slice, __log_arg0 - mem_copy_val v124, v122 - v125 = const u64 1515152261580153489 - log __ptr slice v124, v125 - v126 = get_local __ptr { ptr }, __anon_000, !2387 - v127 = const u64 0 - v128 = get_elem_ptr v126, __ptr ptr, v127, !2388 - store v112 to v128, !2389 - v129 = get_local __ptr { ptr }, buffer, !2390 - mem_copy_val v129, v126 - v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v131 = call new_21(v130) - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v132, v130 - v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v134 = const u64 102, !1801 - v135 = call abi_encode_20(v134, v132, v133) - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2391 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2392 - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v138, v137 - v139 = get_local __ptr slice, __ret_val12 - v140 = call as_raw_slice_22(v138, v139) - v141 = get_local __ptr slice, __log_arg1 - mem_copy_val v141, v139 - v142 = const u64 1515152261580153489 - log __ptr slice v141, v142 - v143 = get_local __ptr { ptr }, buffer, !2393 - v144 = get_local __ptr slice, __ret_val - v145 = const u64 1 - v146 = call read_bytes_8(v143, v145, v144) - v147 = get_local __ptr slice, data, !2394 - mem_copy_val v147, v144 - v148 = get_local __ptr slice, data, !2395 - v149 = get_local __ptr slice, self_3, !2396 - mem_copy_val v149, v148 - v150 = get_local __ptr slice, self_3, !2397 - v151 = get_local __ptr slice, slice_2, !2398 - mem_copy_val v151, v150 - v152 = get_local __ptr slice, slice_2, !2399 - v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { - } - v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v154, v153 - v155 = get_local __ptr { ptr, u64 }, __anon_04, !2396 - mem_copy_val v155, v154 - v156 = get_elem_ptr v155, __ptr ptr, v57, !2400 - v157 = load v156, !2396 - v158 = asm(s: v157) -> __ptr string<1> s { - } - v159 = get_local __ptr string<1>, __aggr_memcpy_03 - mem_copy_val v159, v158 - v160 = get_local __ptr string<1>, r, !2401 - mem_copy_val v160, v159 - v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v162 = call new_21(v161) - v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v163, v161 - v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v165 = const u64 103, !1814 - v166 = call abi_encode_20(v165, v163, v164) - v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2402 - mem_copy_val v167, v164 - v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2403 - v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v169, v168 - v170 = get_local __ptr slice, __ret_val13 - v171 = call as_raw_slice_22(v169, v170) - v172 = get_local __ptr slice, __log_arg2 - mem_copy_val v172, v170 - v173 = const u64 1515152261580153489 - log __ptr slice v172, v173 - v174 = get_local __ptr string<1>, r, !2404 - v175 = get_local __ptr string<1>, _, !2405 - mem_copy_val v175, v174 - v176 = const unit () - ret () v176 - } - - entry fn cost_of_in_str_8() -> (), !2409 { - local string<8> _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut string<8> __aggr_memcpy_03 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local { ptr, u64 } __anon_04 - local slice __anon_1 - local b256 __anon_10 - local string<8> __anon_2 - local { string<8> } __anon_3 - local string<8> __const = const string<8> "12345678" - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local slice __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local string<8> __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { string<8> } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice data - local slice first_parameter - local { string<8> } item_ - local slice method_name_ - local slice params - local string<8> r - local slice second_parameter - local { string<8> } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice self_3 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_2 - - entry(): - v0 = get_local __ptr string<8>, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2410 - v3 = get_global __ptr string<8>, __const_global37 - v4 = cast_ptr v3 to ptr, !2411 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2411 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2411 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 8 - store v10 to v9, !2411 - v11 = get_local __ptr slice, __anon_1, !2411 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr string<8>, __anon_2 - mem_copy_val v12, v0 - v13 = get_local __ptr { string<8> }, __anon_3 - v14 = const u64 0 - v15 = get_elem_ptr v13, __ptr string<8>, v14 - mem_copy_val v15, v12 - v16 = get_local __ptr b256, contract_id_, !2412 - mem_copy_val v16, v2 - v17 = get_local __ptr slice, method_name_, !2412 - mem_copy_val v17, v11 - v18 = get_local __ptr { string<8> }, args_, !2412 - mem_copy_val v18, v13 - v19 = get_local __ptr b256, asset_id_, !2412 - mem_copy_val v19, v1 - v20 = get_local __ptr slice, method_name_, !2413 - v21 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v21, v20 - v22 = get_local __ptr slice, __ret_val15 - v23 = call encode_208(v21, v22) - v24 = get_local __ptr slice, first_parameter, !2414 - mem_copy_val v24, v22 - v25 = get_local __ptr { string<8> }, args_, !2415 - v26 = get_local __ptr { string<8> }, item_, !2416 - mem_copy_val v26, v25 - v27 = get_local __ptr { string<8> }, item_, !2417 - v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v29 = call new_21(v28) - v30 = get_local __ptr { string<8> }, self_, !2418 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2419 - mem_copy_val v31, v28 - v32 = get_local __ptr { string<8> }, self_, !2420 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr string<8>, v33, !2421 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2422 - v36 = get_local __ptr string<8>, __tmp_arg8 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v37, v35 - v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v39 = call abi_encode_125(v36, v37, v38) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2423 - mem_copy_val v40, v38 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2424 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2425 - mem_copy_val v42, v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2426 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v44, v43 - v45 = get_local __ptr slice, __ret_val9 - v46 = call as_raw_slice_22(v44, v45) - v47 = get_local __ptr slice, second_parameter, !2427 - mem_copy_val v47, v45 - v48 = get_local __ptr b256, contract_id_, !2428 - v49 = get_local __ptr slice, first_parameter, !2429 - v50 = get_local __ptr slice, self_0, !2430 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, self_0, !2431 - v52 = get_local __ptr slice, slice_, !2432 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, slice_, !2433 - v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { - } - v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v55, v54 - v56 = get_local __ptr { ptr, u64 }, __anon_01, !2430 - mem_copy_val v56, v55 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr ptr, v57, !2434 - v59 = load v58, !2430 - v60 = asm(a: v59) -> u64 a, !2435 { - } - v61 = get_local __ptr slice, second_parameter, !2436 - v62 = get_local __ptr slice, self_1, !2437 - mem_copy_val v62, v61 - v63 = get_local __ptr slice, self_1, !2438 - v64 = get_local __ptr slice, slice_0, !2439 - mem_copy_val v64, v63 - v65 = get_local __ptr slice, slice_0, !2440 - v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { - } - v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v67, v66 - v68 = get_local __ptr { ptr, u64 }, __anon_02, !2437 - mem_copy_val v68, v67 - v69 = get_elem_ptr v68, __ptr ptr, v57, !2441 - v70 = load v69, !2437 - v71 = asm(a: v70) -> u64 a, !2442 { - } - v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2443 - v73 = const u64 0 - v74 = get_elem_ptr v72, __ptr b256, v73, !2444 - mem_copy_val v74, v48 - v75 = const u64 1 - v76 = get_elem_ptr v72, __ptr u64, v75, !2445 - store v60 to v76, !2446 - v77 = const u64 2 - v78 = get_elem_ptr v72, __ptr u64, v77, !2447 - store v71 to v78, !2448 - v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v79, v72 - v80 = get_local __ptr slice, __ret_val16 - v81 = call encode_212(v79, v80) - v82 = get_local __ptr slice, params, !2449 - mem_copy_val v82, v80 - v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v84 = call new_21(v83) - v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v85, v83 - v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v87 = const u64 100, !1772 - v88 = call abi_encode_20(v87, v85, v86) - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2450 - mem_copy_val v89, v86 - v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2451 - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, __ret_val10 - v93 = call as_raw_slice_22(v91, v92) - v94 = get_local __ptr slice, __log_arg - mem_copy_val v94, v92 - v95 = const u64 1515152261580153489 - log __ptr slice v94, v95 - v96 = get_local __ptr slice, params, !2452 - v97 = get_local __ptr slice, self_2, !2453 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, self_2, !2454 - v99 = get_local __ptr slice, slice_1, !2455 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, slice_1, !2456 - v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { - } - v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v102, v101 - v103 = get_local __ptr { ptr, u64 }, __anon_03, !2453 - mem_copy_val v103, v102 - v104 = get_elem_ptr v103, __ptr ptr, v57, !2457 - v105 = load v104, !2453 - v106 = get_local __ptr b256, asset_id_, !2458 - v107 = get_local __ptr b256, __anon_10, !2412 - mem_copy_val v107, v106 - v108 = get_local __ptr b256, __anon_10, !2412 - v109 = const u64 0 - v110 = const u64 18446744073709551615 - v111 = contract_call __ptr () v105, v109, v108, v110, !2459 - v112 = asm() -> ptr ret, !2460 { - } - v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v114 = call new_21(v113) - v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v115, v113 - v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v117 = const u64 101, !1790 - v118 = call abi_encode_20(v117, v115, v116) - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2461 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2462 - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v121, v120 - v122 = get_local __ptr slice, __ret_val11 - v123 = call as_raw_slice_22(v121, v122) - v124 = get_local __ptr slice, __log_arg0 - mem_copy_val v124, v122 - v125 = const u64 1515152261580153489 - log __ptr slice v124, v125 - v126 = get_local __ptr { ptr }, __anon_000, !2463 - v127 = const u64 0 - v128 = get_elem_ptr v126, __ptr ptr, v127, !2464 - store v112 to v128, !2465 - v129 = get_local __ptr { ptr }, buffer, !2466 - mem_copy_val v129, v126 - v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v131 = call new_21(v130) - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v132, v130 - v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v134 = const u64 102, !1801 - v135 = call abi_encode_20(v134, v132, v133) - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2467 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2468 - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v138, v137 - v139 = get_local __ptr slice, __ret_val12 - v140 = call as_raw_slice_22(v138, v139) - v141 = get_local __ptr slice, __log_arg1 - mem_copy_val v141, v139 - v142 = const u64 1515152261580153489 - log __ptr slice v141, v142 - v143 = get_local __ptr { ptr }, buffer, !2469 - v144 = get_local __ptr slice, __ret_val - v145 = const u64 8 - v146 = call read_bytes_8(v143, v145, v144) - v147 = get_local __ptr slice, data, !2470 - mem_copy_val v147, v144 - v148 = get_local __ptr slice, data, !2471 - v149 = get_local __ptr slice, self_3, !2472 - mem_copy_val v149, v148 - v150 = get_local __ptr slice, self_3, !2473 - v151 = get_local __ptr slice, slice_2, !2474 - mem_copy_val v151, v150 - v152 = get_local __ptr slice, slice_2, !2475 - v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { - } - v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v154, v153 - v155 = get_local __ptr { ptr, u64 }, __anon_04, !2472 - mem_copy_val v155, v154 - v156 = get_elem_ptr v155, __ptr ptr, v57, !2476 - v157 = load v156, !2472 - v158 = asm(s: v157) -> __ptr string<8> s { - } - v159 = get_local __ptr string<8>, __aggr_memcpy_03 - mem_copy_val v159, v158 - v160 = get_local __ptr string<8>, r, !2477 - mem_copy_val v160, v159 - v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v162 = call new_21(v161) - v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v163, v161 - v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v165 = const u64 103, !1814 - v166 = call abi_encode_20(v165, v163, v164) - v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2478 - mem_copy_val v167, v164 - v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2479 - v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v169, v168 - v170 = get_local __ptr slice, __ret_val13 - v171 = call as_raw_slice_22(v169, v170) - v172 = get_local __ptr slice, __log_arg2 - mem_copy_val v172, v170 - v173 = const u64 1515152261580153489 - log __ptr slice v172, v173 - v174 = get_local __ptr string<8>, r, !2480 - v175 = get_local __ptr string<8>, _, !2481 - mem_copy_val v175, v174 - v176 = const unit () - ret () v176 - } - - entry fn cost_of_in_str_16() -> (), !2485 { - local string<16> _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut string<16> __aggr_memcpy_03 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local { ptr, u64 } __anon_04 - local slice __anon_1 - local b256 __anon_10 - local string<16> __anon_2 - local { string<16> } __anon_3 - local string<16> __const = const string<16> "1234567890123456" - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local slice __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local string<16> __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { string<16> } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice data - local slice first_parameter - local { string<16> } item_ - local slice method_name_ - local slice params - local string<16> r - local slice second_parameter - local { string<16> } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice self_3 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_2 - - entry(): - v0 = get_local __ptr string<16>, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2486 - v3 = get_global __ptr string<9>, __const_global38 - v4 = cast_ptr v3 to ptr, !2487 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2487 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2487 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 9 - store v10 to v9, !2487 - v11 = get_local __ptr slice, __anon_1, !2487 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr string<16>, __anon_2 - mem_copy_val v12, v0 - v13 = get_local __ptr { string<16> }, __anon_3 - v14 = const u64 0 - v15 = get_elem_ptr v13, __ptr string<16>, v14 - mem_copy_val v15, v12 - v16 = get_local __ptr b256, contract_id_, !2488 - mem_copy_val v16, v2 - v17 = get_local __ptr slice, method_name_, !2488 - mem_copy_val v17, v11 - v18 = get_local __ptr { string<16> }, args_, !2488 - mem_copy_val v18, v13 - v19 = get_local __ptr b256, asset_id_, !2488 - mem_copy_val v19, v1 - v20 = get_local __ptr slice, method_name_, !2489 - v21 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v21, v20 - v22 = get_local __ptr slice, __ret_val15 - v23 = call encode_208(v21, v22) - v24 = get_local __ptr slice, first_parameter, !2490 - mem_copy_val v24, v22 - v25 = get_local __ptr { string<16> }, args_, !2491 - v26 = get_local __ptr { string<16> }, item_, !2492 - mem_copy_val v26, v25 - v27 = get_local __ptr { string<16> }, item_, !2493 - v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v29 = call new_21(v28) - v30 = get_local __ptr { string<16> }, self_, !2494 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2495 - mem_copy_val v31, v28 - v32 = get_local __ptr { string<16> }, self_, !2496 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr string<16>, v33, !2497 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2498 - v36 = get_local __ptr string<16>, __tmp_arg8 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v37, v35 - v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v39 = call abi_encode_113(v36, v37, v38) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2499 - mem_copy_val v40, v38 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2500 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2501 - mem_copy_val v42, v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2502 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v44, v43 - v45 = get_local __ptr slice, __ret_val9 - v46 = call as_raw_slice_22(v44, v45) - v47 = get_local __ptr slice, second_parameter, !2503 - mem_copy_val v47, v45 - v48 = get_local __ptr b256, contract_id_, !2504 - v49 = get_local __ptr slice, first_parameter, !2505 - v50 = get_local __ptr slice, self_0, !2506 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, self_0, !2507 - v52 = get_local __ptr slice, slice_, !2508 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, slice_, !2509 - v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { - } - v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v55, v54 - v56 = get_local __ptr { ptr, u64 }, __anon_01, !2506 - mem_copy_val v56, v55 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr ptr, v57, !2510 - v59 = load v58, !2506 - v60 = asm(a: v59) -> u64 a, !2511 { - } - v61 = get_local __ptr slice, second_parameter, !2512 - v62 = get_local __ptr slice, self_1, !2513 - mem_copy_val v62, v61 - v63 = get_local __ptr slice, self_1, !2514 - v64 = get_local __ptr slice, slice_0, !2515 - mem_copy_val v64, v63 - v65 = get_local __ptr slice, slice_0, !2516 - v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { - } - v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v67, v66 - v68 = get_local __ptr { ptr, u64 }, __anon_02, !2513 - mem_copy_val v68, v67 - v69 = get_elem_ptr v68, __ptr ptr, v57, !2517 - v70 = load v69, !2513 - v71 = asm(a: v70) -> u64 a, !2518 { - } - v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2519 - v73 = const u64 0 - v74 = get_elem_ptr v72, __ptr b256, v73, !2520 - mem_copy_val v74, v48 - v75 = const u64 1 - v76 = get_elem_ptr v72, __ptr u64, v75, !2521 - store v60 to v76, !2522 - v77 = const u64 2 - v78 = get_elem_ptr v72, __ptr u64, v77, !2523 - store v71 to v78, !2524 - v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v79, v72 - v80 = get_local __ptr slice, __ret_val16 - v81 = call encode_212(v79, v80) - v82 = get_local __ptr slice, params, !2525 - mem_copy_val v82, v80 - v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v84 = call new_21(v83) - v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v85, v83 - v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v87 = const u64 100, !1772 - v88 = call abi_encode_20(v87, v85, v86) - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2526 - mem_copy_val v89, v86 - v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2527 - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, __ret_val10 - v93 = call as_raw_slice_22(v91, v92) - v94 = get_local __ptr slice, __log_arg - mem_copy_val v94, v92 - v95 = const u64 1515152261580153489 - log __ptr slice v94, v95 - v96 = get_local __ptr slice, params, !2528 - v97 = get_local __ptr slice, self_2, !2529 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, self_2, !2530 - v99 = get_local __ptr slice, slice_1, !2531 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, slice_1, !2532 - v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { - } - v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v102, v101 - v103 = get_local __ptr { ptr, u64 }, __anon_03, !2529 - mem_copy_val v103, v102 - v104 = get_elem_ptr v103, __ptr ptr, v57, !2533 - v105 = load v104, !2529 - v106 = get_local __ptr b256, asset_id_, !2534 - v107 = get_local __ptr b256, __anon_10, !2488 - mem_copy_val v107, v106 - v108 = get_local __ptr b256, __anon_10, !2488 - v109 = const u64 0 - v110 = const u64 18446744073709551615 - v111 = contract_call __ptr () v105, v109, v108, v110, !2535 - v112 = asm() -> ptr ret, !2536 { - } - v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v114 = call new_21(v113) - v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v115, v113 - v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v117 = const u64 101, !1790 - v118 = call abi_encode_20(v117, v115, v116) - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2537 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2538 - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v121, v120 - v122 = get_local __ptr slice, __ret_val11 - v123 = call as_raw_slice_22(v121, v122) - v124 = get_local __ptr slice, __log_arg0 - mem_copy_val v124, v122 - v125 = const u64 1515152261580153489 - log __ptr slice v124, v125 - v126 = get_local __ptr { ptr }, __anon_000, !2539 - v127 = const u64 0 - v128 = get_elem_ptr v126, __ptr ptr, v127, !2540 - store v112 to v128, !2541 - v129 = get_local __ptr { ptr }, buffer, !2542 - mem_copy_val v129, v126 - v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v131 = call new_21(v130) - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v132, v130 - v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v134 = const u64 102, !1801 - v135 = call abi_encode_20(v134, v132, v133) - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2543 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2544 - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v138, v137 - v139 = get_local __ptr slice, __ret_val12 - v140 = call as_raw_slice_22(v138, v139) - v141 = get_local __ptr slice, __log_arg1 - mem_copy_val v141, v139 - v142 = const u64 1515152261580153489 - log __ptr slice v141, v142 - v143 = get_local __ptr { ptr }, buffer, !2545 - v144 = get_local __ptr slice, __ret_val - v145 = const u64 16 - v146 = call read_bytes_8(v143, v145, v144) - v147 = get_local __ptr slice, data, !2546 - mem_copy_val v147, v144 - v148 = get_local __ptr slice, data, !2547 - v149 = get_local __ptr slice, self_3, !2548 - mem_copy_val v149, v148 - v150 = get_local __ptr slice, self_3, !2549 - v151 = get_local __ptr slice, slice_2, !2550 - mem_copy_val v151, v150 - v152 = get_local __ptr slice, slice_2, !2551 - v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { - } - v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v154, v153 - v155 = get_local __ptr { ptr, u64 }, __anon_04, !2548 - mem_copy_val v155, v154 - v156 = get_elem_ptr v155, __ptr ptr, v57, !2552 - v157 = load v156, !2548 - v158 = asm(s: v157) -> __ptr string<16> s { - } - v159 = get_local __ptr string<16>, __aggr_memcpy_03 - mem_copy_val v159, v158 - v160 = get_local __ptr string<16>, r, !2553 - mem_copy_val v160, v159 - v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v162 = call new_21(v161) - v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v163, v161 - v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v165 = const u64 103, !1814 - v166 = call abi_encode_20(v165, v163, v164) - v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2554 - mem_copy_val v167, v164 - v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2555 - v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v169, v168 - v170 = get_local __ptr slice, __ret_val13 - v171 = call as_raw_slice_22(v169, v170) - v172 = get_local __ptr slice, __log_arg2 - mem_copy_val v172, v170 - v173 = const u64 1515152261580153489 - log __ptr slice v172, v173 - v174 = get_local __ptr string<16>, r, !2556 - v175 = get_local __ptr string<16>, _, !2557 - mem_copy_val v175, v174 - v176 = const unit () - ret () v176 - } - - entry fn cost_of_in_str_32() -> (), !2561 { - local string<32> _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local mut { ptr, u64 } __aggr_memcpy_02 - local mut string<32> __aggr_memcpy_03 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local { ptr, u64 } __anon_04 - local slice __anon_1 - local b256 __anon_10 - local string<32> __anon_2 - local { string<32> } __anon_3 - local string<32> __const = const string<32> "12345678901234567890123456789012" - local b256 __const0 = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local slice __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local string<32> __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { string<32> } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice data - local slice first_parameter - local { string<32> } item_ - local slice method_name_ - local slice params - local string<32> r - local slice second_parameter - local { string<32> } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice self_3 - local slice slice_ - local slice slice_0 - local slice slice_1 - local slice slice_2 - - entry(): - v0 = get_local __ptr string<32>, __const - v1 = get_local __ptr b256, __const0 - v2 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2562 - v3 = get_global __ptr string<9>, __const_global39 - v4 = cast_ptr v3 to ptr, !2563 - v5 = get_local __ptr { ptr, u64 }, __anon_0, !2563 - v6 = const u64 0 - v7 = get_elem_ptr v5, __ptr ptr, v6 - store v4 to v7, !2563 - v8 = const u64 1 - v9 = get_elem_ptr v5, __ptr u64, v8 - v10 = const u64 9 - store v10 to v9, !2563 - v11 = get_local __ptr slice, __anon_1, !2563 - mem_copy_bytes v11, v5, 16 - v12 = get_local __ptr string<32>, __anon_2 - mem_copy_val v12, v0 - v13 = get_local __ptr { string<32> }, __anon_3 - v14 = const u64 0 - v15 = get_elem_ptr v13, __ptr string<32>, v14 - mem_copy_val v15, v12 - v16 = get_local __ptr b256, contract_id_, !2564 - mem_copy_val v16, v2 - v17 = get_local __ptr slice, method_name_, !2564 - mem_copy_val v17, v11 - v18 = get_local __ptr { string<32> }, args_, !2564 - mem_copy_val v18, v13 - v19 = get_local __ptr b256, asset_id_, !2564 - mem_copy_val v19, v1 - v20 = get_local __ptr slice, method_name_, !2565 - v21 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v21, v20 - v22 = get_local __ptr slice, __ret_val15 - v23 = call encode_208(v21, v22) - v24 = get_local __ptr slice, first_parameter, !2566 - mem_copy_val v24, v22 - v25 = get_local __ptr { string<32> }, args_, !2567 - v26 = get_local __ptr { string<32> }, item_, !2568 - mem_copy_val v26, v25 - v27 = get_local __ptr { string<32> }, item_, !2569 - v28 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v29 = call new_21(v28) - v30 = get_local __ptr { string<32> }, self_, !2570 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2571 - mem_copy_val v31, v28 - v32 = get_local __ptr { string<32> }, self_, !2572 - v33 = const u64 0 - v34 = get_elem_ptr v32, __ptr string<32>, v33, !2573 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2574 - v36 = get_local __ptr string<32>, __tmp_arg8 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v37, v35 - v38 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v39 = call abi_encode_119(v36, v37, v38) - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2575 - mem_copy_val v40, v38 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2576 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2577 - mem_copy_val v42, v41 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2578 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v44, v43 - v45 = get_local __ptr slice, __ret_val9 - v46 = call as_raw_slice_22(v44, v45) - v47 = get_local __ptr slice, second_parameter, !2579 - mem_copy_val v47, v45 - v48 = get_local __ptr b256, contract_id_, !2580 - v49 = get_local __ptr slice, first_parameter, !2581 - v50 = get_local __ptr slice, self_0, !2582 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, self_0, !2583 - v52 = get_local __ptr slice, slice_, !2584 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, slice_, !2585 - v54 = asm(ptr: v53) -> __ptr { ptr, u64 } ptr { - } - v55 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v55, v54 - v56 = get_local __ptr { ptr, u64 }, __anon_01, !2582 - mem_copy_val v56, v55 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr ptr, v57, !2586 - v59 = load v58, !2582 - v60 = asm(a: v59) -> u64 a, !2587 { - } - v61 = get_local __ptr slice, second_parameter, !2588 - v62 = get_local __ptr slice, self_1, !2589 - mem_copy_val v62, v61 - v63 = get_local __ptr slice, self_1, !2590 - v64 = get_local __ptr slice, slice_0, !2591 - mem_copy_val v64, v63 - v65 = get_local __ptr slice, slice_0, !2592 - v66 = asm(ptr: v65) -> __ptr { ptr, u64 } ptr { - } - v67 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v67, v66 - v68 = get_local __ptr { ptr, u64 }, __anon_02, !2589 - mem_copy_val v68, v67 - v69 = get_elem_ptr v68, __ptr ptr, v57, !2593 - v70 = load v69, !2589 - v71 = asm(a: v70) -> u64 a, !2594 { - } - v72 = get_local __ptr { b256, u64, u64 }, __anon_00, !2595 - v73 = const u64 0 - v74 = get_elem_ptr v72, __ptr b256, v73, !2596 - mem_copy_val v74, v48 - v75 = const u64 1 - v76 = get_elem_ptr v72, __ptr u64, v75, !2597 - store v60 to v76, !2598 - v77 = const u64 2 - v78 = get_elem_ptr v72, __ptr u64, v77, !2599 - store v71 to v78, !2600 - v79 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v79, v72 - v80 = get_local __ptr slice, __ret_val16 - v81 = call encode_212(v79, v80) - v82 = get_local __ptr slice, params, !2601 - mem_copy_val v82, v80 - v83 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v84 = call new_21(v83) - v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v85, v83 - v86 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v87 = const u64 100, !1772 - v88 = call abi_encode_20(v87, v85, v86) - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2602 - mem_copy_val v89, v86 - v90 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2603 - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, __ret_val10 - v93 = call as_raw_slice_22(v91, v92) - v94 = get_local __ptr slice, __log_arg - mem_copy_val v94, v92 - v95 = const u64 1515152261580153489 - log __ptr slice v94, v95 - v96 = get_local __ptr slice, params, !2604 - v97 = get_local __ptr slice, self_2, !2605 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, self_2, !2606 - v99 = get_local __ptr slice, slice_1, !2607 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, slice_1, !2608 - v101 = asm(ptr: v100) -> __ptr { ptr, u64 } ptr { - } - v102 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v102, v101 - v103 = get_local __ptr { ptr, u64 }, __anon_03, !2605 - mem_copy_val v103, v102 - v104 = get_elem_ptr v103, __ptr ptr, v57, !2609 - v105 = load v104, !2605 - v106 = get_local __ptr b256, asset_id_, !2610 - v107 = get_local __ptr b256, __anon_10, !2564 - mem_copy_val v107, v106 - v108 = get_local __ptr b256, __anon_10, !2564 - v109 = const u64 0 - v110 = const u64 18446744073709551615 - v111 = contract_call __ptr () v105, v109, v108, v110, !2611 - v112 = asm() -> ptr ret, !2612 { - } - v113 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v114 = call new_21(v113) - v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v115, v113 - v116 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v117 = const u64 101, !1790 - v118 = call abi_encode_20(v117, v115, v116) - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2613 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2614 - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v121, v120 - v122 = get_local __ptr slice, __ret_val11 - v123 = call as_raw_slice_22(v121, v122) - v124 = get_local __ptr slice, __log_arg0 - mem_copy_val v124, v122 - v125 = const u64 1515152261580153489 - log __ptr slice v124, v125 - v126 = get_local __ptr { ptr }, __anon_000, !2615 - v127 = const u64 0 - v128 = get_elem_ptr v126, __ptr ptr, v127, !2616 - store v112 to v128, !2617 - v129 = get_local __ptr { ptr }, buffer, !2618 - mem_copy_val v129, v126 - v130 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v131 = call new_21(v130) - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v132, v130 - v133 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v134 = const u64 102, !1801 - v135 = call abi_encode_20(v134, v132, v133) - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2619 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2620 - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v138, v137 - v139 = get_local __ptr slice, __ret_val12 - v140 = call as_raw_slice_22(v138, v139) - v141 = get_local __ptr slice, __log_arg1 - mem_copy_val v141, v139 - v142 = const u64 1515152261580153489 - log __ptr slice v141, v142 - v143 = get_local __ptr { ptr }, buffer, !2621 - v144 = get_local __ptr slice, __ret_val - v145 = const u64 32 - v146 = call read_bytes_8(v143, v145, v144) - v147 = get_local __ptr slice, data, !2622 - mem_copy_val v147, v144 - v148 = get_local __ptr slice, data, !2623 - v149 = get_local __ptr slice, self_3, !2624 - mem_copy_val v149, v148 - v150 = get_local __ptr slice, self_3, !2625 - v151 = get_local __ptr slice, slice_2, !2626 - mem_copy_val v151, v150 - v152 = get_local __ptr slice, slice_2, !2627 - v153 = asm(ptr: v152) -> __ptr { ptr, u64 } ptr { - } - v154 = get_local __ptr { ptr, u64 }, __aggr_memcpy_02 - mem_copy_val v154, v153 - v155 = get_local __ptr { ptr, u64 }, __anon_04, !2624 - mem_copy_val v155, v154 - v156 = get_elem_ptr v155, __ptr ptr, v57, !2628 - v157 = load v156, !2624 - v158 = asm(s: v157) -> __ptr string<32> s { - } - v159 = get_local __ptr string<32>, __aggr_memcpy_03 - mem_copy_val v159, v158 - v160 = get_local __ptr string<32>, r, !2629 - mem_copy_val v160, v159 - v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v162 = call new_21(v161) - v163 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v163, v161 - v164 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v165 = const u64 103, !1814 - v166 = call abi_encode_20(v165, v163, v164) - v167 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2630 - mem_copy_val v167, v164 - v168 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2631 - v169 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v169, v168 - v170 = get_local __ptr slice, __ret_val13 - v171 = call as_raw_slice_22(v169, v170) - v172 = get_local __ptr slice, __log_arg2 - mem_copy_val v172, v170 - v173 = const u64 1515152261580153489 - log __ptr slice v172, v173 - v174 = get_local __ptr string<32>, r, !2632 - v175 = get_local __ptr string<32>, _, !2633 - mem_copy_val v175, v174 - v176 = const unit () - ret () v176 - } - - entry fn cost_of_in_array_0() -> (), !2637 { - local [u64; 0] _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local [u64; 0] __anon_2 - local { [u64; 0] } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local [u64; 0] __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local { { ptr, u64, u64 } } __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local [u64; 0] __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { [u64; 0] } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { [u64; 0] } item_ - local slice method_name_ - local slice params - local [u64; 0] r - local slice second_parameter - local { [u64; 0] } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2638 - v2 = get_global __ptr string<10>, __const_global40 - v3 = cast_ptr v2 to ptr, !2639 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !2639 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !2639 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !2639 - v10 = get_local __ptr slice, __anon_1, !2639 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr [u64; 0], __anon_2, !2640 - v12 = get_local __ptr { [u64; 0] }, __anon_3 - v13 = const u64 0 - v14 = get_elem_ptr v12, __ptr [u64; 0], v13 - mem_copy_val v14, v11 - v15 = get_local __ptr b256, contract_id_, !2641 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !2641 - mem_copy_val v16, v10 - v17 = get_local __ptr { [u64; 0] }, args_, !2641 - mem_copy_val v17, v12 - v18 = get_local __ptr b256, asset_id_, !2641 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !2642 - v20 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val15 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !2643 - mem_copy_val v23, v21 - v24 = get_local __ptr { [u64; 0] }, args_, !2644 - v25 = get_local __ptr { [u64; 0] }, item_, !2645 - mem_copy_val v25, v24 - v26 = get_local __ptr { [u64; 0] }, item_, !2646 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v28 = call new_21(v27) - v29 = get_local __ptr { [u64; 0] }, self_, !2647 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2648 - mem_copy_val v30, v27 - v31 = get_local __ptr { [u64; 0] }, self_, !2649 - v32 = const u64 0 - v33 = get_elem_ptr v31, __ptr [u64; 0], v32, !2650 - v34 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2651 - v35 = get_local __ptr [u64; 0], __tmp_arg8 - mem_copy_val v35, v33 - v36 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v36, v34 - v37 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v38 = call abi_encode_29(v35, v36, v37) - v39 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2652 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2653 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2654 - mem_copy_val v41, v40 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2655 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v43, v42 - v44 = get_local __ptr slice, __ret_val9 - v45 = call as_raw_slice_22(v43, v44) - v46 = get_local __ptr slice, second_parameter, !2656 - mem_copy_val v46, v44 - v47 = get_local __ptr b256, contract_id_, !2657 - v48 = get_local __ptr slice, first_parameter, !2658 - v49 = get_local __ptr slice, self_0, !2659 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !2660 - v51 = get_local __ptr slice, slice_, !2661 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_, !2662 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_01, !2659 - mem_copy_val v55, v54 - v56 = const u64 0 - v57 = get_elem_ptr v55, __ptr ptr, v56, !2663 - v58 = load v57, !2659 - v59 = asm(a: v58) -> u64 a, !2664 { - } - v60 = get_local __ptr slice, second_parameter, !2665 - v61 = get_local __ptr slice, self_1, !2666 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_1, !2667 - v63 = get_local __ptr slice, slice_0, !2668 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_0, !2669 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_02, !2666 - mem_copy_val v67, v66 - v68 = get_elem_ptr v67, __ptr ptr, v56, !2670 - v69 = load v68, !2666 - v70 = asm(a: v69) -> u64 a, !2671 { - } - v71 = get_local __ptr { b256, u64, u64 }, __anon_00, !2672 - v72 = const u64 0 - v73 = get_elem_ptr v71, __ptr b256, v72, !2673 - mem_copy_val v73, v47 - v74 = const u64 1 - v75 = get_elem_ptr v71, __ptr u64, v74, !2674 - store v59 to v75, !2675 - v76 = const u64 2 - v77 = get_elem_ptr v71, __ptr u64, v76, !2676 - store v70 to v77, !2677 - v78 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v78, v71 - v79 = get_local __ptr slice, __ret_val16 - v80 = call encode_212(v78, v79) - v81 = get_local __ptr slice, params, !2678 - mem_copy_val v81, v79 - v82 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v83 = call new_21(v82) - v84 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v86 = const u64 100, !1772 - v87 = call abi_encode_20(v86, v84, v85) - v88 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2679 - mem_copy_val v88, v85 - v89 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2680 - v90 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v90, v89 - v91 = get_local __ptr slice, __ret_val10 - v92 = call as_raw_slice_22(v90, v91) - v93 = get_local __ptr slice, __log_arg - mem_copy_val v93, v91 - v94 = const u64 1515152261580153489 - log __ptr slice v93, v94 - v95 = get_local __ptr slice, params, !2681 - v96 = get_local __ptr slice, self_2, !2682 - mem_copy_val v96, v95 - v97 = get_local __ptr slice, self_2, !2683 - v98 = get_local __ptr slice, slice_1, !2684 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, slice_1, !2685 - v100 = asm(ptr: v99) -> __ptr { ptr, u64 } ptr { - } - v101 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v101, v100 - v102 = get_local __ptr { ptr, u64 }, __anon_03, !2682 - mem_copy_val v102, v101 - v103 = get_elem_ptr v102, __ptr ptr, v56, !2686 - v104 = load v103, !2682 - v105 = get_local __ptr b256, asset_id_, !2687 - v106 = get_local __ptr b256, __anon_10, !2641 - mem_copy_val v106, v105 - v107 = get_local __ptr b256, __anon_10, !2641 - v108 = const u64 0 - v109 = const u64 18446744073709551615 - v110 = contract_call __ptr () v104, v108, v107, v109, !2688 - v111 = asm() -> ptr ret, !2689 { - } - v112 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v113 = call new_21(v112) - v114 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v114, v112 - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v116 = const u64 101, !1790 - v117 = call abi_encode_20(v116, v114, v115) - v118 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2690 - mem_copy_val v118, v115 - v119 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2691 - v120 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v120, v119 - v121 = get_local __ptr slice, __ret_val11 - v122 = call as_raw_slice_22(v120, v121) - v123 = get_local __ptr slice, __log_arg0 - mem_copy_val v123, v121 - v124 = const u64 1515152261580153489 - log __ptr slice v123, v124 - v125 = get_local __ptr { ptr }, __anon_000, !2692 - v126 = const u64 0 - v127 = get_elem_ptr v125, __ptr ptr, v126, !2693 - store v111 to v127, !2694 - v128 = get_local __ptr { ptr }, buffer, !2695 - mem_copy_val v128, v125 - v129 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v130 = call new_21(v129) - v131 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v131, v129 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v133 = const u64 102, !1801 - v134 = call abi_encode_20(v133, v131, v132) - v135 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2696 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2697 - v137 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v137, v136 - v138 = get_local __ptr slice, __ret_val12 - v139 = call as_raw_slice_22(v137, v138) - v140 = get_local __ptr slice, __log_arg1 - mem_copy_val v140, v138 - v141 = const u64 1515152261580153489 - log __ptr slice v140, v141 - v142 = get_local __ptr { ptr }, buffer, !2698 - v143 = get_local __ptr [u64; 0], __ret_val - v144 = call abi_decode_18(v142, v143) - v145 = get_local __ptr [u64; 0], r, !2699 - mem_copy_val v145, v143 - v146 = get_local __ptr { { ptr, u64, u64 } }, __ret_val8 - v147 = call new_21(v146) - v148 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v148, v146 - v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v150 = const u64 103, !1814 - v151 = call abi_encode_20(v150, v148, v149) - v152 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2700 - mem_copy_val v152, v149 - v153 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2701 - v154 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v154, v153 - v155 = get_local __ptr slice, __ret_val13 - v156 = call as_raw_slice_22(v154, v155) - v157 = get_local __ptr slice, __log_arg2 - mem_copy_val v157, v155 - v158 = const u64 1515152261580153489 - log __ptr slice v157, v158 - v159 = get_local __ptr [u64; 0], r, !2702 - v160 = get_local __ptr [u64; 0], _, !2703 - mem_copy_val v160, v159 - v161 = const unit () - ret () v161 - } - - entry fn cost_of_in_array_1() -> (), !2707 { - local [u64; 1] _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local [u64; 1] __anon_2 - local { [u64; 1] } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local [u64; 1] __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local [u64; 1] __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { [u64; 1] } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { [u64; 1] } item_ - local slice method_name_ - local slice params - local [u64; 1] r - local slice second_parameter - local { [u64; 1] } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2708 - v2 = get_global __ptr string<10>, __const_global41 - v3 = cast_ptr v2 to ptr, !2709 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !2709 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !2709 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !2709 - v10 = get_local __ptr slice, __anon_1, !2709 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr [u64; 1], __anon_2, !2710 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !2711 - store v14 to v13, !2710 - v15 = get_local __ptr { [u64; 1] }, __anon_3 - v16 = const u64 0 - v17 = get_elem_ptr v15, __ptr [u64; 1], v16 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, contract_id_, !2712 - mem_copy_val v18, v1 - v19 = get_local __ptr slice, method_name_, !2712 - mem_copy_val v19, v10 - v20 = get_local __ptr { [u64; 1] }, args_, !2712 - mem_copy_val v20, v15 - v21 = get_local __ptr b256, asset_id_, !2712 - mem_copy_val v21, v0 - v22 = get_local __ptr slice, method_name_, !2713 - v23 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v23, v22 - v24 = get_local __ptr slice, __ret_val15 - v25 = call encode_208(v23, v24) - v26 = get_local __ptr slice, first_parameter, !2714 - mem_copy_val v26, v24 - v27 = get_local __ptr { [u64; 1] }, args_, !2715 - v28 = get_local __ptr { [u64; 1] }, item_, !2716 - mem_copy_val v28, v27 - v29 = get_local __ptr { [u64; 1] }, item_, !2717 - v30 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v31 = call new_21(v30) - v32 = get_local __ptr { [u64; 1] }, self_, !2718 - mem_copy_val v32, v29 - v33 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2719 - mem_copy_val v33, v30 - v34 = get_local __ptr { [u64; 1] }, self_, !2720 - v35 = const u64 0 - v36 = get_elem_ptr v34, __ptr [u64; 1], v35, !2721 - v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2722 - v38 = get_local __ptr [u64; 1], __tmp_arg8 - mem_copy_val v38, v36 - v39 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v39, v37 - v40 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v41 = call abi_encode_37(v38, v39, v40) - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2723 - mem_copy_val v42, v40 - v43 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2724 - v44 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2725 - mem_copy_val v44, v43 - v45 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2726 - v46 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v46, v45 - v47 = get_local __ptr slice, __ret_val8 - v48 = call as_raw_slice_22(v46, v47) - v49 = get_local __ptr slice, second_parameter, !2727 - mem_copy_val v49, v47 - v50 = get_local __ptr b256, contract_id_, !2728 - v51 = get_local __ptr slice, first_parameter, !2729 - v52 = get_local __ptr slice, self_0, !2730 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, self_0, !2731 - v54 = get_local __ptr slice, slice_, !2732 - mem_copy_val v54, v53 - v55 = get_local __ptr slice, slice_, !2733 - v56 = asm(ptr: v55) -> __ptr { ptr, u64 } ptr { - } - v57 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v57, v56 - v58 = get_local __ptr { ptr, u64 }, __anon_01, !2730 - mem_copy_val v58, v57 - v59 = const u64 0 - v60 = get_elem_ptr v58, __ptr ptr, v59, !2734 - v61 = load v60, !2730 - v62 = asm(a: v61) -> u64 a, !2735 { - } - v63 = get_local __ptr slice, second_parameter, !2736 - v64 = get_local __ptr slice, self_1, !2737 - mem_copy_val v64, v63 - v65 = get_local __ptr slice, self_1, !2738 - v66 = get_local __ptr slice, slice_0, !2739 - mem_copy_val v66, v65 - v67 = get_local __ptr slice, slice_0, !2740 - v68 = asm(ptr: v67) -> __ptr { ptr, u64 } ptr { - } - v69 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v69, v68 - v70 = get_local __ptr { ptr, u64 }, __anon_02, !2737 - mem_copy_val v70, v69 - v71 = get_elem_ptr v70, __ptr ptr, v59, !2741 - v72 = load v71, !2737 - v73 = asm(a: v72) -> u64 a, !2742 { - } - v74 = get_local __ptr { b256, u64, u64 }, __anon_00, !2743 - v75 = const u64 0 - v76 = get_elem_ptr v74, __ptr b256, v75, !2744 - mem_copy_val v76, v50 - v77 = const u64 1 - v78 = get_elem_ptr v74, __ptr u64, v77, !2745 - store v62 to v78, !2746 - v79 = const u64 2 - v80 = get_elem_ptr v74, __ptr u64, v79, !2747 - store v73 to v80, !2748 - v81 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v81, v74 - v82 = get_local __ptr slice, __ret_val16 - v83 = call encode_212(v81, v82) - v84 = get_local __ptr slice, params, !2749 - mem_copy_val v84, v82 - v85 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v86 = call new_21(v85) - v87 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v87, v85 - v88 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v89 = const u64 100, !1772 - v90 = call abi_encode_20(v89, v87, v88) - v91 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2750 - mem_copy_val v91, v88 - v92 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2751 - v93 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v93, v92 - v94 = get_local __ptr slice, __ret_val9 - v95 = call as_raw_slice_22(v93, v94) - v96 = get_local __ptr slice, __log_arg - mem_copy_val v96, v94 - v97 = const u64 1515152261580153489 - log __ptr slice v96, v97 - v98 = get_local __ptr slice, params, !2752 - v99 = get_local __ptr slice, self_2, !2753 - mem_copy_val v99, v98 - v100 = get_local __ptr slice, self_2, !2754 - v101 = get_local __ptr slice, slice_1, !2755 - mem_copy_val v101, v100 - v102 = get_local __ptr slice, slice_1, !2756 - v103 = asm(ptr: v102) -> __ptr { ptr, u64 } ptr { - } - v104 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v104, v103 - v105 = get_local __ptr { ptr, u64 }, __anon_03, !2753 - mem_copy_val v105, v104 - v106 = get_elem_ptr v105, __ptr ptr, v59, !2757 - v107 = load v106, !2753 - v108 = get_local __ptr b256, asset_id_, !2758 - v109 = get_local __ptr b256, __anon_10, !2712 - mem_copy_val v109, v108 - v110 = get_local __ptr b256, __anon_10, !2712 - v111 = const u64 0 - v112 = const u64 18446744073709551615 - v113 = contract_call __ptr () v107, v111, v110, v112, !2759 - v114 = asm() -> ptr ret, !2760 { - } - v115 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v116 = call new_21(v115) - v117 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v117, v115 - v118 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v119 = const u64 101, !1790 - v120 = call abi_encode_20(v119, v117, v118) - v121 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2761 - mem_copy_val v121, v118 - v122 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2762 - v123 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v123, v122 - v124 = get_local __ptr slice, __ret_val10 - v125 = call as_raw_slice_22(v123, v124) - v126 = get_local __ptr slice, __log_arg0 - mem_copy_val v126, v124 - v127 = const u64 1515152261580153489 - log __ptr slice v126, v127 - v128 = get_local __ptr { ptr }, __anon_000, !2763 - v129 = const u64 0 - v130 = get_elem_ptr v128, __ptr ptr, v129, !2764 - store v114 to v130, !2765 - v131 = get_local __ptr { ptr }, buffer, !2766 - mem_copy_val v131, v128 - v132 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v133 = call new_21(v132) - v134 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v134, v132 - v135 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v136 = const u64 102, !1801 - v137 = call abi_encode_20(v136, v134, v135) - v138 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2767 - mem_copy_val v138, v135 - v139 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2768 - v140 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v140, v139 - v141 = get_local __ptr slice, __ret_val11 - v142 = call as_raw_slice_22(v140, v141) - v143 = get_local __ptr slice, __log_arg1 - mem_copy_val v143, v141 - v144 = const u64 1515152261580153489 - log __ptr slice v143, v144 - v145 = get_local __ptr { ptr }, buffer, !2769 - v146 = get_local __ptr [u64; 1], __ret_val13 - v147 = call abi_decode_34(v145, v146) - v148 = get_local __ptr [u64; 1], r, !2770 - mem_copy_val v148, v146 - v149 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v150 = call new_21(v149) - v151 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v151, v149 - v152 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v153 = const u64 103, !1814 - v154 = call abi_encode_20(v153, v151, v152) - v155 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2771 - mem_copy_val v155, v152 - v156 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2772 - v157 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v157, v156 - v158 = get_local __ptr slice, __ret_val12 - v159 = call as_raw_slice_22(v157, v158) - v160 = get_local __ptr slice, __log_arg2 - mem_copy_val v160, v158 - v161 = const u64 1515152261580153489 - log __ptr slice v160, v161 - v162 = get_local __ptr [u64; 1], r, !2773 - v163 = get_local __ptr [u64; 1], _, !2774 - mem_copy_val v163, v162 - v164 = const unit () - ret () v164 - } - - entry fn cost_of_in_array_8() -> (), !2778 { - local [u64; 8] _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local [u64; 8] __anon_2 - local { [u64; 8] } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local [u64; 8] __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local [u64; 8] __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { [u64; 8] } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { [u64; 8] } item_ - local slice method_name_ - local slice params - local [u64; 8] r - local slice second_parameter - local { [u64; 8] } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2779 - v1 = get_global __ptr string<10>, __const_global42 - v2 = cast_ptr v1 to ptr, !2780 - v3 = get_local __ptr { ptr, u64 }, __anon_0, !2780 - v4 = const u64 0 - v5 = get_elem_ptr v3, __ptr ptr, v4 - store v2 to v5, !2780 - v6 = const u64 1 - v7 = get_elem_ptr v3, __ptr u64, v6 - v8 = const u64 10 - store v8 to v7, !2780 - v9 = get_local __ptr slice, __anon_1, !2780 - mem_copy_bytes v9, v3, 16 - v10 = get_local __ptr [u64; 8], __anon_2, !2781 - v11 = const u64 0 - br array_init_loop(v11) - - array_init_loop(v12: u64): - v13 = get_elem_ptr v10, __ptr u64, v12 - v14 = const u64 0, !2782 - store v14 to v13, !2781 - v15 = const u64 1 - v16 = add v12, v15 - v17 = const u64 8 - v18 = cmp lt v16 v17 - cbr v18, array_init_loop(v16), array_init_exit() - - array_init_exit(): - v19 = get_local __ptr b256, __const - v20 = get_local __ptr { [u64; 8] }, __anon_3 - v21 = const u64 0 - v22 = get_elem_ptr v20, __ptr [u64; 8], v21 - mem_copy_val v22, v10 - v23 = get_local __ptr b256, contract_id_, !2783 - mem_copy_val v23, v0 - v24 = get_local __ptr slice, method_name_, !2783 - mem_copy_val v24, v9 - v25 = get_local __ptr { [u64; 8] }, args_, !2783 - mem_copy_val v25, v20 - v26 = get_local __ptr b256, asset_id_, !2783 - mem_copy_val v26, v19 - v27 = get_local __ptr slice, method_name_, !2784 - v28 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v28, v27 - v29 = get_local __ptr slice, __ret_val15 - v30 = call encode_208(v28, v29) - v31 = get_local __ptr slice, first_parameter, !2785 - mem_copy_val v31, v29 - v32 = get_local __ptr { [u64; 8] }, args_, !2786 - v33 = get_local __ptr { [u64; 8] }, item_, !2787 - mem_copy_val v33, v32 - v34 = get_local __ptr { [u64; 8] }, item_, !2788 - v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v36 = call new_21(v35) - v37 = get_local __ptr { [u64; 8] }, self_, !2789 - mem_copy_val v37, v34 - v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2790 - mem_copy_val v38, v35 - v39 = get_local __ptr { [u64; 8] }, self_, !2791 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr [u64; 8], v40, !2792 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2793 - v43 = get_local __ptr [u64; 8], __tmp_arg8 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v44, v42 - v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v46 = call abi_encode_61(v43, v44, v45) - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2794 - mem_copy_val v47, v45 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2795 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2796 - mem_copy_val v49, v48 - v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2797 - v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, __ret_val8 - v53 = call as_raw_slice_22(v51, v52) - v54 = get_local __ptr slice, second_parameter, !2798 - mem_copy_val v54, v52 - v55 = get_local __ptr b256, contract_id_, !2799 - v56 = get_local __ptr slice, first_parameter, !2800 - v57 = get_local __ptr slice, self_0, !2801 - mem_copy_val v57, v56 - v58 = get_local __ptr slice, self_0, !2802 - v59 = get_local __ptr slice, slice_, !2803 - mem_copy_val v59, v58 - v60 = get_local __ptr slice, slice_, !2804 - v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { - } - v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v62, v61 - v63 = get_local __ptr { ptr, u64 }, __anon_01, !2801 - mem_copy_val v63, v62 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr ptr, v64, !2805 - v66 = load v65, !2801 - v67 = asm(a: v66) -> u64 a, !2806 { - } - v68 = get_local __ptr slice, second_parameter, !2807 - v69 = get_local __ptr slice, self_1, !2808 - mem_copy_val v69, v68 - v70 = get_local __ptr slice, self_1, !2809 - v71 = get_local __ptr slice, slice_0, !2810 - mem_copy_val v71, v70 - v72 = get_local __ptr slice, slice_0, !2811 - v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { - } - v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v74, v73 - v75 = get_local __ptr { ptr, u64 }, __anon_02, !2808 - mem_copy_val v75, v74 - v76 = get_elem_ptr v75, __ptr ptr, v64, !2812 - v77 = load v76, !2808 - v78 = asm(a: v77) -> u64 a, !2813 { - } - v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !2814 - v80 = const u64 0 - v81 = get_elem_ptr v79, __ptr b256, v80, !2815 - mem_copy_val v81, v55 - v82 = const u64 1 - v83 = get_elem_ptr v79, __ptr u64, v82, !2816 - store v67 to v83, !2817 - v84 = const u64 2 - v85 = get_elem_ptr v79, __ptr u64, v84, !2818 - store v78 to v85, !2819 - v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v86, v79 - v87 = get_local __ptr slice, __ret_val16 - v88 = call encode_212(v86, v87) - v89 = get_local __ptr slice, params, !2820 - mem_copy_val v89, v87 - v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v91 = call new_21(v90) - v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v92, v90 - v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v94 = const u64 100, !1772 - v95 = call abi_encode_20(v94, v92, v93) - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2821 - mem_copy_val v96, v93 - v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2822 - v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, __ret_val9 - v100 = call as_raw_slice_22(v98, v99) - v101 = get_local __ptr slice, __log_arg - mem_copy_val v101, v99 - v102 = const u64 1515152261580153489 - log __ptr slice v101, v102 - v103 = get_local __ptr slice, params, !2823 - v104 = get_local __ptr slice, self_2, !2824 - mem_copy_val v104, v103 - v105 = get_local __ptr slice, self_2, !2825 - v106 = get_local __ptr slice, slice_1, !2826 - mem_copy_val v106, v105 - v107 = get_local __ptr slice, slice_1, !2827 - v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { - } - v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v109, v108 - v110 = get_local __ptr { ptr, u64 }, __anon_03, !2824 - mem_copy_val v110, v109 - v111 = get_elem_ptr v110, __ptr ptr, v64, !2828 - v112 = load v111, !2824 - v113 = get_local __ptr b256, asset_id_, !2829 - v114 = get_local __ptr b256, __anon_10, !2783 - mem_copy_val v114, v113 - v115 = get_local __ptr b256, __anon_10, !2783 - v116 = const u64 0 - v117 = const u64 18446744073709551615 - v118 = contract_call __ptr () v112, v116, v115, v117, !2830 - v119 = asm() -> ptr ret, !2831 { - } - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v121 = call new_21(v120) - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v122, v120 - v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v124 = const u64 101, !1790 - v125 = call abi_encode_20(v124, v122, v123) - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2832 - mem_copy_val v126, v123 - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2833 - v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v128, v127 - v129 = get_local __ptr slice, __ret_val10 - v130 = call as_raw_slice_22(v128, v129) - v131 = get_local __ptr slice, __log_arg0 - mem_copy_val v131, v129 - v132 = const u64 1515152261580153489 - log __ptr slice v131, v132 - v133 = get_local __ptr { ptr }, __anon_000, !2834 - v134 = const u64 0 - v135 = get_elem_ptr v133, __ptr ptr, v134, !2835 - store v119 to v135, !2836 - v136 = get_local __ptr { ptr }, buffer, !2837 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v141 = const u64 102, !1801 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2838 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2839 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val11 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg1 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = get_local __ptr { ptr }, buffer, !2840 - v151 = get_local __ptr [u64; 8], __ret_val13 - v152 = call abi_decode_58(v150, v151) - v153 = get_local __ptr [u64; 8], r, !2841 - mem_copy_val v153, v151 - v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v155 = call new_21(v154) - v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v156, v154 - v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v158 = const u64 103, !1814 - v159 = call abi_encode_20(v158, v156, v157) - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2842 - mem_copy_val v160, v157 - v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2843 - v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v162, v161 - v163 = get_local __ptr slice, __ret_val12 - v164 = call as_raw_slice_22(v162, v163) - v165 = get_local __ptr slice, __log_arg2 - mem_copy_val v165, v163 - v166 = const u64 1515152261580153489 - log __ptr slice v165, v166 - v167 = get_local __ptr [u64; 8], r, !2844 - v168 = get_local __ptr [u64; 8], _, !2845 - mem_copy_val v168, v167 - v169 = const unit () - ret () v169 - } - - entry fn cost_of_in_array_16() -> (), !2849 { - local [u64; 16] _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local [u64; 16] __anon_2 - local { [u64; 16] } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local [u64; 16] __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local [u64; 16] __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { [u64; 16] } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { [u64; 16] } item_ - local slice method_name_ - local slice params - local [u64; 16] r - local slice second_parameter - local { [u64; 16] } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2850 - v1 = get_global __ptr string<11>, __const_global43 - v2 = cast_ptr v1 to ptr, !2851 - v3 = get_local __ptr { ptr, u64 }, __anon_0, !2851 - v4 = const u64 0 - v5 = get_elem_ptr v3, __ptr ptr, v4 - store v2 to v5, !2851 - v6 = const u64 1 - v7 = get_elem_ptr v3, __ptr u64, v6 - v8 = const u64 11 - store v8 to v7, !2851 - v9 = get_local __ptr slice, __anon_1, !2851 - mem_copy_bytes v9, v3, 16 - v10 = get_local __ptr [u64; 16], __anon_2, !2852 - v11 = const u64 0 - br array_init_loop(v11) - - array_init_loop(v12: u64): - v13 = get_elem_ptr v10, __ptr u64, v12 - v14 = const u64 0, !2853 - store v14 to v13, !2852 - v15 = const u64 1 - v16 = add v12, v15 - v17 = const u64 16 - v18 = cmp lt v16 v17 - cbr v18, array_init_loop(v16), array_init_exit() - - array_init_exit(): - v19 = get_local __ptr b256, __const - v20 = get_local __ptr { [u64; 16] }, __anon_3 - v21 = const u64 0 - v22 = get_elem_ptr v20, __ptr [u64; 16], v21 - mem_copy_val v22, v10 - v23 = get_local __ptr b256, contract_id_, !2854 - mem_copy_val v23, v0 - v24 = get_local __ptr slice, method_name_, !2854 - mem_copy_val v24, v9 - v25 = get_local __ptr { [u64; 16] }, args_, !2854 - mem_copy_val v25, v20 - v26 = get_local __ptr b256, asset_id_, !2854 - mem_copy_val v26, v19 - v27 = get_local __ptr slice, method_name_, !2855 - v28 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v28, v27 - v29 = get_local __ptr slice, __ret_val15 - v30 = call encode_208(v28, v29) - v31 = get_local __ptr slice, first_parameter, !2856 - mem_copy_val v31, v29 - v32 = get_local __ptr { [u64; 16] }, args_, !2857 - v33 = get_local __ptr { [u64; 16] }, item_, !2858 - mem_copy_val v33, v32 - v34 = get_local __ptr { [u64; 16] }, item_, !2859 - v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v36 = call new_21(v35) - v37 = get_local __ptr { [u64; 16] }, self_, !2860 - mem_copy_val v37, v34 - v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2861 - mem_copy_val v38, v35 - v39 = get_local __ptr { [u64; 16] }, self_, !2862 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr [u64; 16], v40, !2863 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2864 - v43 = get_local __ptr [u64; 16], __tmp_arg8 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v44, v42 - v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v46 = call abi_encode_43(v43, v44, v45) - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2865 - mem_copy_val v47, v45 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2866 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2867 - mem_copy_val v49, v48 - v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2868 - v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, __ret_val8 - v53 = call as_raw_slice_22(v51, v52) - v54 = get_local __ptr slice, second_parameter, !2869 - mem_copy_val v54, v52 - v55 = get_local __ptr b256, contract_id_, !2870 - v56 = get_local __ptr slice, first_parameter, !2871 - v57 = get_local __ptr slice, self_0, !2872 - mem_copy_val v57, v56 - v58 = get_local __ptr slice, self_0, !2873 - v59 = get_local __ptr slice, slice_, !2874 - mem_copy_val v59, v58 - v60 = get_local __ptr slice, slice_, !2875 - v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { - } - v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v62, v61 - v63 = get_local __ptr { ptr, u64 }, __anon_01, !2872 - mem_copy_val v63, v62 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr ptr, v64, !2876 - v66 = load v65, !2872 - v67 = asm(a: v66) -> u64 a, !2877 { - } - v68 = get_local __ptr slice, second_parameter, !2878 - v69 = get_local __ptr slice, self_1, !2879 - mem_copy_val v69, v68 - v70 = get_local __ptr slice, self_1, !2880 - v71 = get_local __ptr slice, slice_0, !2881 - mem_copy_val v71, v70 - v72 = get_local __ptr slice, slice_0, !2882 - v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { - } - v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v74, v73 - v75 = get_local __ptr { ptr, u64 }, __anon_02, !2879 - mem_copy_val v75, v74 - v76 = get_elem_ptr v75, __ptr ptr, v64, !2883 - v77 = load v76, !2879 - v78 = asm(a: v77) -> u64 a, !2884 { - } - v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !2885 - v80 = const u64 0 - v81 = get_elem_ptr v79, __ptr b256, v80, !2886 - mem_copy_val v81, v55 - v82 = const u64 1 - v83 = get_elem_ptr v79, __ptr u64, v82, !2887 - store v67 to v83, !2888 - v84 = const u64 2 - v85 = get_elem_ptr v79, __ptr u64, v84, !2889 - store v78 to v85, !2890 - v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v86, v79 - v87 = get_local __ptr slice, __ret_val16 - v88 = call encode_212(v86, v87) - v89 = get_local __ptr slice, params, !2891 - mem_copy_val v89, v87 - v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v91 = call new_21(v90) - v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v92, v90 - v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v94 = const u64 100, !1772 - v95 = call abi_encode_20(v94, v92, v93) - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2892 - mem_copy_val v96, v93 - v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2893 - v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, __ret_val9 - v100 = call as_raw_slice_22(v98, v99) - v101 = get_local __ptr slice, __log_arg - mem_copy_val v101, v99 - v102 = const u64 1515152261580153489 - log __ptr slice v101, v102 - v103 = get_local __ptr slice, params, !2894 - v104 = get_local __ptr slice, self_2, !2895 - mem_copy_val v104, v103 - v105 = get_local __ptr slice, self_2, !2896 - v106 = get_local __ptr slice, slice_1, !2897 - mem_copy_val v106, v105 - v107 = get_local __ptr slice, slice_1, !2898 - v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { - } - v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v109, v108 - v110 = get_local __ptr { ptr, u64 }, __anon_03, !2895 - mem_copy_val v110, v109 - v111 = get_elem_ptr v110, __ptr ptr, v64, !2899 - v112 = load v111, !2895 - v113 = get_local __ptr b256, asset_id_, !2900 - v114 = get_local __ptr b256, __anon_10, !2854 - mem_copy_val v114, v113 - v115 = get_local __ptr b256, __anon_10, !2854 - v116 = const u64 0 - v117 = const u64 18446744073709551615 - v118 = contract_call __ptr () v112, v116, v115, v117, !2901 - v119 = asm() -> ptr ret, !2902 { - } - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v121 = call new_21(v120) - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v122, v120 - v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v124 = const u64 101, !1790 - v125 = call abi_encode_20(v124, v122, v123) - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2903 - mem_copy_val v126, v123 - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2904 - v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v128, v127 - v129 = get_local __ptr slice, __ret_val10 - v130 = call as_raw_slice_22(v128, v129) - v131 = get_local __ptr slice, __log_arg0 - mem_copy_val v131, v129 - v132 = const u64 1515152261580153489 - log __ptr slice v131, v132 - v133 = get_local __ptr { ptr }, __anon_000, !2905 - v134 = const u64 0 - v135 = get_elem_ptr v133, __ptr ptr, v134, !2906 - store v119 to v135, !2907 - v136 = get_local __ptr { ptr }, buffer, !2908 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v141 = const u64 102, !1801 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2909 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2910 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val11 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg1 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = get_local __ptr { ptr }, buffer, !2911 - v151 = get_local __ptr [u64; 16], __ret_val13 - v152 = call abi_decode_40(v150, v151) - v153 = get_local __ptr [u64; 16], r, !2912 - mem_copy_val v153, v151 - v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v155 = call new_21(v154) - v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v156, v154 - v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v158 = const u64 103, !1814 - v159 = call abi_encode_20(v158, v156, v157) - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2913 - mem_copy_val v160, v157 - v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2914 - v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v162, v161 - v163 = get_local __ptr slice, __ret_val12 - v164 = call as_raw_slice_22(v162, v163) - v165 = get_local __ptr slice, __log_arg2 - mem_copy_val v165, v163 - v166 = const u64 1515152261580153489 - log __ptr slice v165, v166 - v167 = get_local __ptr [u64; 16], r, !2915 - v168 = get_local __ptr [u64; 16], _, !2916 - mem_copy_val v168, v167 - v169 = const unit () - ret () v169 - } - - entry fn cost_of_in_array_32() -> (), !2920 { - local [u64; 32] _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local [u64; 32] __anon_2 - local { [u64; 32] } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local [u64; 32] __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local [u64; 32] __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { [u64; 32] } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { [u64; 32] } item_ - local slice method_name_ - local slice params - local [u64; 32] r - local slice second_parameter - local { [u64; 32] } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2921 - v1 = get_global __ptr string<11>, __const_global44 - v2 = cast_ptr v1 to ptr, !2922 - v3 = get_local __ptr { ptr, u64 }, __anon_0, !2922 - v4 = const u64 0 - v5 = get_elem_ptr v3, __ptr ptr, v4 - store v2 to v5, !2922 - v6 = const u64 1 - v7 = get_elem_ptr v3, __ptr u64, v6 - v8 = const u64 11 - store v8 to v7, !2922 - v9 = get_local __ptr slice, __anon_1, !2922 - mem_copy_bytes v9, v3, 16 - v10 = get_local __ptr [u64; 32], __anon_2, !2923 - v11 = const u64 0 - br array_init_loop(v11) - - array_init_loop(v12: u64): - v13 = get_elem_ptr v10, __ptr u64, v12 - v14 = const u64 0, !2924 - store v14 to v13, !2923 - v15 = const u64 1 - v16 = add v12, v15 - v17 = const u64 32 - v18 = cmp lt v16 v17 - cbr v18, array_init_loop(v16), array_init_exit() - - array_init_exit(): - v19 = get_local __ptr b256, __const - v20 = get_local __ptr { [u64; 32] }, __anon_3 - v21 = const u64 0 - v22 = get_elem_ptr v20, __ptr [u64; 32], v21 - mem_copy_val v22, v10 - v23 = get_local __ptr b256, contract_id_, !2925 - mem_copy_val v23, v0 - v24 = get_local __ptr slice, method_name_, !2925 - mem_copy_val v24, v9 - v25 = get_local __ptr { [u64; 32] }, args_, !2925 - mem_copy_val v25, v20 - v26 = get_local __ptr b256, asset_id_, !2925 - mem_copy_val v26, v19 - v27 = get_local __ptr slice, method_name_, !2926 - v28 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v28, v27 - v29 = get_local __ptr slice, __ret_val15 - v30 = call encode_208(v28, v29) - v31 = get_local __ptr slice, first_parameter, !2927 - mem_copy_val v31, v29 - v32 = get_local __ptr { [u64; 32] }, args_, !2928 - v33 = get_local __ptr { [u64; 32] }, item_, !2929 - mem_copy_val v33, v32 - v34 = get_local __ptr { [u64; 32] }, item_, !2930 - v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v36 = call new_21(v35) - v37 = get_local __ptr { [u64; 32] }, self_, !2931 - mem_copy_val v37, v34 - v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2932 - mem_copy_val v38, v35 - v39 = get_local __ptr { [u64; 32] }, self_, !2933 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr [u64; 32], v40, !2934 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !2935 - v43 = get_local __ptr [u64; 32], __tmp_arg8 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v44, v42 - v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v46 = call abi_encode_49(v43, v44, v45) - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2936 - mem_copy_val v47, v45 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !2937 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2938 - mem_copy_val v49, v48 - v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !2939 - v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, __ret_val8 - v53 = call as_raw_slice_22(v51, v52) - v54 = get_local __ptr slice, second_parameter, !2940 - mem_copy_val v54, v52 - v55 = get_local __ptr b256, contract_id_, !2941 - v56 = get_local __ptr slice, first_parameter, !2942 - v57 = get_local __ptr slice, self_0, !2943 - mem_copy_val v57, v56 - v58 = get_local __ptr slice, self_0, !2944 - v59 = get_local __ptr slice, slice_, !2945 - mem_copy_val v59, v58 - v60 = get_local __ptr slice, slice_, !2946 - v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { - } - v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v62, v61 - v63 = get_local __ptr { ptr, u64 }, __anon_01, !2943 - mem_copy_val v63, v62 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr ptr, v64, !2947 - v66 = load v65, !2943 - v67 = asm(a: v66) -> u64 a, !2948 { - } - v68 = get_local __ptr slice, second_parameter, !2949 - v69 = get_local __ptr slice, self_1, !2950 - mem_copy_val v69, v68 - v70 = get_local __ptr slice, self_1, !2951 - v71 = get_local __ptr slice, slice_0, !2952 - mem_copy_val v71, v70 - v72 = get_local __ptr slice, slice_0, !2953 - v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { - } - v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v74, v73 - v75 = get_local __ptr { ptr, u64 }, __anon_02, !2950 - mem_copy_val v75, v74 - v76 = get_elem_ptr v75, __ptr ptr, v64, !2954 - v77 = load v76, !2950 - v78 = asm(a: v77) -> u64 a, !2955 { - } - v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !2956 - v80 = const u64 0 - v81 = get_elem_ptr v79, __ptr b256, v80, !2957 - mem_copy_val v81, v55 - v82 = const u64 1 - v83 = get_elem_ptr v79, __ptr u64, v82, !2958 - store v67 to v83, !2959 - v84 = const u64 2 - v85 = get_elem_ptr v79, __ptr u64, v84, !2960 - store v78 to v85, !2961 - v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v86, v79 - v87 = get_local __ptr slice, __ret_val16 - v88 = call encode_212(v86, v87) - v89 = get_local __ptr slice, params, !2962 - mem_copy_val v89, v87 - v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v91 = call new_21(v90) - v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v92, v90 - v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v94 = const u64 100, !1772 - v95 = call abi_encode_20(v94, v92, v93) - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2963 - mem_copy_val v96, v93 - v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !2964 - v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, __ret_val9 - v100 = call as_raw_slice_22(v98, v99) - v101 = get_local __ptr slice, __log_arg - mem_copy_val v101, v99 - v102 = const u64 1515152261580153489 - log __ptr slice v101, v102 - v103 = get_local __ptr slice, params, !2965 - v104 = get_local __ptr slice, self_2, !2966 - mem_copy_val v104, v103 - v105 = get_local __ptr slice, self_2, !2967 - v106 = get_local __ptr slice, slice_1, !2968 - mem_copy_val v106, v105 - v107 = get_local __ptr slice, slice_1, !2969 - v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { - } - v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v109, v108 - v110 = get_local __ptr { ptr, u64 }, __anon_03, !2966 - mem_copy_val v110, v109 - v111 = get_elem_ptr v110, __ptr ptr, v64, !2970 - v112 = load v111, !2966 - v113 = get_local __ptr b256, asset_id_, !2971 - v114 = get_local __ptr b256, __anon_10, !2925 - mem_copy_val v114, v113 - v115 = get_local __ptr b256, __anon_10, !2925 - v116 = const u64 0 - v117 = const u64 18446744073709551615 - v118 = contract_call __ptr () v112, v116, v115, v117, !2972 - v119 = asm() -> ptr ret, !2973 { - } - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v121 = call new_21(v120) - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v122, v120 - v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v124 = const u64 101, !1790 - v125 = call abi_encode_20(v124, v122, v123) - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2974 - mem_copy_val v126, v123 - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !2975 - v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v128, v127 - v129 = get_local __ptr slice, __ret_val10 - v130 = call as_raw_slice_22(v128, v129) - v131 = get_local __ptr slice, __log_arg0 - mem_copy_val v131, v129 - v132 = const u64 1515152261580153489 - log __ptr slice v131, v132 - v133 = get_local __ptr { ptr }, __anon_000, !2976 - v134 = const u64 0 - v135 = get_elem_ptr v133, __ptr ptr, v134, !2977 - store v119 to v135, !2978 - v136 = get_local __ptr { ptr }, buffer, !2979 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v141 = const u64 102, !1801 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2980 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !2981 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val11 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg1 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = get_local __ptr { ptr }, buffer, !2982 - v151 = get_local __ptr [u64; 32], __ret_val13 - v152 = call abi_decode_46(v150, v151) - v153 = get_local __ptr [u64; 32], r, !2983 - mem_copy_val v153, v151 - v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v155 = call new_21(v154) - v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v156, v154 - v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v158 = const u64 103, !1814 - v159 = call abi_encode_20(v158, v156, v157) - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2984 - mem_copy_val v160, v157 - v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !2985 - v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v162, v161 - v163 = get_local __ptr slice, __ret_val12 - v164 = call as_raw_slice_22(v162, v163) - v165 = get_local __ptr slice, __log_arg2 - mem_copy_val v165, v163 - v166 = const u64 1515152261580153489 - log __ptr slice v165, v166 - v167 = get_local __ptr [u64; 32], r, !2986 - v168 = get_local __ptr [u64; 32], _, !2987 - mem_copy_val v168, v167 - v169 = const unit () - ret () v169 - } - - entry fn cost_of_in_array_64() -> (), !2991 { - local [u64; 64] _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local [u64; 64] __anon_2 - local { [u64; 64] } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local [u64; 64] __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local [u64; 64] __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { [u64; 64] } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { [u64; 64] } item_ - local slice method_name_ - local slice params - local [u64; 64] r - local slice second_parameter - local { [u64; 64] } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !2992 - v1 = get_global __ptr string<11>, __const_global45 - v2 = cast_ptr v1 to ptr, !2993 - v3 = get_local __ptr { ptr, u64 }, __anon_0, !2993 - v4 = const u64 0 - v5 = get_elem_ptr v3, __ptr ptr, v4 - store v2 to v5, !2993 - v6 = const u64 1 - v7 = get_elem_ptr v3, __ptr u64, v6 - v8 = const u64 11 - store v8 to v7, !2993 - v9 = get_local __ptr slice, __anon_1, !2993 - mem_copy_bytes v9, v3, 16 - v10 = get_local __ptr [u64; 64], __anon_2, !2994 - v11 = const u64 0 - br array_init_loop(v11) - - array_init_loop(v12: u64): - v13 = get_elem_ptr v10, __ptr u64, v12 - v14 = const u64 0, !2995 - store v14 to v13, !2994 - v15 = const u64 1 - v16 = add v12, v15 - v17 = const u64 64 - v18 = cmp lt v16 v17 - cbr v18, array_init_loop(v16), array_init_exit() - - array_init_exit(): - v19 = get_local __ptr b256, __const - v20 = get_local __ptr { [u64; 64] }, __anon_3 - v21 = const u64 0 - v22 = get_elem_ptr v20, __ptr [u64; 64], v21 - mem_copy_val v22, v10 - v23 = get_local __ptr b256, contract_id_, !2996 - mem_copy_val v23, v0 - v24 = get_local __ptr slice, method_name_, !2996 - mem_copy_val v24, v9 - v25 = get_local __ptr { [u64; 64] }, args_, !2996 - mem_copy_val v25, v20 - v26 = get_local __ptr b256, asset_id_, !2996 - mem_copy_val v26, v19 - v27 = get_local __ptr slice, method_name_, !2997 - v28 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v28, v27 - v29 = get_local __ptr slice, __ret_val15 - v30 = call encode_208(v28, v29) - v31 = get_local __ptr slice, first_parameter, !2998 - mem_copy_val v31, v29 - v32 = get_local __ptr { [u64; 64] }, args_, !2999 - v33 = get_local __ptr { [u64; 64] }, item_, !3000 - mem_copy_val v33, v32 - v34 = get_local __ptr { [u64; 64] }, item_, !3001 - v35 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v36 = call new_21(v35) - v37 = get_local __ptr { [u64; 64] }, self_, !3002 - mem_copy_val v37, v34 - v38 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3003 - mem_copy_val v38, v35 - v39 = get_local __ptr { [u64; 64] }, self_, !3004 - v40 = const u64 0 - v41 = get_elem_ptr v39, __ptr [u64; 64], v40, !3005 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3006 - v43 = get_local __ptr [u64; 64], __tmp_arg8 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v44, v42 - v45 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v46 = call abi_encode_55(v43, v44, v45) - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3007 - mem_copy_val v47, v45 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3008 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3009 - mem_copy_val v49, v48 - v50 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3010 - v51 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, __ret_val8 - v53 = call as_raw_slice_22(v51, v52) - v54 = get_local __ptr slice, second_parameter, !3011 - mem_copy_val v54, v52 - v55 = get_local __ptr b256, contract_id_, !3012 - v56 = get_local __ptr slice, first_parameter, !3013 - v57 = get_local __ptr slice, self_0, !3014 - mem_copy_val v57, v56 - v58 = get_local __ptr slice, self_0, !3015 - v59 = get_local __ptr slice, slice_, !3016 - mem_copy_val v59, v58 - v60 = get_local __ptr slice, slice_, !3017 - v61 = asm(ptr: v60) -> __ptr { ptr, u64 } ptr { - } - v62 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v62, v61 - v63 = get_local __ptr { ptr, u64 }, __anon_01, !3014 - mem_copy_val v63, v62 - v64 = const u64 0 - v65 = get_elem_ptr v63, __ptr ptr, v64, !3018 - v66 = load v65, !3014 - v67 = asm(a: v66) -> u64 a, !3019 { - } - v68 = get_local __ptr slice, second_parameter, !3020 - v69 = get_local __ptr slice, self_1, !3021 - mem_copy_val v69, v68 - v70 = get_local __ptr slice, self_1, !3022 - v71 = get_local __ptr slice, slice_0, !3023 - mem_copy_val v71, v70 - v72 = get_local __ptr slice, slice_0, !3024 - v73 = asm(ptr: v72) -> __ptr { ptr, u64 } ptr { - } - v74 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v74, v73 - v75 = get_local __ptr { ptr, u64 }, __anon_02, !3021 - mem_copy_val v75, v74 - v76 = get_elem_ptr v75, __ptr ptr, v64, !3025 - v77 = load v76, !3021 - v78 = asm(a: v77) -> u64 a, !3026 { - } - v79 = get_local __ptr { b256, u64, u64 }, __anon_00, !3027 - v80 = const u64 0 - v81 = get_elem_ptr v79, __ptr b256, v80, !3028 - mem_copy_val v81, v55 - v82 = const u64 1 - v83 = get_elem_ptr v79, __ptr u64, v82, !3029 - store v67 to v83, !3030 - v84 = const u64 2 - v85 = get_elem_ptr v79, __ptr u64, v84, !3031 - store v78 to v85, !3032 - v86 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v86, v79 - v87 = get_local __ptr slice, __ret_val16 - v88 = call encode_212(v86, v87) - v89 = get_local __ptr slice, params, !3033 - mem_copy_val v89, v87 - v90 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v91 = call new_21(v90) - v92 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v92, v90 - v93 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v94 = const u64 100, !1772 - v95 = call abi_encode_20(v94, v92, v93) - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3034 - mem_copy_val v96, v93 - v97 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3035 - v98 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v98, v97 - v99 = get_local __ptr slice, __ret_val9 - v100 = call as_raw_slice_22(v98, v99) - v101 = get_local __ptr slice, __log_arg - mem_copy_val v101, v99 - v102 = const u64 1515152261580153489 - log __ptr slice v101, v102 - v103 = get_local __ptr slice, params, !3036 - v104 = get_local __ptr slice, self_2, !3037 - mem_copy_val v104, v103 - v105 = get_local __ptr slice, self_2, !3038 - v106 = get_local __ptr slice, slice_1, !3039 - mem_copy_val v106, v105 - v107 = get_local __ptr slice, slice_1, !3040 - v108 = asm(ptr: v107) -> __ptr { ptr, u64 } ptr { - } - v109 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v109, v108 - v110 = get_local __ptr { ptr, u64 }, __anon_03, !3037 - mem_copy_val v110, v109 - v111 = get_elem_ptr v110, __ptr ptr, v64, !3041 - v112 = load v111, !3037 - v113 = get_local __ptr b256, asset_id_, !3042 - v114 = get_local __ptr b256, __anon_10, !2996 - mem_copy_val v114, v113 - v115 = get_local __ptr b256, __anon_10, !2996 - v116 = const u64 0 - v117 = const u64 18446744073709551615 - v118 = contract_call __ptr () v112, v116, v115, v117, !3043 - v119 = asm() -> ptr ret, !3044 { - } - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v121 = call new_21(v120) - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v122, v120 - v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v124 = const u64 101, !1790 - v125 = call abi_encode_20(v124, v122, v123) - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3045 - mem_copy_val v126, v123 - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3046 - v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v128, v127 - v129 = get_local __ptr slice, __ret_val10 - v130 = call as_raw_slice_22(v128, v129) - v131 = get_local __ptr slice, __log_arg0 - mem_copy_val v131, v129 - v132 = const u64 1515152261580153489 - log __ptr slice v131, v132 - v133 = get_local __ptr { ptr }, __anon_000, !3047 - v134 = const u64 0 - v135 = get_elem_ptr v133, __ptr ptr, v134, !3048 - store v119 to v135, !3049 - v136 = get_local __ptr { ptr }, buffer, !3050 - mem_copy_val v136, v133 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v141 = const u64 102, !1801 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3051 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3052 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val11 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg1 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = get_local __ptr { ptr }, buffer, !3053 - v151 = get_local __ptr [u64; 64], __ret_val13 - v152 = call abi_decode_52(v150, v151) - v153 = get_local __ptr [u64; 64], r, !3054 - mem_copy_val v153, v151 - v154 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v155 = call new_21(v154) - v156 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v156, v154 - v157 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v158 = const u64 103, !1814 - v159 = call abi_encode_20(v158, v156, v157) - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3055 - mem_copy_val v160, v157 - v161 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3056 - v162 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v162, v161 - v163 = get_local __ptr slice, __ret_val12 - v164 = call as_raw_slice_22(v162, v163) - v165 = get_local __ptr slice, __log_arg2 - mem_copy_val v165, v163 - v166 = const u64 1515152261580153489 - log __ptr slice v165, v166 - v167 = get_local __ptr [u64; 64], r, !3057 - v168 = get_local __ptr [u64; 64], _, !3058 - mem_copy_val v168, v167 - v169 = const unit () - ret () v169 - } - - entry fn cost_of_in_tuple_0() -> (), !3062 { - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { () } __anon_2 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local slice __ret_val14 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local slice __tmp_arg8 - local { b256, u64, u64 } __tmp_arg9 - local { () } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer_0 - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { () } item_ - local slice method_name_ - local slice params - local slice second_parameter - local { () } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3063 - v2 = get_global __ptr string<10>, __const_global46 - v3 = cast_ptr v2 to ptr, !3064 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3064 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3064 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !3064 - v10 = get_local __ptr slice, __anon_1, !3064 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { () }, __anon_2 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr (), v12 - v14 = const unit (), !3065 - store v14 to v13 - v15 = get_local __ptr b256, contract_id_, !3066 - mem_copy_val v15, v1 - v16 = get_local __ptr slice, method_name_, !3066 - mem_copy_val v16, v10 - v17 = get_local __ptr { () }, args_, !3066 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, asset_id_, !3066 - mem_copy_val v18, v0 - v19 = get_local __ptr slice, method_name_, !3067 - v20 = get_local __ptr slice, __tmp_arg8 - mem_copy_val v20, v19 - v21 = get_local __ptr slice, __ret_val13 - v22 = call encode_208(v20, v21) - v23 = get_local __ptr slice, first_parameter, !3068 - mem_copy_val v23, v21 - v24 = get_local __ptr { () }, args_, !3069 - v25 = get_local __ptr { () }, item_, !3070 - mem_copy_val v25, v24 - v26 = get_local __ptr { () }, item_, !3071 - v27 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v28 = call new_21(v27) - v29 = get_local __ptr { () }, self_, !3072 - mem_copy_val v29, v26 - v30 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3073 - mem_copy_val v30, v27 - v31 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3074 - v32 = get_local __ptr { { ptr, u64, u64 } }, buffer_0, !3077 - mem_copy_val v32, v31 - v33 = get_local __ptr { { ptr, u64, u64 } }, buffer_0, !3079 - v34 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3080 - mem_copy_val v34, v33 - v35 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3081 - v36 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3082 - mem_copy_val v36, v35 - v37 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3083 - v38 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v38, v37 - v39 = get_local __ptr slice, __ret_val8 - v40 = call as_raw_slice_22(v38, v39) - v41 = get_local __ptr slice, second_parameter, !3084 - mem_copy_val v41, v39 - v42 = get_local __ptr b256, contract_id_, !3085 - v43 = get_local __ptr slice, first_parameter, !3086 - v44 = get_local __ptr slice, self_0, !3087 - mem_copy_val v44, v43 - v45 = get_local __ptr slice, self_0, !3088 - v46 = get_local __ptr slice, slice_, !3089 - mem_copy_val v46, v45 - v47 = get_local __ptr slice, slice_, !3090 - v48 = asm(ptr: v47) -> __ptr { ptr, u64 } ptr { - } - v49 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v49, v48 - v50 = get_local __ptr { ptr, u64 }, __anon_01, !3087 - mem_copy_val v50, v49 - v51 = const u64 0 - v52 = get_elem_ptr v50, __ptr ptr, v51, !3091 - v53 = load v52, !3087 - v54 = asm(a: v53) -> u64 a, !3092 { - } - v55 = get_local __ptr slice, second_parameter, !3093 - v56 = get_local __ptr slice, self_1, !3094 - mem_copy_val v56, v55 - v57 = get_local __ptr slice, self_1, !3095 - v58 = get_local __ptr slice, slice_0, !3096 - mem_copy_val v58, v57 - v59 = get_local __ptr slice, slice_0, !3097 - v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { - } - v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v61, v60 - v62 = get_local __ptr { ptr, u64 }, __anon_02, !3094 - mem_copy_val v62, v61 - v63 = get_elem_ptr v62, __ptr ptr, v51, !3098 - v64 = load v63, !3094 - v65 = asm(a: v64) -> u64 a, !3099 { - } - v66 = get_local __ptr { b256, u64, u64 }, __anon_00, !3100 - v67 = const u64 0 - v68 = get_elem_ptr v66, __ptr b256, v67, !3101 - mem_copy_val v68, v42 - v69 = const u64 1 - v70 = get_elem_ptr v66, __ptr u64, v69, !3102 - store v54 to v70, !3103 - v71 = const u64 2 - v72 = get_elem_ptr v66, __ptr u64, v71, !3104 - store v65 to v72, !3105 - v73 = get_local __ptr { b256, u64, u64 }, __tmp_arg9 - mem_copy_val v73, v66 - v74 = get_local __ptr slice, __ret_val14 - v75 = call encode_212(v73, v74) - v76 = get_local __ptr slice, params, !3106 - mem_copy_val v76, v74 - v77 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v78 = call new_21(v77) - v79 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v79, v77 - v80 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v81 = const u64 100, !1772 - v82 = call abi_encode_20(v81, v79, v80) - v83 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3107 - mem_copy_val v83, v80 - v84 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3108 - v85 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v85, v84 - v86 = get_local __ptr slice, __ret_val9 - v87 = call as_raw_slice_22(v85, v86) - v88 = get_local __ptr slice, __log_arg - mem_copy_val v88, v86 - v89 = const u64 1515152261580153489 - log __ptr slice v88, v89 - v90 = get_local __ptr slice, params, !3109 - v91 = get_local __ptr slice, self_2, !3110 - mem_copy_val v91, v90 - v92 = get_local __ptr slice, self_2, !3111 - v93 = get_local __ptr slice, slice_1, !3112 - mem_copy_val v93, v92 - v94 = get_local __ptr slice, slice_1, !3113 - v95 = asm(ptr: v94) -> __ptr { ptr, u64 } ptr { - } - v96 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v96, v95 - v97 = get_local __ptr { ptr, u64 }, __anon_03, !3110 - mem_copy_val v97, v96 - v98 = get_elem_ptr v97, __ptr ptr, v51, !3114 - v99 = load v98, !3110 - v100 = get_local __ptr b256, asset_id_, !3115 - v101 = get_local __ptr b256, __anon_10, !3066 - mem_copy_val v101, v100 - v102 = get_local __ptr b256, __anon_10, !3066 - v103 = const u64 0 - v104 = const u64 18446744073709551615 - v105 = contract_call __ptr () v99, v103, v102, v104, !3116 - v106 = asm() -> ptr ret, !3117 { - } - v107 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v108 = call new_21(v107) - v109 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v109, v107 - v110 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v111 = const u64 101, !1790 - v112 = call abi_encode_20(v111, v109, v110) - v113 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3118 - mem_copy_val v113, v110 - v114 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3119 - v115 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v115, v114 - v116 = get_local __ptr slice, __ret_val10 - v117 = call as_raw_slice_22(v115, v116) - v118 = get_local __ptr slice, __log_arg0 - mem_copy_val v118, v116 - v119 = const u64 1515152261580153489 - log __ptr slice v118, v119 - v120 = get_local __ptr { ptr }, __anon_000, !3120 - v121 = const u64 0 - v122 = get_elem_ptr v120, __ptr ptr, v121, !3121 - store v106 to v122, !3122 - v123 = get_local __ptr { ptr }, buffer, !3123 - mem_copy_val v123, v120 - v124 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v125 = call new_21(v124) - v126 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v126, v124 - v127 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v128 = const u64 102, !1801 - v129 = call abi_encode_20(v128, v126, v127) - v130 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3124 - mem_copy_val v130, v127 - v131 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3125 - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v132, v131 - v133 = get_local __ptr slice, __ret_val11 - v134 = call as_raw_slice_22(v132, v133) - v135 = get_local __ptr slice, __log_arg1 - mem_copy_val v135, v133 - v136 = const u64 1515152261580153489 - log __ptr slice v135, v136 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v141 = const u64 103, !1814 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3126 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3127 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val12 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg2 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = const unit () - ret () v150 - } - - entry fn cost_of_in_tuple_1() -> (), !3131 { - local { u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local { ptr, u64 } __anon_04 - local slice __anon_1 - local b256 __anon_10 - local { u64 } __anon_2 - local { { u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local slice __tmp_arg7 - local { b256, u64, u64 } __tmp_arg8 - local { { u64 } } __tmp_arg9 - local { { u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local b256 contract_id_ - local slice first_parameter - local slice method_name_ - local slice params - local { u64 } r - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3132 - v2 = get_global __ptr string<10>, __const_global47 - v3 = cast_ptr v2 to ptr, !3133 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3133 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3133 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !3133 - v10 = get_local __ptr slice, __anon_1, !3133 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64 }, __anon_2, !3134 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !3134 - v14 = const u64 0, !3135 - store v14 to v13, !3134 - v15 = get_local __ptr { { u64 } }, __anon_3 - v16 = const u64 0 - v17 = get_elem_ptr v15, __ptr { u64 }, v16 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, contract_id_, !3136 - mem_copy_val v18, v1 - v19 = get_local __ptr slice, method_name_, !3136 - mem_copy_val v19, v10 - v20 = get_local __ptr { { u64 } }, args_, !3136 - mem_copy_val v20, v15 - v21 = get_local __ptr b256, asset_id_, !3136 - mem_copy_val v21, v0 - v22 = get_local __ptr slice, method_name_, !3137 - v23 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v23, v22 - v24 = get_local __ptr slice, __ret_val11 - v25 = call encode_208(v23, v24) - v26 = get_local __ptr slice, first_parameter, !3138 - mem_copy_val v26, v24 - v27 = get_local __ptr { { u64 } }, args_, !3139 - v28 = get_local __ptr { { u64 } }, __tmp_arg9 - mem_copy_val v28, v27 - v29 = get_local __ptr slice, __ret_val13 - v30 = call encode_281(v28, v29) - v31 = get_local __ptr slice, second_parameter, !3140 - mem_copy_val v31, v29 - v32 = get_local __ptr b256, contract_id_, !3141 - v33 = get_local __ptr slice, first_parameter, !3142 - v34 = get_local __ptr slice, self_, !3143 - mem_copy_val v34, v33 - v35 = get_local __ptr slice, self_, !3144 - v36 = get_local __ptr slice, slice_, !3145 - mem_copy_val v36, v35 - v37 = get_local __ptr slice, slice_, !3146 - v38 = asm(ptr: v37) -> __ptr { ptr, u64 } ptr { - } - v39 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v39, v38 - v40 = get_local __ptr { ptr, u64 }, __anon_02, !3143 - mem_copy_val v40, v39 - v41 = const u64 0 - v42 = get_elem_ptr v40, __ptr ptr, v41, !3147 - v43 = load v42, !3143 - v44 = asm(a: v43) -> u64 a, !3148 { - } - v45 = get_local __ptr slice, second_parameter, !3149 - v46 = get_local __ptr slice, self_0, !3150 - mem_copy_val v46, v45 - v47 = get_local __ptr slice, self_0, !3151 - v48 = get_local __ptr slice, slice_0, !3152 - mem_copy_val v48, v47 - v49 = get_local __ptr slice, slice_0, !3153 - v50 = asm(ptr: v49) -> __ptr { ptr, u64 } ptr { - } - v51 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v51, v50 - v52 = get_local __ptr { ptr, u64 }, __anon_03, !3150 - mem_copy_val v52, v51 - v53 = get_elem_ptr v52, __ptr ptr, v41, !3154 - v54 = load v53, !3150 - v55 = asm(a: v54) -> u64 a, !3155 { - } - v56 = get_local __ptr { b256, u64, u64 }, __anon_00, !3156 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr b256, v57, !3157 - mem_copy_val v58, v32 - v59 = const u64 1 - v60 = get_elem_ptr v56, __ptr u64, v59, !3158 - store v44 to v60, !3159 - v61 = const u64 2 - v62 = get_elem_ptr v56, __ptr u64, v61, !3160 - store v55 to v62, !3161 - v63 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 - mem_copy_val v63, v56 - v64 = get_local __ptr slice, __ret_val12 - v65 = call encode_212(v63, v64) - v66 = get_local __ptr slice, params, !3162 - mem_copy_val v66, v64 - v67 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v68 = call new_21(v67) - v69 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v69, v67 - v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v71 = const u64 100, !1772 - v72 = call abi_encode_20(v71, v69, v70) - v73 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3163 - mem_copy_val v73, v70 - v74 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3164 - v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v75, v74 - v76 = get_local __ptr slice, __ret_val7 - v77 = call as_raw_slice_22(v75, v76) - v78 = get_local __ptr slice, __log_arg - mem_copy_val v78, v76 - v79 = const u64 1515152261580153489 - log __ptr slice v78, v79 - v80 = get_local __ptr slice, params, !3165 - v81 = get_local __ptr slice, self_1, !3166 - mem_copy_val v81, v80 - v82 = get_local __ptr slice, self_1, !3167 - v83 = get_local __ptr slice, slice_1, !3168 - mem_copy_val v83, v82 - v84 = get_local __ptr slice, slice_1, !3169 - v85 = asm(ptr: v84) -> __ptr { ptr, u64 } ptr { - } - v86 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v86, v85 - v87 = get_local __ptr { ptr, u64 }, __anon_04, !3166 - mem_copy_val v87, v86 - v88 = get_elem_ptr v87, __ptr ptr, v41, !3170 - v89 = load v88, !3166 - v90 = get_local __ptr b256, asset_id_, !3171 - v91 = get_local __ptr b256, __anon_10, !3136 - mem_copy_val v91, v90 - v92 = get_local __ptr b256, __anon_10, !3136 - v93 = const u64 0 - v94 = const u64 18446744073709551615 - v95 = contract_call __ptr () v89, v93, v92, v94, !3172 - v96 = asm() -> ptr ret, !3173 { - } - v97 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v98 = call new_21(v97) - v99 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v99, v97 - v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v101 = const u64 101, !1790 - v102 = call abi_encode_20(v101, v99, v100) - v103 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3174 - mem_copy_val v103, v100 - v104 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3175 - v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v105, v104 - v106 = get_local __ptr slice, __ret_val8 - v107 = call as_raw_slice_22(v105, v106) - v108 = get_local __ptr slice, __log_arg0 - mem_copy_val v108, v106 - v109 = const u64 1515152261580153489 - log __ptr slice v108, v109 - v110 = get_local __ptr { ptr }, __anon_000, !3176 - v111 = const u64 0 - v112 = get_elem_ptr v110, __ptr ptr, v111, !3177 - store v96 to v112, !3178 - v113 = get_local __ptr { ptr }, buffer, !3179 - mem_copy_val v113, v110 - v114 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v115 = call new_21(v114) - v116 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v116, v114 - v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v118 = const u64 102, !1801 - v119 = call abi_encode_20(v118, v116, v117) - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3180 - mem_copy_val v120, v117 - v121 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3181 - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v122, v121 - v123 = get_local __ptr slice, __ret_val9 - v124 = call as_raw_slice_22(v122, v123) - v125 = get_local __ptr slice, __log_arg1 - mem_copy_val v125, v123 - v126 = const u64 1515152261580153489 - log __ptr slice v125, v126 - v127 = get_local __ptr { ptr }, buffer, !3182 - v128 = const u64 0 - v129 = get_elem_ptr v127, __ptr ptr, v128, !3183 - v130 = load v129, !3184 - v131 = asm(ptr: v130, val) -> u64 val, !3185 { - lw val ptr i0, !58 - } - v132 = load v129, !3184 - v133 = const u64 8, !3184 - v134 = add v132, v133, !3184 - store v134 to v129, !3186 - v135 = get_local __ptr { u64 }, __anon_01, !3187 - v136 = const u64 0 - v137 = get_elem_ptr v135, __ptr u64, v136, !3188 - store v131 to v137, !3189 - v138 = get_local __ptr { u64 }, r, !3190 - mem_copy_val v138, v135 - v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v140 = call new_21(v139) - v141 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v141, v139 - v142 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v143 = const u64 103, !1814 - v144 = call abi_encode_20(v143, v141, v142) - v145 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3191 - mem_copy_val v145, v142 - v146 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3192 - v147 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v147, v146 - v148 = get_local __ptr slice, __ret_val10 - v149 = call as_raw_slice_22(v147, v148) - v150 = get_local __ptr slice, __log_arg2 - mem_copy_val v150, v148 - v151 = const u64 1515152261580153489 - log __ptr slice v150, v151 - v152 = get_local __ptr { u64 }, r, !3193 - v153 = get_local __ptr { u64 }, _, !3194 - mem_copy_val v153, v152 - v154 = const unit () - ret () v154 - } - - entry fn cost_of_in_tuple_2() -> (), !3198 { - local { u64, u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, u64 } __anon_2 - local { { u64, u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local { u64, u64 } __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local slice __ret_val14 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local slice __tmp_arg7 - local { b256, u64, u64 } __tmp_arg8 - local { { u64, u64 } } __tmp_arg9 - local { { u64, u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local b256 contract_id_ - local slice first_parameter - local slice method_name_ - local slice params - local { u64, u64 } r - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3199 - v2 = get_global __ptr string<10>, __const_global48 - v3 = cast_ptr v2 to ptr, !3200 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3200 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3200 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !3200 - v10 = get_local __ptr slice, __anon_1, !3200 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, u64 }, __anon_2, !3201 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !3201 - v14 = const u64 0, !3202 - store v14 to v13, !3201 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15, !3201 - v17 = const u64 0, !3203 - store v17 to v16, !3201 - v18 = get_local __ptr { { u64, u64 } }, __anon_3 - v19 = const u64 0 - v20 = get_elem_ptr v18, __ptr { u64, u64 }, v19 - mem_copy_val v20, v11 - v21 = get_local __ptr b256, contract_id_, !3204 - mem_copy_val v21, v1 - v22 = get_local __ptr slice, method_name_, !3204 - mem_copy_val v22, v10 - v23 = get_local __ptr { { u64, u64 } }, args_, !3204 - mem_copy_val v23, v18 - v24 = get_local __ptr b256, asset_id_, !3204 - mem_copy_val v24, v0 - v25 = get_local __ptr slice, method_name_, !3205 - v26 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v26, v25 - v27 = get_local __ptr slice, __ret_val12 - v28 = call encode_208(v26, v27) - v29 = get_local __ptr slice, first_parameter, !3206 - mem_copy_val v29, v27 - v30 = get_local __ptr { { u64, u64 } }, args_, !3207 - v31 = get_local __ptr { { u64, u64 } }, __tmp_arg9 - mem_copy_val v31, v30 - v32 = get_local __ptr slice, __ret_val14 - v33 = call encode_284(v31, v32) - v34 = get_local __ptr slice, second_parameter, !3208 - mem_copy_val v34, v32 - v35 = get_local __ptr b256, contract_id_, !3209 - v36 = get_local __ptr slice, first_parameter, !3210 - v37 = get_local __ptr slice, self_, !3211 - mem_copy_val v37, v36 - v38 = get_local __ptr slice, self_, !3212 - v39 = get_local __ptr slice, slice_, !3213 - mem_copy_val v39, v38 - v40 = get_local __ptr slice, slice_, !3214 - v41 = asm(ptr: v40) -> __ptr { ptr, u64 } ptr { - } - v42 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v42, v41 - v43 = get_local __ptr { ptr, u64 }, __anon_01, !3211 - mem_copy_val v43, v42 - v44 = const u64 0 - v45 = get_elem_ptr v43, __ptr ptr, v44, !3215 - v46 = load v45, !3211 - v47 = asm(a: v46) -> u64 a, !3216 { - } - v48 = get_local __ptr slice, second_parameter, !3217 - v49 = get_local __ptr slice, self_0, !3218 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !3219 - v51 = get_local __ptr slice, slice_0, !3220 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_0, !3221 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_02, !3218 - mem_copy_val v55, v54 - v56 = get_elem_ptr v55, __ptr ptr, v44, !3222 - v57 = load v56, !3218 - v58 = asm(a: v57) -> u64 a, !3223 { - } - v59 = get_local __ptr { b256, u64, u64 }, __anon_00, !3224 - v60 = const u64 0 - v61 = get_elem_ptr v59, __ptr b256, v60, !3225 - mem_copy_val v61, v35 - v62 = const u64 1 - v63 = get_elem_ptr v59, __ptr u64, v62, !3226 - store v47 to v63, !3227 - v64 = const u64 2 - v65 = get_elem_ptr v59, __ptr u64, v64, !3228 - store v58 to v65, !3229 - v66 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 - mem_copy_val v66, v59 - v67 = get_local __ptr slice, __ret_val13 - v68 = call encode_212(v66, v67) - v69 = get_local __ptr slice, params, !3230 - mem_copy_val v69, v67 - v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v71 = call new_21(v70) - v72 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v72, v70 - v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v74 = const u64 100, !1772 - v75 = call abi_encode_20(v74, v72, v73) - v76 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3231 - mem_copy_val v76, v73 - v77 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3232 - v78 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v78, v77 - v79 = get_local __ptr slice, __ret_val7 - v80 = call as_raw_slice_22(v78, v79) - v81 = get_local __ptr slice, __log_arg - mem_copy_val v81, v79 - v82 = const u64 1515152261580153489 - log __ptr slice v81, v82 - v83 = get_local __ptr slice, params, !3233 - v84 = get_local __ptr slice, self_1, !3234 - mem_copy_val v84, v83 - v85 = get_local __ptr slice, self_1, !3235 - v86 = get_local __ptr slice, slice_1, !3236 - mem_copy_val v86, v85 - v87 = get_local __ptr slice, slice_1, !3237 - v88 = asm(ptr: v87) -> __ptr { ptr, u64 } ptr { - } - v89 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v89, v88 - v90 = get_local __ptr { ptr, u64 }, __anon_03, !3234 - mem_copy_val v90, v89 - v91 = get_elem_ptr v90, __ptr ptr, v44, !3238 - v92 = load v91, !3234 - v93 = get_local __ptr b256, asset_id_, !3239 - v94 = get_local __ptr b256, __anon_10, !3204 - mem_copy_val v94, v93 - v95 = get_local __ptr b256, __anon_10, !3204 - v96 = const u64 0 - v97 = const u64 18446744073709551615 - v98 = contract_call __ptr () v92, v96, v95, v97, !3240 - v99 = asm() -> ptr ret, !3241 { - } - v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v101 = call new_21(v100) - v102 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v102, v100 - v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v104 = const u64 101, !1790 - v105 = call abi_encode_20(v104, v102, v103) - v106 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3242 - mem_copy_val v106, v103 - v107 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3243 - v108 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v108, v107 - v109 = get_local __ptr slice, __ret_val8 - v110 = call as_raw_slice_22(v108, v109) - v111 = get_local __ptr slice, __log_arg0 - mem_copy_val v111, v109 - v112 = const u64 1515152261580153489 - log __ptr slice v111, v112 - v113 = get_local __ptr { ptr }, __anon_000, !3244 - v114 = const u64 0 - v115 = get_elem_ptr v113, __ptr ptr, v114, !3245 - store v99 to v115, !3246 - v116 = get_local __ptr { ptr }, buffer, !3247 - mem_copy_val v116, v113 - v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v118 = call new_21(v117) - v119 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v119, v117 - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v121 = const u64 102, !1801 - v122 = call abi_encode_20(v121, v119, v120) - v123 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3248 - mem_copy_val v123, v120 - v124 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3249 - v125 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v125, v124 - v126 = get_local __ptr slice, __ret_val9 - v127 = call as_raw_slice_22(v125, v126) - v128 = get_local __ptr slice, __log_arg1 - mem_copy_val v128, v126 - v129 = const u64 1515152261580153489 - log __ptr slice v128, v129 - v130 = get_local __ptr { ptr }, buffer, !3250 - v131 = get_local __ptr { u64, u64 }, __ret_val11 - v132 = call abi_decode_134(v130, v131) - v133 = get_local __ptr { u64, u64 }, r, !3251 - mem_copy_val v133, v131 - v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v135 = call new_21(v134) - v136 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v136, v134 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v138 = const u64 103, !1814 - v139 = call abi_encode_20(v138, v136, v137) - v140 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3252 - mem_copy_val v140, v137 - v141 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3253 - v142 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v142, v141 - v143 = get_local __ptr slice, __ret_val10 - v144 = call as_raw_slice_22(v142, v143) - v145 = get_local __ptr slice, __log_arg2 - mem_copy_val v145, v143 - v146 = const u64 1515152261580153489 - log __ptr slice v145, v146 - v147 = get_local __ptr { u64, u64 }, r, !3254 - v148 = get_local __ptr { u64, u64 }, _, !3255 - mem_copy_val v148, v147 - v149 = const unit () - ret () v149 - } - - entry fn cost_of_in_tuple_3() -> (), !3259 { - local { u64, u64, u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, u64, u64 } __anon_2 - local { { u64, u64, u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local { u64, u64, u64 } __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local slice __ret_val14 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local slice __tmp_arg7 - local { b256, u64, u64 } __tmp_arg8 - local { { u64, u64, u64 } } __tmp_arg9 - local { { u64, u64, u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local b256 contract_id_ - local slice first_parameter - local slice method_name_ - local slice params - local { u64, u64, u64 } r - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3260 - v2 = get_global __ptr string<10>, __const_global49 - v3 = cast_ptr v2 to ptr, !3261 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3261 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3261 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !3261 - v10 = get_local __ptr slice, __anon_1, !3261 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, u64, u64 }, __anon_2, !3262 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !3262 - v14 = const u64 0, !3263 - store v14 to v13, !3262 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15, !3262 - v17 = const u64 0, !3264 - store v17 to v16, !3262 - v18 = const u64 2 - v19 = get_elem_ptr v11, __ptr u64, v18, !3262 - v20 = const u64 0, !3265 - store v20 to v19, !3262 - v21 = get_local __ptr { { u64, u64, u64 } }, __anon_3 - v22 = const u64 0 - v23 = get_elem_ptr v21, __ptr { u64, u64, u64 }, v22 - mem_copy_val v23, v11 - v24 = get_local __ptr b256, contract_id_, !3266 - mem_copy_val v24, v1 - v25 = get_local __ptr slice, method_name_, !3266 - mem_copy_val v25, v10 - v26 = get_local __ptr { { u64, u64, u64 } }, args_, !3266 - mem_copy_val v26, v21 - v27 = get_local __ptr b256, asset_id_, !3266 - mem_copy_val v27, v0 - v28 = get_local __ptr slice, method_name_, !3267 - v29 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v29, v28 - v30 = get_local __ptr slice, __ret_val12 - v31 = call encode_208(v29, v30) - v32 = get_local __ptr slice, first_parameter, !3268 - mem_copy_val v32, v30 - v33 = get_local __ptr { { u64, u64, u64 } }, args_, !3269 - v34 = get_local __ptr { { u64, u64, u64 } }, __tmp_arg9 - mem_copy_val v34, v33 - v35 = get_local __ptr slice, __ret_val14 - v36 = call encode_287(v34, v35) - v37 = get_local __ptr slice, second_parameter, !3270 - mem_copy_val v37, v35 - v38 = get_local __ptr b256, contract_id_, !3271 - v39 = get_local __ptr slice, first_parameter, !3272 - v40 = get_local __ptr slice, self_, !3273 - mem_copy_val v40, v39 - v41 = get_local __ptr slice, self_, !3274 - v42 = get_local __ptr slice, slice_, !3275 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, slice_, !3276 - v44 = asm(ptr: v43) -> __ptr { ptr, u64 } ptr { - } - v45 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v45, v44 - v46 = get_local __ptr { ptr, u64 }, __anon_01, !3273 - mem_copy_val v46, v45 - v47 = const u64 0 - v48 = get_elem_ptr v46, __ptr ptr, v47, !3277 - v49 = load v48, !3273 - v50 = asm(a: v49) -> u64 a, !3278 { - } - v51 = get_local __ptr slice, second_parameter, !3279 - v52 = get_local __ptr slice, self_0, !3280 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, self_0, !3281 - v54 = get_local __ptr slice, slice_0, !3282 - mem_copy_val v54, v53 - v55 = get_local __ptr slice, slice_0, !3283 - v56 = asm(ptr: v55) -> __ptr { ptr, u64 } ptr { - } - v57 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v57, v56 - v58 = get_local __ptr { ptr, u64 }, __anon_02, !3280 - mem_copy_val v58, v57 - v59 = get_elem_ptr v58, __ptr ptr, v47, !3284 - v60 = load v59, !3280 - v61 = asm(a: v60) -> u64 a, !3285 { - } - v62 = get_local __ptr { b256, u64, u64 }, __anon_00, !3286 - v63 = const u64 0 - v64 = get_elem_ptr v62, __ptr b256, v63, !3287 - mem_copy_val v64, v38 - v65 = const u64 1 - v66 = get_elem_ptr v62, __ptr u64, v65, !3288 - store v50 to v66, !3289 - v67 = const u64 2 - v68 = get_elem_ptr v62, __ptr u64, v67, !3290 - store v61 to v68, !3291 - v69 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 - mem_copy_val v69, v62 - v70 = get_local __ptr slice, __ret_val13 - v71 = call encode_212(v69, v70) - v72 = get_local __ptr slice, params, !3292 - mem_copy_val v72, v70 - v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v74 = call new_21(v73) - v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v75, v73 - v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v77 = const u64 100, !1772 - v78 = call abi_encode_20(v77, v75, v76) - v79 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3293 - mem_copy_val v79, v76 - v80 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3294 - v81 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v81, v80 - v82 = get_local __ptr slice, __ret_val7 - v83 = call as_raw_slice_22(v81, v82) - v84 = get_local __ptr slice, __log_arg - mem_copy_val v84, v82 - v85 = const u64 1515152261580153489 - log __ptr slice v84, v85 - v86 = get_local __ptr slice, params, !3295 - v87 = get_local __ptr slice, self_1, !3296 - mem_copy_val v87, v86 - v88 = get_local __ptr slice, self_1, !3297 - v89 = get_local __ptr slice, slice_1, !3298 - mem_copy_val v89, v88 - v90 = get_local __ptr slice, slice_1, !3299 - v91 = asm(ptr: v90) -> __ptr { ptr, u64 } ptr { - } - v92 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v92, v91 - v93 = get_local __ptr { ptr, u64 }, __anon_03, !3296 - mem_copy_val v93, v92 - v94 = get_elem_ptr v93, __ptr ptr, v47, !3300 - v95 = load v94, !3296 - v96 = get_local __ptr b256, asset_id_, !3301 - v97 = get_local __ptr b256, __anon_10, !3266 - mem_copy_val v97, v96 - v98 = get_local __ptr b256, __anon_10, !3266 - v99 = const u64 0 - v100 = const u64 18446744073709551615 - v101 = contract_call __ptr () v95, v99, v98, v100, !3302 - v102 = asm() -> ptr ret, !3303 { - } - v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v104 = call new_21(v103) - v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v105, v103 - v106 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v107 = const u64 101, !1790 - v108 = call abi_encode_20(v107, v105, v106) - v109 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3304 - mem_copy_val v109, v106 - v110 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3305 - v111 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v111, v110 - v112 = get_local __ptr slice, __ret_val8 - v113 = call as_raw_slice_22(v111, v112) - v114 = get_local __ptr slice, __log_arg0 - mem_copy_val v114, v112 - v115 = const u64 1515152261580153489 - log __ptr slice v114, v115 - v116 = get_local __ptr { ptr }, __anon_000, !3306 - v117 = const u64 0 - v118 = get_elem_ptr v116, __ptr ptr, v117, !3307 - store v102 to v118, !3308 - v119 = get_local __ptr { ptr }, buffer, !3309 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v121 = call new_21(v120) - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v122, v120 - v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v124 = const u64 102, !1801 - v125 = call abi_encode_20(v124, v122, v123) - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3310 - mem_copy_val v126, v123 - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3311 - v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v128, v127 - v129 = get_local __ptr slice, __ret_val9 - v130 = call as_raw_slice_22(v128, v129) - v131 = get_local __ptr slice, __log_arg1 - mem_copy_val v131, v129 - v132 = const u64 1515152261580153489 - log __ptr slice v131, v132 - v133 = get_local __ptr { ptr }, buffer, !3312 - v134 = get_local __ptr { u64, u64, u64 }, __ret_val11 - v135 = call abi_decode_162(v133, v134) - v136 = get_local __ptr { u64, u64, u64 }, r, !3313 - mem_copy_val v136, v134 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v141 = const u64 103, !1814 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3314 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3315 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val10 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg2 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = get_local __ptr { u64, u64, u64 }, r, !3316 - v151 = get_local __ptr { u64, u64, u64 }, _, !3317 - mem_copy_val v151, v150 - v152 = const unit () - ret () v152 - } - - entry fn cost_of_in_tuple_4() -> (), !3321 { - local { u64, u64, u64, u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, u64, u64, u64 } __anon_2 - local { { u64, u64, u64, u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { u64, u64, u64, u64 } __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { u64, u64, u64, u64 } __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { { u64, u64, u64, u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { { u64, u64, u64, u64 } } item_ - local slice method_name_ - local slice params - local { u64, u64, u64, u64 } r - local slice second_parameter - local { { u64, u64, u64, u64 } } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3322 - v2 = get_global __ptr string<10>, __const_global50 - v3 = cast_ptr v2 to ptr, !3323 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3323 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3323 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 10 - store v9 to v8, !3323 - v10 = get_local __ptr slice, __anon_1, !3323 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, u64, u64, u64 }, __anon_2, !3324 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !3324 - v14 = const u64 0, !3325 - store v14 to v13, !3324 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15, !3324 - v17 = const u64 0, !3326 - store v17 to v16, !3324 - v18 = const u64 2 - v19 = get_elem_ptr v11, __ptr u64, v18, !3324 - v20 = const u64 0, !3327 - store v20 to v19, !3324 - v21 = const u64 3 - v22 = get_elem_ptr v11, __ptr u64, v21, !3324 - v23 = const u64 0, !3328 - store v23 to v22, !3324 - v24 = get_local __ptr { { u64, u64, u64, u64 } }, __anon_3 - v25 = const u64 0 - v26 = get_elem_ptr v24, __ptr { u64, u64, u64, u64 }, v25 - mem_copy_val v26, v11 - v27 = get_local __ptr b256, contract_id_, !3329 - mem_copy_val v27, v1 - v28 = get_local __ptr slice, method_name_, !3329 - mem_copy_val v28, v10 - v29 = get_local __ptr { { u64, u64, u64, u64 } }, args_, !3329 - mem_copy_val v29, v24 - v30 = get_local __ptr b256, asset_id_, !3329 - mem_copy_val v30, v0 - v31 = get_local __ptr slice, method_name_, !3330 - v32 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v32, v31 - v33 = get_local __ptr slice, __ret_val15 - v34 = call encode_208(v32, v33) - v35 = get_local __ptr slice, first_parameter, !3331 - mem_copy_val v35, v33 - v36 = get_local __ptr { { u64, u64, u64, u64 } }, args_, !3332 - v37 = get_local __ptr { { u64, u64, u64, u64 } }, item_, !3333 - mem_copy_val v37, v36 - v38 = get_local __ptr { { u64, u64, u64, u64 } }, item_, !3334 - v39 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v40 = call new_21(v39) - v41 = get_local __ptr { { u64, u64, u64, u64 } }, self_, !3335 - mem_copy_val v41, v38 - v42 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3336 - mem_copy_val v42, v39 - v43 = get_local __ptr { { u64, u64, u64, u64 } }, self_, !3337 - v44 = const u64 0 - v45 = get_elem_ptr v43, __ptr { u64, u64, u64, u64 }, v44, !3338 - v46 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3339 - v47 = get_local __ptr { u64, u64, u64, u64 }, __tmp_arg8 - mem_copy_val v47, v45 - v48 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v48, v46 - v49 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v50 = call abi_encode_171(v47, v48, v49) - v51 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3340 - mem_copy_val v51, v49 - v52 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3341 - v53 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3342 - mem_copy_val v53, v52 - v54 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3343 - v55 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v55, v54 - v56 = get_local __ptr slice, __ret_val8 - v57 = call as_raw_slice_22(v55, v56) - v58 = get_local __ptr slice, second_parameter, !3344 - mem_copy_val v58, v56 - v59 = get_local __ptr b256, contract_id_, !3345 - v60 = get_local __ptr slice, first_parameter, !3346 - v61 = get_local __ptr slice, self_0, !3347 - mem_copy_val v61, v60 - v62 = get_local __ptr slice, self_0, !3348 - v63 = get_local __ptr slice, slice_, !3349 - mem_copy_val v63, v62 - v64 = get_local __ptr slice, slice_, !3350 - v65 = asm(ptr: v64) -> __ptr { ptr, u64 } ptr { - } - v66 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v66, v65 - v67 = get_local __ptr { ptr, u64 }, __anon_01, !3347 - mem_copy_val v67, v66 - v68 = const u64 0 - v69 = get_elem_ptr v67, __ptr ptr, v68, !3351 - v70 = load v69, !3347 - v71 = asm(a: v70) -> u64 a, !3352 { - } - v72 = get_local __ptr slice, second_parameter, !3353 - v73 = get_local __ptr slice, self_1, !3354 - mem_copy_val v73, v72 - v74 = get_local __ptr slice, self_1, !3355 - v75 = get_local __ptr slice, slice_0, !3356 - mem_copy_val v75, v74 - v76 = get_local __ptr slice, slice_0, !3357 - v77 = asm(ptr: v76) -> __ptr { ptr, u64 } ptr { - } - v78 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v78, v77 - v79 = get_local __ptr { ptr, u64 }, __anon_02, !3354 - mem_copy_val v79, v78 - v80 = get_elem_ptr v79, __ptr ptr, v68, !3358 - v81 = load v80, !3354 - v82 = asm(a: v81) -> u64 a, !3359 { - } - v83 = get_local __ptr { b256, u64, u64 }, __anon_00, !3360 - v84 = const u64 0 - v85 = get_elem_ptr v83, __ptr b256, v84, !3361 - mem_copy_val v85, v59 - v86 = const u64 1 - v87 = get_elem_ptr v83, __ptr u64, v86, !3362 - store v71 to v87, !3363 - v88 = const u64 2 - v89 = get_elem_ptr v83, __ptr u64, v88, !3364 - store v82 to v89, !3365 - v90 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v90, v83 - v91 = get_local __ptr slice, __ret_val16 - v92 = call encode_212(v90, v91) - v93 = get_local __ptr slice, params, !3366 - mem_copy_val v93, v91 - v94 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v95 = call new_21(v94) - v96 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v96, v94 - v97 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v98 = const u64 100, !1772 - v99 = call abi_encode_20(v98, v96, v97) - v100 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3367 - mem_copy_val v100, v97 - v101 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3368 - v102 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v102, v101 - v103 = get_local __ptr slice, __ret_val9 - v104 = call as_raw_slice_22(v102, v103) - v105 = get_local __ptr slice, __log_arg - mem_copy_val v105, v103 - v106 = const u64 1515152261580153489 - log __ptr slice v105, v106 - v107 = get_local __ptr slice, params, !3369 - v108 = get_local __ptr slice, self_2, !3370 - mem_copy_val v108, v107 - v109 = get_local __ptr slice, self_2, !3371 - v110 = get_local __ptr slice, slice_1, !3372 - mem_copy_val v110, v109 - v111 = get_local __ptr slice, slice_1, !3373 - v112 = asm(ptr: v111) -> __ptr { ptr, u64 } ptr { - } - v113 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v113, v112 - v114 = get_local __ptr { ptr, u64 }, __anon_03, !3370 - mem_copy_val v114, v113 - v115 = get_elem_ptr v114, __ptr ptr, v68, !3374 - v116 = load v115, !3370 - v117 = get_local __ptr b256, asset_id_, !3375 - v118 = get_local __ptr b256, __anon_10, !3329 - mem_copy_val v118, v117 - v119 = get_local __ptr b256, __anon_10, !3329 - v120 = const u64 0 - v121 = const u64 18446744073709551615 - v122 = contract_call __ptr () v116, v120, v119, v121, !3376 - v123 = asm() -> ptr ret, !3377 { - } - v124 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v125 = call new_21(v124) - v126 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v126, v124 - v127 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v128 = const u64 101, !1790 - v129 = call abi_encode_20(v128, v126, v127) - v130 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3378 - mem_copy_val v130, v127 - v131 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3379 - v132 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v132, v131 - v133 = get_local __ptr slice, __ret_val10 - v134 = call as_raw_slice_22(v132, v133) - v135 = get_local __ptr slice, __log_arg0 - mem_copy_val v135, v133 - v136 = const u64 1515152261580153489 - log __ptr slice v135, v136 - v137 = get_local __ptr { ptr }, __anon_000, !3380 - v138 = const u64 0 - v139 = get_elem_ptr v137, __ptr ptr, v138, !3381 - store v123 to v139, !3382 - v140 = get_local __ptr { ptr }, buffer, !3383 - mem_copy_val v140, v137 - v141 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v142 = call new_21(v141) - v143 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v143, v141 - v144 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v145 = const u64 102, !1801 - v146 = call abi_encode_20(v145, v143, v144) - v147 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3384 - mem_copy_val v147, v144 - v148 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3385 - v149 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v149, v148 - v150 = get_local __ptr slice, __ret_val11 - v151 = call as_raw_slice_22(v149, v150) - v152 = get_local __ptr slice, __log_arg1 - mem_copy_val v152, v150 - v153 = const u64 1515152261580153489 - log __ptr slice v152, v153 - v154 = get_local __ptr { ptr }, buffer, !3386 - v155 = get_local __ptr { u64, u64, u64, u64 }, __ret_val13 - v156 = call abi_decode_168(v154, v155) - v157 = get_local __ptr { u64, u64, u64, u64 }, r, !3387 - mem_copy_val v157, v155 - v158 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v159 = call new_21(v158) - v160 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v160, v158 - v161 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v162 = const u64 103, !1814 - v163 = call abi_encode_20(v162, v160, v161) - v164 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3388 - mem_copy_val v164, v161 - v165 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3389 - v166 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v166, v165 - v167 = get_local __ptr slice, __ret_val12 - v168 = call as_raw_slice_22(v166, v167) - v169 = get_local __ptr slice, __log_arg2 - mem_copy_val v169, v167 - v170 = const u64 1515152261580153489 - log __ptr slice v169, v170 - v171 = get_local __ptr { u64, u64, u64, u64 }, r, !3390 - v172 = get_local __ptr { u64, u64, u64, u64 }, _, !3391 - mem_copy_val v172, v171 - v173 = const unit () - ret () v173 - } - - entry fn in_struct_u64() -> (), !3395 { - local { u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64 } __anon_2 - local { { u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local { u64 } __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local slice __ret_val14 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local slice __tmp_arg7 - local { b256, u64, u64 } __tmp_arg8 - local { { u64 } } __tmp_arg9 - local { { u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local b256 contract_id_ - local slice first_parameter - local slice method_name_ - local slice params - local { u64 } r - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3396 - v2 = get_global __ptr string<13>, __const_global51 - v3 = cast_ptr v2 to ptr, !3397 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3397 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3397 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 13 - store v9 to v8, !3397 - v10 = get_local __ptr slice, __anon_1, !3397 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64 }, __anon_2, !3398 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !3399 - store v14 to v13, !3398 - v15 = get_local __ptr { { u64 } }, __anon_3 - v16 = const u64 0 - v17 = get_elem_ptr v15, __ptr { u64 }, v16 - mem_copy_val v17, v11 - v18 = get_local __ptr b256, contract_id_, !3400 - mem_copy_val v18, v1 - v19 = get_local __ptr slice, method_name_, !3400 - mem_copy_val v19, v10 - v20 = get_local __ptr { { u64 } }, args_, !3400 - mem_copy_val v20, v15 - v21 = get_local __ptr b256, asset_id_, !3400 - mem_copy_val v21, v0 - v22 = get_local __ptr slice, method_name_, !3401 - v23 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v23, v22 - v24 = get_local __ptr slice, __ret_val12 - v25 = call encode_208(v23, v24) - v26 = get_local __ptr slice, first_parameter, !3402 - mem_copy_val v26, v24 - v27 = get_local __ptr { { u64 } }, args_, !3403 - v28 = get_local __ptr { { u64 } }, __tmp_arg9 - mem_copy_val v28, v27 - v29 = get_local __ptr slice, __ret_val14 - v30 = call encode_281(v28, v29) - v31 = get_local __ptr slice, second_parameter, !3404 - mem_copy_val v31, v29 - v32 = get_local __ptr b256, contract_id_, !3405 - v33 = get_local __ptr slice, first_parameter, !3406 - v34 = get_local __ptr slice, self_, !3407 - mem_copy_val v34, v33 - v35 = get_local __ptr slice, self_, !3408 - v36 = get_local __ptr slice, slice_, !3409 - mem_copy_val v36, v35 - v37 = get_local __ptr slice, slice_, !3410 - v38 = asm(ptr: v37) -> __ptr { ptr, u64 } ptr { - } - v39 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v39, v38 - v40 = get_local __ptr { ptr, u64 }, __anon_01, !3407 - mem_copy_val v40, v39 - v41 = const u64 0 - v42 = get_elem_ptr v40, __ptr ptr, v41, !3411 - v43 = load v42, !3407 - v44 = asm(a: v43) -> u64 a, !3412 { - } - v45 = get_local __ptr slice, second_parameter, !3413 - v46 = get_local __ptr slice, self_0, !3414 - mem_copy_val v46, v45 - v47 = get_local __ptr slice, self_0, !3415 - v48 = get_local __ptr slice, slice_0, !3416 - mem_copy_val v48, v47 - v49 = get_local __ptr slice, slice_0, !3417 - v50 = asm(ptr: v49) -> __ptr { ptr, u64 } ptr { - } - v51 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v51, v50 - v52 = get_local __ptr { ptr, u64 }, __anon_02, !3414 - mem_copy_val v52, v51 - v53 = get_elem_ptr v52, __ptr ptr, v41, !3418 - v54 = load v53, !3414 - v55 = asm(a: v54) -> u64 a, !3419 { - } - v56 = get_local __ptr { b256, u64, u64 }, __anon_00, !3420 - v57 = const u64 0 - v58 = get_elem_ptr v56, __ptr b256, v57, !3421 - mem_copy_val v58, v32 - v59 = const u64 1 - v60 = get_elem_ptr v56, __ptr u64, v59, !3422 - store v44 to v60, !3423 - v61 = const u64 2 - v62 = get_elem_ptr v56, __ptr u64, v61, !3424 - store v55 to v62, !3425 - v63 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 - mem_copy_val v63, v56 - v64 = get_local __ptr slice, __ret_val13 - v65 = call encode_212(v63, v64) - v66 = get_local __ptr slice, params, !3426 - mem_copy_val v66, v64 - v67 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v68 = call new_21(v67) - v69 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v69, v67 - v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v71 = const u64 100, !1772 - v72 = call abi_encode_20(v71, v69, v70) - v73 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3427 - mem_copy_val v73, v70 - v74 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3428 - v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v75, v74 - v76 = get_local __ptr slice, __ret_val7 - v77 = call as_raw_slice_22(v75, v76) - v78 = get_local __ptr slice, __log_arg - mem_copy_val v78, v76 - v79 = const u64 1515152261580153489 - log __ptr slice v78, v79 - v80 = get_local __ptr slice, params, !3429 - v81 = get_local __ptr slice, self_1, !3430 - mem_copy_val v81, v80 - v82 = get_local __ptr slice, self_1, !3431 - v83 = get_local __ptr slice, slice_1, !3432 - mem_copy_val v83, v82 - v84 = get_local __ptr slice, slice_1, !3433 - v85 = asm(ptr: v84) -> __ptr { ptr, u64 } ptr { - } - v86 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v86, v85 - v87 = get_local __ptr { ptr, u64 }, __anon_03, !3430 - mem_copy_val v87, v86 - v88 = get_elem_ptr v87, __ptr ptr, v41, !3434 - v89 = load v88, !3430 - v90 = get_local __ptr b256, asset_id_, !3435 - v91 = get_local __ptr b256, __anon_10, !3400 - mem_copy_val v91, v90 - v92 = get_local __ptr b256, __anon_10, !3400 - v93 = const u64 0 - v94 = const u64 18446744073709551615 - v95 = contract_call __ptr () v89, v93, v92, v94, !3436 - v96 = asm() -> ptr ret, !3437 { - } - v97 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v98 = call new_21(v97) - v99 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v99, v97 - v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v101 = const u64 101, !1790 - v102 = call abi_encode_20(v101, v99, v100) - v103 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3438 - mem_copy_val v103, v100 - v104 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3439 - v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v105, v104 - v106 = get_local __ptr slice, __ret_val8 - v107 = call as_raw_slice_22(v105, v106) - v108 = get_local __ptr slice, __log_arg0 - mem_copy_val v108, v106 - v109 = const u64 1515152261580153489 - log __ptr slice v108, v109 - v110 = get_local __ptr { ptr }, __anon_000, !3440 - v111 = const u64 0 - v112 = get_elem_ptr v110, __ptr ptr, v111, !3441 - store v96 to v112, !3442 - v113 = get_local __ptr { ptr }, buffer, !3443 - mem_copy_val v113, v110 - v114 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v115 = call new_21(v114) - v116 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v116, v114 - v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v118 = const u64 102, !1801 - v119 = call abi_encode_20(v118, v116, v117) - v120 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3444 - mem_copy_val v120, v117 - v121 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3445 - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v122, v121 - v123 = get_local __ptr slice, __ret_val9 - v124 = call as_raw_slice_22(v122, v123) - v125 = get_local __ptr slice, __log_arg1 - mem_copy_val v125, v123 - v126 = const u64 1515152261580153489 - log __ptr slice v125, v126 - v127 = get_local __ptr { ptr }, buffer, !3446 - v128 = get_local __ptr { u64 }, __ret_val11 - v129 = call abi_decode_128(v127, v128) - v130 = get_local __ptr { u64 }, r, !3447 - mem_copy_val v130, v128 - v131 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v132 = call new_21(v131) - v133 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v133, v131 - v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v135 = const u64 103, !1814 - v136 = call abi_encode_20(v135, v133, v134) - v137 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3448 - mem_copy_val v137, v134 - v138 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3449 - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v139, v138 - v140 = get_local __ptr slice, __ret_val10 - v141 = call as_raw_slice_22(v139, v140) - v142 = get_local __ptr slice, __log_arg2 - mem_copy_val v142, v140 - v143 = const u64 1515152261580153489 - log __ptr slice v142, v143 - v144 = get_local __ptr { u64 }, r, !3450 - v145 = get_local __ptr { u64 }, _, !3451 - mem_copy_val v145, v144 - v146 = const unit () - ret () v146 - } - - pub fn encode_281(item: __ptr { { u64 } }, __ret_value: __ptr slice) -> (), !3452 { - local { { ptr, u64, u64 } } __ret_val - local slice __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - - entry(item: __ptr { { u64 } }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3453 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr { u64 }, v3, !3454 - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v7 = call abi_encode_131(v4, v5, v6) - v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3455 - mem_copy_val v8, v6 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v10 = get_local __ptr slice, __ret_val0 - v11 = call as_raw_slice_22(v9, v10) - mem_copy_val __ret_value, v10 - v12 = const unit () - ret () v12 - } - - entry fn in_struct_u64_u64() -> (), !3459 { - local { u64, u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, u64 } __anon_2 - local { { u64, u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local { u64, u64 } __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local slice __ret_val14 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local slice __tmp_arg7 - local { b256, u64, u64 } __tmp_arg8 - local { { u64, u64 } } __tmp_arg9 - local { { u64, u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local b256 contract_id_ - local slice first_parameter - local slice method_name_ - local slice params - local { u64, u64 } r - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3460 - v2 = get_global __ptr string<17>, __const_global52 - v3 = cast_ptr v2 to ptr, !3461 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3461 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3461 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 17 - store v9 to v8, !3461 - v10 = get_local __ptr slice, __anon_1, !3461 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, u64 }, __anon_2, !3462 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !3463 - store v14 to v13, !3462 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15 - v17 = const u64 0, !3464 - store v17 to v16, !3462 - v18 = get_local __ptr { { u64, u64 } }, __anon_3 - v19 = const u64 0 - v20 = get_elem_ptr v18, __ptr { u64, u64 }, v19 - mem_copy_val v20, v11 - v21 = get_local __ptr b256, contract_id_, !3465 - mem_copy_val v21, v1 - v22 = get_local __ptr slice, method_name_, !3465 - mem_copy_val v22, v10 - v23 = get_local __ptr { { u64, u64 } }, args_, !3465 - mem_copy_val v23, v18 - v24 = get_local __ptr b256, asset_id_, !3465 - mem_copy_val v24, v0 - v25 = get_local __ptr slice, method_name_, !3466 - v26 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v26, v25 - v27 = get_local __ptr slice, __ret_val12 - v28 = call encode_208(v26, v27) - v29 = get_local __ptr slice, first_parameter, !3467 - mem_copy_val v29, v27 - v30 = get_local __ptr { { u64, u64 } }, args_, !3468 - v31 = get_local __ptr { { u64, u64 } }, __tmp_arg9 - mem_copy_val v31, v30 - v32 = get_local __ptr slice, __ret_val14 - v33 = call encode_284(v31, v32) - v34 = get_local __ptr slice, second_parameter, !3469 - mem_copy_val v34, v32 - v35 = get_local __ptr b256, contract_id_, !3470 - v36 = get_local __ptr slice, first_parameter, !3471 - v37 = get_local __ptr slice, self_, !3472 - mem_copy_val v37, v36 - v38 = get_local __ptr slice, self_, !3473 - v39 = get_local __ptr slice, slice_, !3474 - mem_copy_val v39, v38 - v40 = get_local __ptr slice, slice_, !3475 - v41 = asm(ptr: v40) -> __ptr { ptr, u64 } ptr { - } - v42 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v42, v41 - v43 = get_local __ptr { ptr, u64 }, __anon_01, !3472 - mem_copy_val v43, v42 - v44 = const u64 0 - v45 = get_elem_ptr v43, __ptr ptr, v44, !3476 - v46 = load v45, !3472 - v47 = asm(a: v46) -> u64 a, !3477 { - } - v48 = get_local __ptr slice, second_parameter, !3478 - v49 = get_local __ptr slice, self_0, !3479 - mem_copy_val v49, v48 - v50 = get_local __ptr slice, self_0, !3480 - v51 = get_local __ptr slice, slice_0, !3481 - mem_copy_val v51, v50 - v52 = get_local __ptr slice, slice_0, !3482 - v53 = asm(ptr: v52) -> __ptr { ptr, u64 } ptr { - } - v54 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v54, v53 - v55 = get_local __ptr { ptr, u64 }, __anon_02, !3479 - mem_copy_val v55, v54 - v56 = get_elem_ptr v55, __ptr ptr, v44, !3483 - v57 = load v56, !3479 - v58 = asm(a: v57) -> u64 a, !3484 { - } - v59 = get_local __ptr { b256, u64, u64 }, __anon_00, !3485 - v60 = const u64 0 - v61 = get_elem_ptr v59, __ptr b256, v60, !3486 - mem_copy_val v61, v35 - v62 = const u64 1 - v63 = get_elem_ptr v59, __ptr u64, v62, !3487 - store v47 to v63, !3488 - v64 = const u64 2 - v65 = get_elem_ptr v59, __ptr u64, v64, !3489 - store v58 to v65, !3490 - v66 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 - mem_copy_val v66, v59 - v67 = get_local __ptr slice, __ret_val13 - v68 = call encode_212(v66, v67) - v69 = get_local __ptr slice, params, !3491 - mem_copy_val v69, v67 - v70 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v71 = call new_21(v70) - v72 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v72, v70 - v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v74 = const u64 100, !1772 - v75 = call abi_encode_20(v74, v72, v73) - v76 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3492 - mem_copy_val v76, v73 - v77 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3493 - v78 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v78, v77 - v79 = get_local __ptr slice, __ret_val7 - v80 = call as_raw_slice_22(v78, v79) - v81 = get_local __ptr slice, __log_arg - mem_copy_val v81, v79 - v82 = const u64 1515152261580153489 - log __ptr slice v81, v82 - v83 = get_local __ptr slice, params, !3494 - v84 = get_local __ptr slice, self_1, !3495 - mem_copy_val v84, v83 - v85 = get_local __ptr slice, self_1, !3496 - v86 = get_local __ptr slice, slice_1, !3497 - mem_copy_val v86, v85 - v87 = get_local __ptr slice, slice_1, !3498 - v88 = asm(ptr: v87) -> __ptr { ptr, u64 } ptr { - } - v89 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v89, v88 - v90 = get_local __ptr { ptr, u64 }, __anon_03, !3495 - mem_copy_val v90, v89 - v91 = get_elem_ptr v90, __ptr ptr, v44, !3499 - v92 = load v91, !3495 - v93 = get_local __ptr b256, asset_id_, !3500 - v94 = get_local __ptr b256, __anon_10, !3465 - mem_copy_val v94, v93 - v95 = get_local __ptr b256, __anon_10, !3465 - v96 = const u64 0 - v97 = const u64 18446744073709551615 - v98 = contract_call __ptr () v92, v96, v95, v97, !3501 - v99 = asm() -> ptr ret, !3502 { - } - v100 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v101 = call new_21(v100) - v102 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v102, v100 - v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v104 = const u64 101, !1790 - v105 = call abi_encode_20(v104, v102, v103) - v106 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3503 - mem_copy_val v106, v103 - v107 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3504 - v108 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v108, v107 - v109 = get_local __ptr slice, __ret_val8 - v110 = call as_raw_slice_22(v108, v109) - v111 = get_local __ptr slice, __log_arg0 - mem_copy_val v111, v109 - v112 = const u64 1515152261580153489 - log __ptr slice v111, v112 - v113 = get_local __ptr { ptr }, __anon_000, !3505 - v114 = const u64 0 - v115 = get_elem_ptr v113, __ptr ptr, v114, !3506 - store v99 to v115, !3507 - v116 = get_local __ptr { ptr }, buffer, !3508 - mem_copy_val v116, v113 - v117 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v118 = call new_21(v117) - v119 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v119, v117 - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v121 = const u64 102, !1801 - v122 = call abi_encode_20(v121, v119, v120) - v123 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3509 - mem_copy_val v123, v120 - v124 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3510 - v125 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v125, v124 - v126 = get_local __ptr slice, __ret_val9 - v127 = call as_raw_slice_22(v125, v126) - v128 = get_local __ptr slice, __log_arg1 - mem_copy_val v128, v126 - v129 = const u64 1515152261580153489 - log __ptr slice v128, v129 - v130 = get_local __ptr { ptr }, buffer, !3511 - v131 = get_local __ptr { u64, u64 }, __ret_val11 - v132 = call abi_decode_134(v130, v131) - v133 = get_local __ptr { u64, u64 }, r, !3512 - mem_copy_val v133, v131 - v134 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v135 = call new_21(v134) - v136 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v136, v134 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v138 = const u64 103, !1814 - v139 = call abi_encode_20(v138, v136, v137) - v140 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3513 - mem_copy_val v140, v137 - v141 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3514 - v142 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v142, v141 - v143 = get_local __ptr slice, __ret_val10 - v144 = call as_raw_slice_22(v142, v143) - v145 = get_local __ptr slice, __log_arg2 - mem_copy_val v145, v143 - v146 = const u64 1515152261580153489 - log __ptr slice v145, v146 - v147 = get_local __ptr { u64, u64 }, r, !3515 - v148 = get_local __ptr { u64, u64 }, _, !3516 - mem_copy_val v148, v147 - v149 = const unit () - ret () v149 - } - - pub fn encode_284(item: __ptr { { u64, u64 } }, __ret_value: __ptr slice) -> (), !3517 { - local { { ptr, u64, u64 } } __ret_val - local slice __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - - entry(item: __ptr { { u64, u64 } }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3518 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr { u64, u64 }, v3, !3519 - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v7 = call abi_encode_159(v4, v5, v6) - v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3520 - mem_copy_val v8, v6 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v10 = get_local __ptr slice, __ret_val0 - v11 = call as_raw_slice_22(v9, v10) - mem_copy_val __ret_value, v10 - v12 = const unit () - ret () v12 - } - - entry fn in_struct_u64_u64_u64() -> (), !3524 { - local { u64, u64, u64 } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, u64, u64 } __anon_2 - local { { u64, u64, u64 } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local { u64, u64, u64 } __ret_val11 - local slice __ret_val12 - local slice __ret_val13 - local slice __ret_val14 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local slice __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local slice __tmp_arg7 - local { b256, u64, u64 } __tmp_arg8 - local { { u64, u64, u64 } } __tmp_arg9 - local { { u64, u64, u64 } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local b256 contract_id_ - local slice first_parameter - local slice method_name_ - local slice params - local { u64, u64, u64 } r - local slice second_parameter - local slice self_ - local slice self_0 - local slice self_1 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3525 - v2 = get_global __ptr string<21>, __const_global53 - v3 = cast_ptr v2 to ptr, !3526 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3526 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3526 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 21 - store v9 to v8, !3526 - v10 = get_local __ptr slice, __anon_1, !3526 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, u64, u64 }, __anon_2, !3527 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12 - v14 = const u64 0, !3528 - store v14 to v13, !3527 - v15 = const u64 1 - v16 = get_elem_ptr v11, __ptr u64, v15 - v17 = const u64 0, !3529 - store v17 to v16, !3527 - v18 = const u64 2 - v19 = get_elem_ptr v11, __ptr u64, v18 - v20 = const u64 0, !3530 - store v20 to v19, !3527 - v21 = get_local __ptr { { u64, u64, u64 } }, __anon_3 - v22 = const u64 0 - v23 = get_elem_ptr v21, __ptr { u64, u64, u64 }, v22 - mem_copy_val v23, v11 - v24 = get_local __ptr b256, contract_id_, !3531 - mem_copy_val v24, v1 - v25 = get_local __ptr slice, method_name_, !3531 - mem_copy_val v25, v10 - v26 = get_local __ptr { { u64, u64, u64 } }, args_, !3531 - mem_copy_val v26, v21 - v27 = get_local __ptr b256, asset_id_, !3531 - mem_copy_val v27, v0 - v28 = get_local __ptr slice, method_name_, !3532 - v29 = get_local __ptr slice, __tmp_arg7 - mem_copy_val v29, v28 - v30 = get_local __ptr slice, __ret_val12 - v31 = call encode_208(v29, v30) - v32 = get_local __ptr slice, first_parameter, !3533 - mem_copy_val v32, v30 - v33 = get_local __ptr { { u64, u64, u64 } }, args_, !3534 - v34 = get_local __ptr { { u64, u64, u64 } }, __tmp_arg9 - mem_copy_val v34, v33 - v35 = get_local __ptr slice, __ret_val14 - v36 = call encode_287(v34, v35) - v37 = get_local __ptr slice, second_parameter, !3535 - mem_copy_val v37, v35 - v38 = get_local __ptr b256, contract_id_, !3536 - v39 = get_local __ptr slice, first_parameter, !3537 - v40 = get_local __ptr slice, self_, !3538 - mem_copy_val v40, v39 - v41 = get_local __ptr slice, self_, !3539 - v42 = get_local __ptr slice, slice_, !3540 - mem_copy_val v42, v41 - v43 = get_local __ptr slice, slice_, !3541 - v44 = asm(ptr: v43) -> __ptr { ptr, u64 } ptr { - } - v45 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v45, v44 - v46 = get_local __ptr { ptr, u64 }, __anon_01, !3538 - mem_copy_val v46, v45 - v47 = const u64 0 - v48 = get_elem_ptr v46, __ptr ptr, v47, !3542 - v49 = load v48, !3538 - v50 = asm(a: v49) -> u64 a, !3543 { - } - v51 = get_local __ptr slice, second_parameter, !3544 - v52 = get_local __ptr slice, self_0, !3545 - mem_copy_val v52, v51 - v53 = get_local __ptr slice, self_0, !3546 - v54 = get_local __ptr slice, slice_0, !3547 - mem_copy_val v54, v53 - v55 = get_local __ptr slice, slice_0, !3548 - v56 = asm(ptr: v55) -> __ptr { ptr, u64 } ptr { - } - v57 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v57, v56 - v58 = get_local __ptr { ptr, u64 }, __anon_02, !3545 - mem_copy_val v58, v57 - v59 = get_elem_ptr v58, __ptr ptr, v47, !3549 - v60 = load v59, !3545 - v61 = asm(a: v60) -> u64 a, !3550 { - } - v62 = get_local __ptr { b256, u64, u64 }, __anon_00, !3551 - v63 = const u64 0 - v64 = get_elem_ptr v62, __ptr b256, v63, !3552 - mem_copy_val v64, v38 - v65 = const u64 1 - v66 = get_elem_ptr v62, __ptr u64, v65, !3553 - store v50 to v66, !3554 - v67 = const u64 2 - v68 = get_elem_ptr v62, __ptr u64, v67, !3555 - store v61 to v68, !3556 - v69 = get_local __ptr { b256, u64, u64 }, __tmp_arg8 - mem_copy_val v69, v62 - v70 = get_local __ptr slice, __ret_val13 - v71 = call encode_212(v69, v70) - v72 = get_local __ptr slice, params, !3557 - mem_copy_val v72, v70 - v73 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v74 = call new_21(v73) - v75 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v75, v73 - v76 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v77 = const u64 100, !1772 - v78 = call abi_encode_20(v77, v75, v76) - v79 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3558 - mem_copy_val v79, v76 - v80 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3559 - v81 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v81, v80 - v82 = get_local __ptr slice, __ret_val7 - v83 = call as_raw_slice_22(v81, v82) - v84 = get_local __ptr slice, __log_arg - mem_copy_val v84, v82 - v85 = const u64 1515152261580153489 - log __ptr slice v84, v85 - v86 = get_local __ptr slice, params, !3560 - v87 = get_local __ptr slice, self_1, !3561 - mem_copy_val v87, v86 - v88 = get_local __ptr slice, self_1, !3562 - v89 = get_local __ptr slice, slice_1, !3563 - mem_copy_val v89, v88 - v90 = get_local __ptr slice, slice_1, !3564 - v91 = asm(ptr: v90) -> __ptr { ptr, u64 } ptr { - } - v92 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v92, v91 - v93 = get_local __ptr { ptr, u64 }, __anon_03, !3561 - mem_copy_val v93, v92 - v94 = get_elem_ptr v93, __ptr ptr, v47, !3565 - v95 = load v94, !3561 - v96 = get_local __ptr b256, asset_id_, !3566 - v97 = get_local __ptr b256, __anon_10, !3531 - mem_copy_val v97, v96 - v98 = get_local __ptr b256, __anon_10, !3531 - v99 = const u64 0 - v100 = const u64 18446744073709551615 - v101 = contract_call __ptr () v95, v99, v98, v100, !3567 - v102 = asm() -> ptr ret, !3568 { - } - v103 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v104 = call new_21(v103) - v105 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v105, v103 - v106 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v107 = const u64 101, !1790 - v108 = call abi_encode_20(v107, v105, v106) - v109 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3569 - mem_copy_val v109, v106 - v110 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3570 - v111 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v111, v110 - v112 = get_local __ptr slice, __ret_val8 - v113 = call as_raw_slice_22(v111, v112) - v114 = get_local __ptr slice, __log_arg0 - mem_copy_val v114, v112 - v115 = const u64 1515152261580153489 - log __ptr slice v114, v115 - v116 = get_local __ptr { ptr }, __anon_000, !3571 - v117 = const u64 0 - v118 = get_elem_ptr v116, __ptr ptr, v117, !3572 - store v102 to v118, !3573 - v119 = get_local __ptr { ptr }, buffer, !3574 - mem_copy_val v119, v116 - v120 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v121 = call new_21(v120) - v122 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v122, v120 - v123 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v124 = const u64 102, !1801 - v125 = call abi_encode_20(v124, v122, v123) - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3575 - mem_copy_val v126, v123 - v127 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3576 - v128 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v128, v127 - v129 = get_local __ptr slice, __ret_val9 - v130 = call as_raw_slice_22(v128, v129) - v131 = get_local __ptr slice, __log_arg1 - mem_copy_val v131, v129 - v132 = const u64 1515152261580153489 - log __ptr slice v131, v132 - v133 = get_local __ptr { ptr }, buffer, !3577 - v134 = get_local __ptr { u64, u64, u64 }, __ret_val11 - v135 = call abi_decode_162(v133, v134) - v136 = get_local __ptr { u64, u64, u64 }, r, !3578 - mem_copy_val v136, v134 - v137 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v138 = call new_21(v137) - v139 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v139, v137 - v140 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v141 = const u64 103, !1814 - v142 = call abi_encode_20(v141, v139, v140) - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3579 - mem_copy_val v143, v140 - v144 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3580 - v145 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v145, v144 - v146 = get_local __ptr slice, __ret_val10 - v147 = call as_raw_slice_22(v145, v146) - v148 = get_local __ptr slice, __log_arg2 - mem_copy_val v148, v146 - v149 = const u64 1515152261580153489 - log __ptr slice v148, v149 - v150 = get_local __ptr { u64, u64, u64 }, r, !3581 - v151 = get_local __ptr { u64, u64, u64 }, _, !3582 - mem_copy_val v151, v150 - v152 = const unit () - ret () v152 - } - - pub fn encode_287(item: __ptr { { u64, u64, u64 } }, __ret_value: __ptr slice) -> (), !3583 { - local { { ptr, u64, u64 } } __ret_val - local slice __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - - entry(item: __ptr { { u64, u64, u64 } }, __ret_value: __ptr slice): - v0 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v1 = call new_21(v0) - v2 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3584 - mem_copy_val v2, v0 - v3 = const u64 0 - v4 = get_elem_ptr item, __ptr { u64, u64, u64 }, v3, !3585 - v5 = get_local __ptr { { ptr, u64, u64 } }, buffer_ - v6 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v7 = call abi_encode_143(v4, v5, v6) - v8 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3586 - mem_copy_val v8, v6 - v9 = get_local __ptr { { ptr, u64, u64 } }, buffer__ - v10 = get_local __ptr slice, __ret_val0 - v11 = call as_raw_slice_22(v9, v10) - mem_copy_val __ret_value, v10 - v12 = const unit () - ret () v12 - } - - entry fn in_enum_u64() -> (), !3590 { - local { u64, ( u64 ) } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, ( u64 ) } __anon_2 - local { { u64, ( u64 ) } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { u64, ( u64 ) } __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { u64, ( u64 ) } __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { { u64, ( u64 ) } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { { u64, ( u64 ) } } item_ - local slice method_name_ - local slice params - local { u64, ( u64 ) } r - local slice second_parameter - local { { u64, ( u64 ) } } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3591 - v2 = get_global __ptr string<11>, __const_global54 - v3 = cast_ptr v2 to ptr, !3592 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3592 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3592 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 11 - store v9 to v8, !3592 - v10 = get_local __ptr slice, __anon_1, !3592 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, ( u64 ) }, __anon_2, !1385 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !1385 - v14 = const u64 0, !1385 - store v14 to v13, !1385 - v15 = const u64 1 - v16 = const u64 0 - v17 = get_elem_ptr v11, __ptr u64, v15, v16, !1385 - v18 = const u64 0, !3593 - store v18 to v17, !1385 - v19 = get_local __ptr { { u64, ( u64 ) } }, __anon_3 - v20 = const u64 0 - v21 = get_elem_ptr v19, __ptr { u64, ( u64 ) }, v20 - mem_copy_val v21, v11 - v22 = get_local __ptr b256, contract_id_, !3594 - mem_copy_val v22, v1 - v23 = get_local __ptr slice, method_name_, !3594 - mem_copy_val v23, v10 - v24 = get_local __ptr { { u64, ( u64 ) } }, args_, !3594 - mem_copy_val v24, v19 - v25 = get_local __ptr b256, asset_id_, !3594 - mem_copy_val v25, v0 - v26 = get_local __ptr slice, method_name_, !3595 - v27 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v27, v26 - v28 = get_local __ptr slice, __ret_val15 - v29 = call encode_208(v27, v28) - v30 = get_local __ptr slice, first_parameter, !3596 - mem_copy_val v30, v28 - v31 = get_local __ptr { { u64, ( u64 ) } }, args_, !3597 - v32 = get_local __ptr { { u64, ( u64 ) } }, item_, !3598 - mem_copy_val v32, v31 - v33 = get_local __ptr { { u64, ( u64 ) } }, item_, !3599 - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v35 = call new_21(v34) - v36 = get_local __ptr { { u64, ( u64 ) } }, self_, !3600 - mem_copy_val v36, v33 - v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3601 - mem_copy_val v37, v34 - v38 = get_local __ptr { { u64, ( u64 ) } }, self_, !3602 - v39 = const u64 0 - v40 = get_elem_ptr v38, __ptr { u64, ( u64 ) }, v39, !3603 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3604 - v42 = get_local __ptr { u64, ( u64 ) }, __tmp_arg8 - mem_copy_val v42, v40 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v45 = call abi_encode_83(v42, v43, v44) - v46 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3605 - mem_copy_val v46, v44 - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3606 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3607 - mem_copy_val v48, v47 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3608 - v50 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, __ret_val8 - v52 = call as_raw_slice_22(v50, v51) - v53 = get_local __ptr slice, second_parameter, !3609 - mem_copy_val v53, v51 - v54 = get_local __ptr b256, contract_id_, !3610 - v55 = get_local __ptr slice, first_parameter, !3611 - v56 = get_local __ptr slice, self_0, !3612 - mem_copy_val v56, v55 - v57 = get_local __ptr slice, self_0, !3613 - v58 = get_local __ptr slice, slice_, !3614 - mem_copy_val v58, v57 - v59 = get_local __ptr slice, slice_, !3615 - v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { - } - v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v61, v60 - v62 = get_local __ptr { ptr, u64 }, __anon_01, !3612 - mem_copy_val v62, v61 - v63 = const u64 0 - v64 = get_elem_ptr v62, __ptr ptr, v63, !3616 - v65 = load v64, !3612 - v66 = asm(a: v65) -> u64 a, !3617 { - } - v67 = get_local __ptr slice, second_parameter, !3618 - v68 = get_local __ptr slice, self_1, !3619 - mem_copy_val v68, v67 - v69 = get_local __ptr slice, self_1, !3620 - v70 = get_local __ptr slice, slice_0, !3621 - mem_copy_val v70, v69 - v71 = get_local __ptr slice, slice_0, !3622 - v72 = asm(ptr: v71) -> __ptr { ptr, u64 } ptr { - } - v73 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v73, v72 - v74 = get_local __ptr { ptr, u64 }, __anon_02, !3619 - mem_copy_val v74, v73 - v75 = get_elem_ptr v74, __ptr ptr, v63, !3623 - v76 = load v75, !3619 - v77 = asm(a: v76) -> u64 a, !3624 { - } - v78 = get_local __ptr { b256, u64, u64 }, __anon_00, !3625 - v79 = const u64 0 - v80 = get_elem_ptr v78, __ptr b256, v79, !3626 - mem_copy_val v80, v54 - v81 = const u64 1 - v82 = get_elem_ptr v78, __ptr u64, v81, !3627 - store v66 to v82, !3628 - v83 = const u64 2 - v84 = get_elem_ptr v78, __ptr u64, v83, !3629 - store v77 to v84, !3630 - v85 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v85, v78 - v86 = get_local __ptr slice, __ret_val16 - v87 = call encode_212(v85, v86) - v88 = get_local __ptr slice, params, !3631 - mem_copy_val v88, v86 - v89 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v90 = call new_21(v89) - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v91, v89 - v92 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v93 = const u64 100, !1772 - v94 = call abi_encode_20(v93, v91, v92) - v95 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3632 - mem_copy_val v95, v92 - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3633 - v97 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, __ret_val9 - v99 = call as_raw_slice_22(v97, v98) - v100 = get_local __ptr slice, __log_arg - mem_copy_val v100, v98 - v101 = const u64 1515152261580153489 - log __ptr slice v100, v101 - v102 = get_local __ptr slice, params, !3634 - v103 = get_local __ptr slice, self_2, !3635 - mem_copy_val v103, v102 - v104 = get_local __ptr slice, self_2, !3636 - v105 = get_local __ptr slice, slice_1, !3637 - mem_copy_val v105, v104 - v106 = get_local __ptr slice, slice_1, !3638 - v107 = asm(ptr: v106) -> __ptr { ptr, u64 } ptr { - } - v108 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v108, v107 - v109 = get_local __ptr { ptr, u64 }, __anon_03, !3635 - mem_copy_val v109, v108 - v110 = get_elem_ptr v109, __ptr ptr, v63, !3639 - v111 = load v110, !3635 - v112 = get_local __ptr b256, asset_id_, !3640 - v113 = get_local __ptr b256, __anon_10, !3594 - mem_copy_val v113, v112 - v114 = get_local __ptr b256, __anon_10, !3594 - v115 = const u64 0 - v116 = const u64 18446744073709551615 - v117 = contract_call __ptr () v111, v115, v114, v116, !3641 - v118 = asm() -> ptr ret, !3642 { - } - v119 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v120 = call new_21(v119) - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v121, v119 - v122 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v123 = const u64 101, !1790 - v124 = call abi_encode_20(v123, v121, v122) - v125 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3643 - mem_copy_val v125, v122 - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3644 - v127 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v127, v126 - v128 = get_local __ptr slice, __ret_val10 - v129 = call as_raw_slice_22(v127, v128) - v130 = get_local __ptr slice, __log_arg0 - mem_copy_val v130, v128 - v131 = const u64 1515152261580153489 - log __ptr slice v130, v131 - v132 = get_local __ptr { ptr }, __anon_000, !3645 - v133 = const u64 0 - v134 = get_elem_ptr v132, __ptr ptr, v133, !3646 - store v118 to v134, !3647 - v135 = get_local __ptr { ptr }, buffer, !3648 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v137 = call new_21(v136) - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v138, v136 - v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v140 = const u64 102, !1801 - v141 = call abi_encode_20(v140, v138, v139) - v142 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3649 - mem_copy_val v142, v139 - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3650 - v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v144, v143 - v145 = get_local __ptr slice, __ret_val11 - v146 = call as_raw_slice_22(v144, v145) - v147 = get_local __ptr slice, __log_arg1 - mem_copy_val v147, v145 - v148 = const u64 1515152261580153489 - log __ptr slice v147, v148 - v149 = get_local __ptr { ptr }, buffer, !3651 - v150 = get_local __ptr { u64, ( u64 ) }, __ret_val13 - v151 = call abi_decode_80(v149, v150) - v152 = get_local __ptr { u64, ( u64 ) }, r, !3652 - mem_copy_val v152, v150 - v153 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v154 = call new_21(v153) - v155 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v155, v153 - v156 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v157 = const u64 103, !1814 - v158 = call abi_encode_20(v157, v155, v156) - v159 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3653 - mem_copy_val v159, v156 - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3654 - v161 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v161, v160 - v162 = get_local __ptr slice, __ret_val12 - v163 = call as_raw_slice_22(v161, v162) - v164 = get_local __ptr slice, __log_arg2 - mem_copy_val v164, v162 - v165 = const u64 1515152261580153489 - log __ptr slice v164, v165 - v166 = get_local __ptr { u64, ( u64 ) }, r, !3655 - v167 = get_local __ptr { u64, ( u64 ) }, _, !3656 - mem_copy_val v167, v166 - v168 = const unit () - ret () v168 - } - - entry fn in_enum_u64_u64() -> (), !3660 { - local { u64, ( u64 | u64 ) } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, ( u64 | u64 ) } __anon_2 - local { { u64, ( u64 | u64 ) } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { u64, ( u64 | u64 ) } __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { u64, ( u64 | u64 ) } __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { { u64, ( u64 | u64 ) } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { { u64, ( u64 | u64 ) } } item_ - local slice method_name_ - local slice params - local { u64, ( u64 | u64 ) } r - local slice second_parameter - local { { u64, ( u64 | u64 ) } } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3661 - v2 = get_global __ptr string<15>, __const_global55 - v3 = cast_ptr v2 to ptr, !3662 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3662 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3662 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 15 - store v9 to v8, !3662 - v10 = get_local __ptr slice, __anon_1, !3662 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, ( u64 | u64 ) }, __anon_2, !1417 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !1417 - v14 = const u64 0, !1417 - store v14 to v13, !1417 - v15 = const u64 1 - v16 = const u64 0 - v17 = get_elem_ptr v11, __ptr u64, v15, v16, !1417 - v18 = const u64 0, !3663 - store v18 to v17, !1417 - v19 = get_local __ptr { { u64, ( u64 | u64 ) } }, __anon_3 - v20 = const u64 0 - v21 = get_elem_ptr v19, __ptr { u64, ( u64 | u64 ) }, v20 - mem_copy_val v21, v11 - v22 = get_local __ptr b256, contract_id_, !3664 - mem_copy_val v22, v1 - v23 = get_local __ptr slice, method_name_, !3664 - mem_copy_val v23, v10 - v24 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_, !3664 - mem_copy_val v24, v19 - v25 = get_local __ptr b256, asset_id_, !3664 - mem_copy_val v25, v0 - v26 = get_local __ptr slice, method_name_, !3665 - v27 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v27, v26 - v28 = get_local __ptr slice, __ret_val15 - v29 = call encode_208(v27, v28) - v30 = get_local __ptr slice, first_parameter, !3666 - mem_copy_val v30, v28 - v31 = get_local __ptr { { u64, ( u64 | u64 ) } }, args_, !3667 - v32 = get_local __ptr { { u64, ( u64 | u64 ) } }, item_, !3668 - mem_copy_val v32, v31 - v33 = get_local __ptr { { u64, ( u64 | u64 ) } }, item_, !3669 - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v35 = call new_21(v34) - v36 = get_local __ptr { { u64, ( u64 | u64 ) } }, self_, !3670 - mem_copy_val v36, v33 - v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3671 - mem_copy_val v37, v34 - v38 = get_local __ptr { { u64, ( u64 | u64 ) } }, self_, !3672 - v39 = const u64 0 - v40 = get_elem_ptr v38, __ptr { u64, ( u64 | u64 ) }, v39, !3673 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3674 - v42 = get_local __ptr { u64, ( u64 | u64 ) }, __tmp_arg8 - mem_copy_val v42, v40 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v45 = call abi_encode_89(v42, v43, v44) - v46 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3675 - mem_copy_val v46, v44 - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3676 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3677 - mem_copy_val v48, v47 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3678 - v50 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, __ret_val8 - v52 = call as_raw_slice_22(v50, v51) - v53 = get_local __ptr slice, second_parameter, !3679 - mem_copy_val v53, v51 - v54 = get_local __ptr b256, contract_id_, !3680 - v55 = get_local __ptr slice, first_parameter, !3681 - v56 = get_local __ptr slice, self_0, !3682 - mem_copy_val v56, v55 - v57 = get_local __ptr slice, self_0, !3683 - v58 = get_local __ptr slice, slice_, !3684 - mem_copy_val v58, v57 - v59 = get_local __ptr slice, slice_, !3685 - v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { - } - v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v61, v60 - v62 = get_local __ptr { ptr, u64 }, __anon_01, !3682 - mem_copy_val v62, v61 - v63 = const u64 0 - v64 = get_elem_ptr v62, __ptr ptr, v63, !3686 - v65 = load v64, !3682 - v66 = asm(a: v65) -> u64 a, !3687 { - } - v67 = get_local __ptr slice, second_parameter, !3688 - v68 = get_local __ptr slice, self_1, !3689 - mem_copy_val v68, v67 - v69 = get_local __ptr slice, self_1, !3690 - v70 = get_local __ptr slice, slice_0, !3691 - mem_copy_val v70, v69 - v71 = get_local __ptr slice, slice_0, !3692 - v72 = asm(ptr: v71) -> __ptr { ptr, u64 } ptr { - } - v73 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v73, v72 - v74 = get_local __ptr { ptr, u64 }, __anon_02, !3689 - mem_copy_val v74, v73 - v75 = get_elem_ptr v74, __ptr ptr, v63, !3693 - v76 = load v75, !3689 - v77 = asm(a: v76) -> u64 a, !3694 { - } - v78 = get_local __ptr { b256, u64, u64 }, __anon_00, !3695 - v79 = const u64 0 - v80 = get_elem_ptr v78, __ptr b256, v79, !3696 - mem_copy_val v80, v54 - v81 = const u64 1 - v82 = get_elem_ptr v78, __ptr u64, v81, !3697 - store v66 to v82, !3698 - v83 = const u64 2 - v84 = get_elem_ptr v78, __ptr u64, v83, !3699 - store v77 to v84, !3700 - v85 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v85, v78 - v86 = get_local __ptr slice, __ret_val16 - v87 = call encode_212(v85, v86) - v88 = get_local __ptr slice, params, !3701 - mem_copy_val v88, v86 - v89 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v90 = call new_21(v89) - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v91, v89 - v92 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v93 = const u64 100, !1772 - v94 = call abi_encode_20(v93, v91, v92) - v95 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3702 - mem_copy_val v95, v92 - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3703 - v97 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, __ret_val9 - v99 = call as_raw_slice_22(v97, v98) - v100 = get_local __ptr slice, __log_arg - mem_copy_val v100, v98 - v101 = const u64 1515152261580153489 - log __ptr slice v100, v101 - v102 = get_local __ptr slice, params, !3704 - v103 = get_local __ptr slice, self_2, !3705 - mem_copy_val v103, v102 - v104 = get_local __ptr slice, self_2, !3706 - v105 = get_local __ptr slice, slice_1, !3707 - mem_copy_val v105, v104 - v106 = get_local __ptr slice, slice_1, !3708 - v107 = asm(ptr: v106) -> __ptr { ptr, u64 } ptr { - } - v108 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v108, v107 - v109 = get_local __ptr { ptr, u64 }, __anon_03, !3705 - mem_copy_val v109, v108 - v110 = get_elem_ptr v109, __ptr ptr, v63, !3709 - v111 = load v110, !3705 - v112 = get_local __ptr b256, asset_id_, !3710 - v113 = get_local __ptr b256, __anon_10, !3664 - mem_copy_val v113, v112 - v114 = get_local __ptr b256, __anon_10, !3664 - v115 = const u64 0 - v116 = const u64 18446744073709551615 - v117 = contract_call __ptr () v111, v115, v114, v116, !3711 - v118 = asm() -> ptr ret, !3712 { - } - v119 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v120 = call new_21(v119) - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v121, v119 - v122 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v123 = const u64 101, !1790 - v124 = call abi_encode_20(v123, v121, v122) - v125 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3713 - mem_copy_val v125, v122 - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3714 - v127 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v127, v126 - v128 = get_local __ptr slice, __ret_val10 - v129 = call as_raw_slice_22(v127, v128) - v130 = get_local __ptr slice, __log_arg0 - mem_copy_val v130, v128 - v131 = const u64 1515152261580153489 - log __ptr slice v130, v131 - v132 = get_local __ptr { ptr }, __anon_000, !3715 - v133 = const u64 0 - v134 = get_elem_ptr v132, __ptr ptr, v133, !3716 - store v118 to v134, !3717 - v135 = get_local __ptr { ptr }, buffer, !3718 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v137 = call new_21(v136) - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v138, v136 - v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v140 = const u64 102, !1801 - v141 = call abi_encode_20(v140, v138, v139) - v142 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3719 - mem_copy_val v142, v139 - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3720 - v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v144, v143 - v145 = get_local __ptr slice, __ret_val11 - v146 = call as_raw_slice_22(v144, v145) - v147 = get_local __ptr slice, __log_arg1 - mem_copy_val v147, v145 - v148 = const u64 1515152261580153489 - log __ptr slice v147, v148 - v149 = get_local __ptr { ptr }, buffer, !3721 - v150 = get_local __ptr { u64, ( u64 | u64 ) }, __ret_val13 - v151 = call abi_decode_86(v149, v150) - v152 = get_local __ptr { u64, ( u64 | u64 ) }, r, !3722 - mem_copy_val v152, v150 - v153 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v154 = call new_21(v153) - v155 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v155, v153 - v156 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v157 = const u64 103, !1814 - v158 = call abi_encode_20(v157, v155, v156) - v159 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3723 - mem_copy_val v159, v156 - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3724 - v161 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v161, v160 - v162 = get_local __ptr slice, __ret_val12 - v163 = call as_raw_slice_22(v161, v162) - v164 = get_local __ptr slice, __log_arg2 - mem_copy_val v164, v162 - v165 = const u64 1515152261580153489 - log __ptr slice v164, v165 - v166 = get_local __ptr { u64, ( u64 | u64 ) }, r, !3725 - v167 = get_local __ptr { u64, ( u64 | u64 ) }, _, !3726 - mem_copy_val v167, v166 - v168 = const unit () - ret () v168 - } - - entry fn in_enum_u64_u64_u64() -> (), !3730 { - local { u64, ( u64 | u64 | u64 ) } _ - local mut { ptr, u64 } __aggr_memcpy_0 - local mut { ptr, u64 } __aggr_memcpy_00 - local mut { ptr, u64 } __aggr_memcpy_01 - local { ptr, u64 } __anon_0 - local { b256, u64, u64 } __anon_00 - local { ptr } __anon_000 - local { ptr, u64 } __anon_01 - local { ptr, u64 } __anon_02 - local { ptr, u64 } __anon_03 - local slice __anon_1 - local b256 __anon_10 - local { u64, ( u64 | u64 | u64 ) } __anon_2 - local { { u64, ( u64 | u64 | u64 ) } } __anon_3 - local b256 __const = const b256 0x0000000000000000000000000000000000000000000000000000000000000000 - local slice __log_arg - local slice __log_arg0 - local slice __log_arg1 - local slice __log_arg2 - local { { ptr, u64, u64 } } __ret_val - local { { ptr, u64, u64 } } __ret_val0 - local { { ptr, u64, u64 } } __ret_val1 - local slice __ret_val10 - local slice __ret_val11 - local slice __ret_val12 - local { u64, ( u64 | u64 | u64 ) } __ret_val13 - local { { ptr, u64, u64 } } __ret_val14 - local slice __ret_val15 - local slice __ret_val16 - local { { ptr, u64, u64 } } __ret_val2 - local { { ptr, u64, u64 } } __ret_val3 - local { { ptr, u64, u64 } } __ret_val4 - local { { ptr, u64, u64 } } __ret_val5 - local { { ptr, u64, u64 } } __ret_val6 - local { { ptr, u64, u64 } } __ret_val7 - local slice __ret_val8 - local slice __ret_val9 - local { { ptr, u64, u64 } } __tmp_arg - local { { ptr, u64, u64 } } __tmp_arg0 - local { { ptr, u64, u64 } } __tmp_arg1 - local slice __tmp_arg10 - local { b256, u64, u64 } __tmp_arg11 - local { { ptr, u64, u64 } } __tmp_arg2 - local { { ptr, u64, u64 } } __tmp_arg3 - local { { ptr, u64, u64 } } __tmp_arg4 - local { { ptr, u64, u64 } } __tmp_arg5 - local { { ptr, u64, u64 } } __tmp_arg6 - local { { ptr, u64, u64 } } __tmp_arg7 - local { u64, ( u64 | u64 | u64 ) } __tmp_arg8 - local { { ptr, u64, u64 } } __tmp_arg9 - local { { u64, ( u64 | u64 | u64 ) } } args_ - local b256 asset_id_ - local mut { ptr } buffer - local { { ptr, u64, u64 } } buffer0 - local { { ptr, u64, u64 } } buffer1 - local { { ptr, u64, u64 } } buffer2 - local { { ptr, u64, u64 } } buffer3 - local { { ptr, u64, u64 } } buffer4 - local { { ptr, u64, u64 } } buffer_ - local { { ptr, u64, u64 } } buffer__ - local b256 contract_id_ - local slice first_parameter - local { { u64, ( u64 | u64 | u64 ) } } item_ - local slice method_name_ - local slice params - local { u64, ( u64 | u64 | u64 ) } r - local slice second_parameter - local { { u64, ( u64 | u64 | u64 ) } } self_ - local slice self_0 - local slice self_1 - local slice self_2 - local slice slice_ - local slice slice_0 - local slice slice_1 - - entry(): - v0 = get_local __ptr b256, __const - v1 = get_global __ptr b256, const_of_contract_call::CONTRACT_ID, !3731 - v2 = get_global __ptr string<19>, __const_global56 - v3 = cast_ptr v2 to ptr, !3732 - v4 = get_local __ptr { ptr, u64 }, __anon_0, !3732 - v5 = const u64 0 - v6 = get_elem_ptr v4, __ptr ptr, v5 - store v3 to v6, !3732 - v7 = const u64 1 - v8 = get_elem_ptr v4, __ptr u64, v7 - v9 = const u64 19 - store v9 to v8, !3732 - v10 = get_local __ptr slice, __anon_1, !3732 - mem_copy_bytes v10, v4, 16 - v11 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __anon_2, !1463 - v12 = const u64 0 - v13 = get_elem_ptr v11, __ptr u64, v12, !1463 - v14 = const u64 0, !1463 - store v14 to v13, !1463 - v15 = const u64 1 - v16 = const u64 0 - v17 = get_elem_ptr v11, __ptr u64, v15, v16, !1463 - v18 = const u64 0, !3733 - store v18 to v17, !1463 - v19 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, __anon_3 - v20 = const u64 0 - v21 = get_elem_ptr v19, __ptr { u64, ( u64 | u64 | u64 ) }, v20 - mem_copy_val v21, v11 - v22 = get_local __ptr b256, contract_id_, !3734 - mem_copy_val v22, v1 - v23 = get_local __ptr slice, method_name_, !3734 - mem_copy_val v23, v10 - v24 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args_, !3734 - mem_copy_val v24, v19 - v25 = get_local __ptr b256, asset_id_, !3734 - mem_copy_val v25, v0 - v26 = get_local __ptr slice, method_name_, !3735 - v27 = get_local __ptr slice, __tmp_arg10 - mem_copy_val v27, v26 - v28 = get_local __ptr slice, __ret_val15 - v29 = call encode_208(v27, v28) - v30 = get_local __ptr slice, first_parameter, !3736 - mem_copy_val v30, v28 - v31 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, args_, !3737 - v32 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, item_, !3738 - mem_copy_val v32, v31 - v33 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, item_, !3739 - v34 = get_local __ptr { { ptr, u64, u64 } }, __ret_val3 - v35 = call new_21(v34) - v36 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, self_, !3740 - mem_copy_val v36, v33 - v37 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3741 - mem_copy_val v37, v34 - v38 = get_local __ptr { { u64, ( u64 | u64 | u64 ) } }, self_, !3742 - v39 = const u64 0 - v40 = get_elem_ptr v38, __ptr { u64, ( u64 | u64 | u64 ) }, v39, !3743 - v41 = get_local __ptr { { ptr, u64, u64 } }, buffer_, !3744 - v42 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __tmp_arg8 - mem_copy_val v42, v40 - v43 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg9 - mem_copy_val v43, v41 - v44 = get_local __ptr { { ptr, u64, u64 } }, __ret_val14 - v45 = call abi_encode_95(v42, v43, v44) - v46 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3745 - mem_copy_val v46, v44 - v47 = get_local __ptr { { ptr, u64, u64 } }, buffer__, !3746 - v48 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3747 - mem_copy_val v48, v47 - v49 = get_local __ptr { { ptr, u64, u64 } }, buffer0, !3748 - v50 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg3 - mem_copy_val v50, v49 - v51 = get_local __ptr slice, __ret_val8 - v52 = call as_raw_slice_22(v50, v51) - v53 = get_local __ptr slice, second_parameter, !3749 - mem_copy_val v53, v51 - v54 = get_local __ptr b256, contract_id_, !3750 - v55 = get_local __ptr slice, first_parameter, !3751 - v56 = get_local __ptr slice, self_0, !3752 - mem_copy_val v56, v55 - v57 = get_local __ptr slice, self_0, !3753 - v58 = get_local __ptr slice, slice_, !3754 - mem_copy_val v58, v57 - v59 = get_local __ptr slice, slice_, !3755 - v60 = asm(ptr: v59) -> __ptr { ptr, u64 } ptr { - } - v61 = get_local __ptr { ptr, u64 }, __aggr_memcpy_0 - mem_copy_val v61, v60 - v62 = get_local __ptr { ptr, u64 }, __anon_01, !3752 - mem_copy_val v62, v61 - v63 = const u64 0 - v64 = get_elem_ptr v62, __ptr ptr, v63, !3756 - v65 = load v64, !3752 - v66 = asm(a: v65) -> u64 a, !3757 { - } - v67 = get_local __ptr slice, second_parameter, !3758 - v68 = get_local __ptr slice, self_1, !3759 - mem_copy_val v68, v67 - v69 = get_local __ptr slice, self_1, !3760 - v70 = get_local __ptr slice, slice_0, !3761 - mem_copy_val v70, v69 - v71 = get_local __ptr slice, slice_0, !3762 - v72 = asm(ptr: v71) -> __ptr { ptr, u64 } ptr { - } - v73 = get_local __ptr { ptr, u64 }, __aggr_memcpy_00 - mem_copy_val v73, v72 - v74 = get_local __ptr { ptr, u64 }, __anon_02, !3759 - mem_copy_val v74, v73 - v75 = get_elem_ptr v74, __ptr ptr, v63, !3763 - v76 = load v75, !3759 - v77 = asm(a: v76) -> u64 a, !3764 { - } - v78 = get_local __ptr { b256, u64, u64 }, __anon_00, !3765 - v79 = const u64 0 - v80 = get_elem_ptr v78, __ptr b256, v79, !3766 - mem_copy_val v80, v54 - v81 = const u64 1 - v82 = get_elem_ptr v78, __ptr u64, v81, !3767 - store v66 to v82, !3768 - v83 = const u64 2 - v84 = get_elem_ptr v78, __ptr u64, v83, !3769 - store v77 to v84, !3770 - v85 = get_local __ptr { b256, u64, u64 }, __tmp_arg11 - mem_copy_val v85, v78 - v86 = get_local __ptr slice, __ret_val16 - v87 = call encode_212(v85, v86) - v88 = get_local __ptr slice, params, !3771 - mem_copy_val v88, v86 - v89 = get_local __ptr { { ptr, u64, u64 } }, __ret_val4 - v90 = call new_21(v89) - v91 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg - mem_copy_val v91, v89 - v92 = get_local __ptr { { ptr, u64, u64 } }, __ret_val - v93 = const u64 100, !1772 - v94 = call abi_encode_20(v93, v91, v92) - v95 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3772 - mem_copy_val v95, v92 - v96 = get_local __ptr { { ptr, u64, u64 } }, buffer1, !3773 - v97 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg4 - mem_copy_val v97, v96 - v98 = get_local __ptr slice, __ret_val9 - v99 = call as_raw_slice_22(v97, v98) - v100 = get_local __ptr slice, __log_arg - mem_copy_val v100, v98 - v101 = const u64 1515152261580153489 - log __ptr slice v100, v101 - v102 = get_local __ptr slice, params, !3774 - v103 = get_local __ptr slice, self_2, !3775 - mem_copy_val v103, v102 - v104 = get_local __ptr slice, self_2, !3776 - v105 = get_local __ptr slice, slice_1, !3777 - mem_copy_val v105, v104 - v106 = get_local __ptr slice, slice_1, !3778 - v107 = asm(ptr: v106) -> __ptr { ptr, u64 } ptr { - } - v108 = get_local __ptr { ptr, u64 }, __aggr_memcpy_01 - mem_copy_val v108, v107 - v109 = get_local __ptr { ptr, u64 }, __anon_03, !3775 - mem_copy_val v109, v108 - v110 = get_elem_ptr v109, __ptr ptr, v63, !3779 - v111 = load v110, !3775 - v112 = get_local __ptr b256, asset_id_, !3780 - v113 = get_local __ptr b256, __anon_10, !3734 - mem_copy_val v113, v112 - v114 = get_local __ptr b256, __anon_10, !3734 - v115 = const u64 0 - v116 = const u64 18446744073709551615 - v117 = contract_call __ptr () v111, v115, v114, v116, !3781 - v118 = asm() -> ptr ret, !3782 { - } - v119 = get_local __ptr { { ptr, u64, u64 } }, __ret_val5 - v120 = call new_21(v119) - v121 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg0 - mem_copy_val v121, v119 - v122 = get_local __ptr { { ptr, u64, u64 } }, __ret_val0 - v123 = const u64 101, !1790 - v124 = call abi_encode_20(v123, v121, v122) - v125 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3783 - mem_copy_val v125, v122 - v126 = get_local __ptr { { ptr, u64, u64 } }, buffer2, !3784 - v127 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg5 - mem_copy_val v127, v126 - v128 = get_local __ptr slice, __ret_val10 - v129 = call as_raw_slice_22(v127, v128) - v130 = get_local __ptr slice, __log_arg0 - mem_copy_val v130, v128 - v131 = const u64 1515152261580153489 - log __ptr slice v130, v131 - v132 = get_local __ptr { ptr }, __anon_000, !3785 - v133 = const u64 0 - v134 = get_elem_ptr v132, __ptr ptr, v133, !3786 - store v118 to v134, !3787 - v135 = get_local __ptr { ptr }, buffer, !3788 - mem_copy_val v135, v132 - v136 = get_local __ptr { { ptr, u64, u64 } }, __ret_val6 - v137 = call new_21(v136) - v138 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg1 - mem_copy_val v138, v136 - v139 = get_local __ptr { { ptr, u64, u64 } }, __ret_val1 - v140 = const u64 102, !1801 - v141 = call abi_encode_20(v140, v138, v139) - v142 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3789 - mem_copy_val v142, v139 - v143 = get_local __ptr { { ptr, u64, u64 } }, buffer3, !3790 - v144 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg6 - mem_copy_val v144, v143 - v145 = get_local __ptr slice, __ret_val11 - v146 = call as_raw_slice_22(v144, v145) - v147 = get_local __ptr slice, __log_arg1 - mem_copy_val v147, v145 - v148 = const u64 1515152261580153489 - log __ptr slice v147, v148 - v149 = get_local __ptr { ptr }, buffer, !3791 - v150 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, __ret_val13 - v151 = call abi_decode_92(v149, v150) - v152 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, r, !3792 - mem_copy_val v152, v150 - v153 = get_local __ptr { { ptr, u64, u64 } }, __ret_val7 - v154 = call new_21(v153) - v155 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg2 - mem_copy_val v155, v153 - v156 = get_local __ptr { { ptr, u64, u64 } }, __ret_val2 - v157 = const u64 103, !1814 - v158 = call abi_encode_20(v157, v155, v156) - v159 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3793 - mem_copy_val v159, v156 - v160 = get_local __ptr { { ptr, u64, u64 } }, buffer4, !3794 - v161 = get_local __ptr { { ptr, u64, u64 } }, __tmp_arg7 - mem_copy_val v161, v160 - v162 = get_local __ptr slice, __ret_val12 - v163 = call as_raw_slice_22(v161, v162) - v164 = get_local __ptr slice, __log_arg2 - mem_copy_val v164, v162 - v165 = const u64 1515152261580153489 - log __ptr slice v164, v165 - v166 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, r, !3795 - v167 = get_local __ptr { u64, ( u64 | u64 | u64 ) }, _, !3796 - mem_copy_val v167, v166 - v168 = const unit () - ret () v168 - } -} - -!0 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main..sw" -!1 = span !0 1 8828 -!2 = fn_name_span !0 8 15 -!3 = (!1 !2) -!4 = span !0 50 87 -!5 = fn_call_path_span !0 50 85 -!6 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/codec.sw" -!7 = span !6 1259 1300 -!8 = (!4 !5 !7) -!9 = span !6 1320 1359 -!10 = fn_call_path_span !6 1324 1327 -!11 = (!4 !5 !9 !10) -!12 = (!4 !5 !9 !10) -!13 = span !6 1379 1396 -!14 = fn_call_path_span !6 1383 1387 -!15 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_ptr.sw" -!16 = span !15 2650 2739 -!17 = (!4 !5 !13 !14 !16) -!18 = span !15 2688 2701 -!19 = span !6 1439 1497 -!20 = (!4 !5 !19) -!21 = span !6 1407 1508 -!22 = (!4 !5 !21) -!23 = (!4 !5) -!24 = (!4 !5 !21) -!25 = span !0 32 88 -!26 = span !0 120 147 -!27 = fn_call_path_span !0 120 138 -!28 = span !6 140299 140335 -!29 = fn_call_path_span !6 140299 140333 -!30 = span !6 882 923 -!31 = (!26 !27 !28 !29 !30) -!32 = span !6 943 981 -!33 = fn_call_path_span !6 947 950 -!34 = (!26 !27 !28 !29 !32 !33) -!35 = (!26 !27 !28 !29 !32 !33) -!36 = span !6 1001 1018 -!37 = fn_call_path_span !6 1005 1009 -!38 = (!26 !27 !28 !29 !36 !37 !16) -!39 = span !6 1061 1119 -!40 = (!26 !27 !28 !29 !39) -!41 = span !6 1029 1130 -!42 = (!26 !27 !28 !29 !41) -!43 = (!26 !27 !28 !29) -!44 = (!26 !27 !28 !29 !41) -!45 = span !6 140282 140336 -!46 = (!26 !27 !45) -!47 = span !6 140355 140361 -!48 = (!26 !27 !47) -!49 = span !6 140341 140362 -!50 = fn_call_path_span !6 140341 140354 -!51 = span !6 73247 73275 -!52 = fn_call_path_span !6 73254 73266 -!53 = span !6 625 637 -!54 = (!26 !27 !49 !50 !51 !52 !53) -!55 = (!26 !27 !49 !50 !51 !52) -!56 = span !6 2766 2847 -!57 = (!26 !27 !49 !50 !51 !52 !56) -!58 = span !6 2804 2817 -!59 = span !6 2857 2896 -!60 = (!26 !27 !49 !50 !51 !52 !59) -!61 = span !6 73285 73319 -!62 = (!26 !27 !49 !50 !61) -!63 = span !6 73336 73340 -!64 = (!26 !27 !49 !50 !63) -!65 = span !6 73336 73346 -!66 = fn_call_path_span !6 73341 73344 -!67 = (!26 !27 !49 !50 !65 !66) -!68 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/raw_slice.sw" -!69 = span !68 2922 2926 -!70 = (!26 !27 !49 !50 !65 !66 !69) -!71 = span !68 2911 2927 -!72 = fn_call_path_span !68 2911 2921 -!73 = (!26 !27 !49 !50 !65 !66 !71 !72) -!74 = span !68 1633 1638 -!75 = (!26 !27 !49 !50 !65 !66 !71 !72 !74) -!76 = span !68 2928 2929 -!77 = (!26 !27 !49 !50 !65 !66 !76) -!78 = span !6 73335 73352 -!79 = (!26 !27 !49 !50 !78) -!80 = (!26 !27 !49 !50 !78) -!81 = (!26 !27 !49 !50 !78) -!82 = (!26 !27 !49 !50 !78) -!83 = span !0 101 148 -!84 = span !0 164 176 -!85 = span !0 180 192 -!86 = span !0 164 192 -!87 = span !0 219 226 -!88 = span !0 219 250 -!89 = fn_call_path_span !0 227 233 -!90 = span !6 3959 3978 -!91 = fn_call_path_span !6 3959 3972 -!92 = span !6 115441 115466 -!93 = (!88 !89 !90 !91 !92) -!94 = (!88 !89 !90 !91 !92) -!95 = span !0 195 251 -!96 = span !0 324 328 -!97 = span !0 329 330 -!98 = span !0 296 331 -!99 = fn_call_path_span !0 296 323 -!100 = (!98 !99) -!101 = "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw" -!102 = span !101 4062 4063 -!103 = (!98 !99 !102) -!104 = span !0 272 332 -!105 = span !0 377 384 -!106 = span !0 358 385 -!107 = fn_call_path_span !0 358 364 -!108 = (!106 !107) -!109 = span !6 70852 70856 -!110 = (!106 !107 !109) -!111 = span !6 70839 70883 -!112 = (!106 !107 !111) -!113 = span !6 70888 70894 -!114 = (!106 !107 !113) -!115 = span !0 333 386 -!116 = span !0 422 429 -!117 = span !0 422 435 -!118 = fn_call_path_span !0 430 433 -!119 = (!117 !118) -!120 = (!117 !118 !69) -!121 = (!117 !118 !71 !72) -!122 = (!117 !118 !71 !72 !74) -!123 = (!117 !118 !76) -!124 = span !0 437 444 -!125 = span !0 407 457 -!126 = span !0 464 476 -!127 = span !0 480 492 -!128 = span !0 464 492 -!129 = span !0 519 526 -!130 = span !0 519 550 -!131 = fn_call_path_span !0 527 533 -!132 = (!130 !131 !90 !91 !92) -!133 = (!130 !131 !90 !91 !92) -!134 = span !0 495 551 -!135 = span !0 624 628 -!136 = span !0 629 630 -!137 = span !0 596 631 -!138 = fn_call_path_span !0 596 623 -!139 = (!137 !138) -!140 = span !101 4156 4157 -!141 = (!137 !138 !140) -!142 = span !0 572 632 -!143 = span !0 677 684 -!144 = span !0 658 685 -!145 = fn_call_path_span !0 658 664 -!146 = (!144 !145) -!147 = (!144 !145 !109) -!148 = (!144 !145 !111) -!149 = (!144 !145 !113) -!150 = span !0 633 686 -!151 = span !0 722 729 -!152 = span !0 722 735 -!153 = fn_call_path_span !0 730 733 -!154 = (!152 !153) -!155 = (!152 !153 !69) -!156 = (!152 !153 !71 !72) -!157 = (!152 !153 !71 !72 !74) -!158 = (!152 !153 !76) -!159 = span !0 737 744 -!160 = span !0 707 757 -!161 = span !0 764 776 -!162 = span !0 780 793 -!163 = span !0 764 793 -!164 = span !0 821 828 -!165 = span !0 821 853 -!166 = fn_call_path_span !0 829 835 -!167 = (!165 !166 !90 !91 !92) -!168 = (!165 !166 !90 !91 !92) -!169 = span !0 796 854 -!170 = span !0 929 933 -!171 = span !0 934 935 -!172 = span !0 900 936 -!173 = fn_call_path_span !0 900 928 -!174 = (!172 !173) -!175 = span !101 4359 4360 -!176 = (!172 !173 !175) -!177 = span !0 875 937 -!178 = span !0 983 990 -!179 = span !0 963 991 -!180 = fn_call_path_span !0 963 969 -!181 = (!179 !180) -!182 = (!179 !180 !109) -!183 = (!179 !180 !111) -!184 = (!179 !180 !113) -!185 = span !0 938 992 -!186 = span !0 1028 1035 -!187 = span !0 1028 1041 -!188 = fn_call_path_span !0 1036 1039 -!189 = (!187 !188) -!190 = (!187 !188 !69) -!191 = (!187 !188 !71 !72) -!192 = (!187 !188 !71 !72 !74) -!193 = (!187 !188 !76) -!194 = span !0 1043 1050 -!195 = span !0 1013 1063 -!196 = span !0 1070 1082 -!197 = span !0 1086 1099 -!198 = span !0 1070 1099 -!199 = span !0 1127 1134 -!200 = span !0 1127 1159 -!201 = fn_call_path_span !0 1135 1141 -!202 = (!200 !201 !90 !91 !92) -!203 = (!200 !201 !90 !91 !92) -!204 = span !0 1102 1160 -!205 = span !0 1235 1239 -!206 = span !0 1240 1241 -!207 = span !0 1206 1242 -!208 = fn_call_path_span !0 1206 1234 -!209 = (!207 !208) -!210 = span !101 4458 4459 -!211 = (!207 !208 !210) -!212 = span !0 1181 1243 -!213 = span !0 1289 1296 -!214 = span !0 1269 1297 -!215 = fn_call_path_span !0 1269 1275 -!216 = (!214 !215) -!217 = (!214 !215 !109) -!218 = (!214 !215 !111) -!219 = (!214 !215 !113) -!220 = span !0 1244 1298 -!221 = span !0 1334 1341 -!222 = span !0 1334 1347 -!223 = fn_call_path_span !0 1342 1345 -!224 = (!222 !223) -!225 = (!222 !223 !69) -!226 = (!222 !223 !71 !72) -!227 = (!222 !223 !71 !72 !74) -!228 = (!222 !223 !76) -!229 = span !0 1349 1356 -!230 = span !0 1319 1369 -!231 = span !0 1376 1388 -!232 = span !0 1392 1405 -!233 = span !0 1376 1405 -!234 = span !0 1433 1440 -!235 = span !0 1433 1465 -!236 = fn_call_path_span !0 1441 1447 -!237 = (!235 !236 !90 !91 !92) -!238 = (!235 !236 !90 !91 !92) -!239 = span !0 1408 1466 -!240 = span !0 1541 1545 -!241 = span !0 1546 1547 -!242 = span !0 1512 1548 -!243 = fn_call_path_span !0 1512 1540 -!244 = (!242 !243) -!245 = span !101 4557 4558 -!246 = (!242 !243 !245) -!247 = span !0 1487 1549 -!248 = span !0 1595 1602 -!249 = span !0 1575 1603 -!250 = fn_call_path_span !0 1575 1581 -!251 = (!249 !250) -!252 = (!249 !250 !109) -!253 = (!249 !250 !111) -!254 = (!249 !250 !113) -!255 = span !0 1550 1604 -!256 = span !0 1640 1647 -!257 = span !0 1640 1653 -!258 = fn_call_path_span !0 1648 1651 -!259 = (!257 !258) -!260 = (!257 !258 !69) -!261 = (!257 !258 !71 !72) -!262 = (!257 !258 !71 !72 !74) -!263 = (!257 !258 !76) -!264 = span !0 1655 1662 -!265 = span !0 1625 1675 -!266 = span !0 1682 1694 -!267 = span !0 1698 1710 -!268 = span !0 1682 1710 -!269 = span !0 1737 1744 -!270 = span !0 1737 1768 -!271 = fn_call_path_span !0 1745 1751 -!272 = (!270 !271 !90 !91 !92) -!273 = (!270 !271 !90 !91 !92) -!274 = span !0 1713 1769 -!275 = span !0 1842 1846 -!276 = span !0 1847 1848 -!277 = span !0 1814 1849 -!278 = fn_call_path_span !0 1814 1841 -!279 = (!277 !278) -!280 = span !101 4257 4258 -!281 = (!277 !278 !280) -!282 = (!277 !278 !280) -!283 = (!277 !278 !280 !109) -!284 = (!277 !278 !280 !111) -!285 = (!277 !278 !280 !113) -!286 = span !101 4261 4262 -!287 = (!277 !278 !286) -!288 = span !0 1790 1850 -!289 = span !0 1895 1902 -!290 = span !0 1876 1903 -!291 = fn_call_path_span !0 1876 1882 -!292 = (!290 !291) -!293 = (!290 !291 !109) -!294 = (!290 !291 !111) -!295 = (!290 !291 !113) -!296 = span !0 1851 1904 -!297 = span !0 1940 1947 -!298 = span !0 1940 1953 -!299 = fn_call_path_span !0 1948 1951 -!300 = (!298 !299) -!301 = (!298 !299 !69) -!302 = (!298 !299 !71 !72) -!303 = (!298 !299 !71 !72 !74) -!304 = (!298 !299 !76) -!305 = span !0 1955 1962 -!306 = span !0 1925 1975 -!307 = span !0 1982 1994 -!308 = span !0 1998 2007 -!309 = span !0 1982 2007 -!310 = span !0 2030 2037 -!311 = span !0 2030 2057 -!312 = fn_call_path_span !0 2038 2044 -!313 = (!311 !312 !90 !91 !92) -!314 = (!311 !312 !90 !91 !92) -!315 = span !0 2010 2058 -!316 = span !0 2124 2128 -!317 = span !0 2129 2130 -!318 = span !0 2099 2131 -!319 = fn_call_path_span !0 2099 2123 -!320 = (!318 !319) -!321 = span !101 3540 3541 -!322 = (!318 !319 !321) -!323 = span !0 2079 2132 -!324 = span !0 2173 2180 -!325 = span !0 2158 2181 -!326 = fn_call_path_span !0 2158 2164 -!327 = (!325 !326) -!328 = (!325 !326 !109) -!329 = (!325 !326 !111) -!330 = (!325 !326 !113) -!331 = span !0 2133 2182 -!332 = span !0 2218 2225 -!333 = span !0 2218 2231 -!334 = fn_call_path_span !0 2226 2229 -!335 = (!333 !334) -!336 = (!333 !334 !69) -!337 = (!333 !334 !71 !72) -!338 = (!333 !334 !71 !72 !74) -!339 = (!333 !334 !76) -!340 = span !0 2233 2240 -!341 = span !0 2203 2253 -!342 = span !0 2260 2272 -!343 = span !0 2276 2285 -!344 = span !0 2260 2285 -!345 = span !0 2308 2315 -!346 = span !0 2308 2335 -!347 = fn_call_path_span !0 2316 2322 -!348 = span !6 115442 115463 -!349 = fn_call_path_span !6 115442 115455 -!350 = span !6 72847 72866 -!351 = fn_call_path_span !6 72854 72858 -!352 = (!346 !347 !90 !91 !348 !349 !350 !351) -!353 = span !6 72881 72882 -!354 = span !6 72881 72892 -!355 = fn_call_path_span !6 72881 72892 -!356 = (!346 !347 !90 !91 !348 !349 !354 !355) -!357 = span !6 72886 72891 -!358 = (!346 !347 !90 !91 !348 !349 !354) -!359 = span !6 72905 72906 -!360 = span !6 72905 72915 -!361 = fn_call_path_span !6 72905 72915 -!362 = (!346 !347 !90 !91 !348 !349 !360 !361) -!363 = span !6 72910 72914 -!364 = (!346 !347 !90 !91 !348 !349 !360) -!365 = span !6 72942 72943 -!366 = span !6 72933 72944 -!367 = (!346 !347 !90 !91 !348 !349 !366) -!368 = (!346 !347 !90 !91 !92) -!369 = (!346 !347 !90 !91 !92) -!370 = (!346 !347 !90 !91 !92) -!371 = span !0 2288 2336 -!372 = span !0 2402 2406 -!373 = span !0 2407 2408 -!374 = span !0 2436 2459 -!375 = fn_call_path_span !0 2436 2442 -!376 = (!374 !375 !111) -!377 = (!374 !375 !113) -!378 = span !0 2411 2460 -!379 = span !0 2496 2503 -!380 = span !0 2496 2509 -!381 = fn_call_path_span !0 2504 2507 -!382 = (!380 !381) -!383 = (!380 !381 !69) -!384 = (!380 !381 !71 !72) -!385 = (!380 !381 !71 !72 !74) -!386 = (!380 !381 !76) -!387 = span !0 2511 2518 -!388 = span !0 2481 2531 -!389 = span !0 2538 2550 -!390 = span !0 2554 2567 -!391 = span !0 2538 2567 -!392 = span !0 2593 2600 -!393 = span !0 2593 2623 -!394 = fn_call_path_span !0 2601 2607 -!395 = (!393 !394 !90 !91 !92) -!396 = (!393 !394 !90 !91 !92) -!397 = span !0 2570 2624 -!398 = span !0 2697 2701 -!399 = span !0 2702 2703 -!400 = span !0 2668 2704 -!401 = fn_call_path_span !0 2668 2696 -!402 = (!400 !401) -!403 = span !101 5528 5529 -!404 = (!400 !401 !403) -!405 = span !0 2645 2705 -!406 = span !0 2749 2756 -!407 = span !0 2731 2757 -!408 = fn_call_path_span !0 2731 2737 -!409 = (!407 !408) -!410 = (!407 !408 !109) -!411 = (!407 !408 !111) -!412 = (!407 !408 !113) -!413 = span !0 2706 2758 -!414 = span !0 2794 2801 -!415 = span !0 2794 2807 -!416 = fn_call_path_span !0 2802 2805 -!417 = (!415 !416) -!418 = (!415 !416 !69) -!419 = (!415 !416 !71 !72) -!420 = (!415 !416 !71 !72 !74) -!421 = (!415 !416 !76) -!422 = span !0 2809 2816 -!423 = span !0 2779 2829 -!424 = span !0 2836 2848 -!425 = span !0 2852 2869 -!426 = span !0 2836 2869 -!427 = span !0 2900 2907 -!428 = span !0 2900 2935 -!429 = fn_call_path_span !0 2908 2914 -!430 = (!428 !429 !90 !91 !92) -!431 = (!428 !429 !90 !91 !92) -!432 = span !0 2872 2936 -!433 = span !0 3018 3022 -!434 = span !0 3023 3024 -!435 = span !0 2985 3025 -!436 = fn_call_path_span !0 2985 3017 -!437 = (!435 !436) -!438 = span !101 5643 5644 -!439 = (!435 !436 !438) -!440 = span !0 2957 3026 -!441 = span !0 3075 3082 -!442 = span !0 3052 3083 -!443 = fn_call_path_span !0 3052 3058 -!444 = (!442 !443) -!445 = (!442 !443 !109) -!446 = (!442 !443 !111) -!447 = (!442 !443 !113) -!448 = span !0 3027 3084 -!449 = span !0 3120 3127 -!450 = span !0 3120 3133 -!451 = fn_call_path_span !0 3128 3131 -!452 = (!450 !451) -!453 = (!450 !451 !69) -!454 = (!450 !451 !71 !72) -!455 = (!450 !451 !71 !72 !74) -!456 = (!450 !451 !76) -!457 = span !0 3135 3142 -!458 = span !0 3105 3155 -!459 = span !0 3162 3174 -!460 = span !0 3178 3199 -!461 = span !0 3162 3199 -!462 = span !0 3235 3242 -!463 = span !0 3235 3275 -!464 = fn_call_path_span !0 3243 3249 -!465 = (!463 !464 !90 !91 !92) -!466 = (!463 !464 !90 !91 !92) -!467 = span !0 3202 3276 -!468 = span !0 3367 3371 -!469 = span !0 3372 3373 -!470 = span !0 3330 3374 -!471 = fn_call_path_span !0 3330 3366 -!472 = (!470 !471) -!473 = span !101 5780 5781 -!474 = (!470 !471 !473) -!475 = span !0 3297 3375 -!476 = span !0 3429 3436 -!477 = span !0 3401 3437 -!478 = fn_call_path_span !0 3401 3407 -!479 = (!477 !478) -!480 = (!477 !478 !109) -!481 = (!477 !478 !111) -!482 = (!477 !478 !113) -!483 = span !0 3376 3438 -!484 = span !0 3474 3481 -!485 = span !0 3474 3487 -!486 = fn_call_path_span !0 3482 3485 -!487 = (!485 !486) -!488 = (!485 !486 !69) -!489 = (!485 !486 !71 !72) -!490 = (!485 !486 !71 !72 !74) -!491 = (!485 !486 !76) -!492 = span !0 3489 3496 -!493 = span !0 3459 3509 -!494 = span !0 3516 3528 -!495 = span !0 3532 3542 -!496 = span !0 3516 3542 -!497 = span !0 3567 3574 -!498 = span !0 3567 3596 -!499 = fn_call_path_span !0 3575 3581 -!500 = span !6 73547 73579 -!501 = (!498 !499 !90 !91 !348 !349 !500) -!502 = span !6 73595 73599 -!503 = (!498 !499 !90 !91 !348 !349 !502) -!504 = span !6 73595 73605 -!505 = fn_call_path_span !6 73600 73603 -!506 = (!498 !499 !90 !91 !348 !349 !504 !505) -!507 = (!498 !499 !90 !91 !348 !349 !504 !505 !69) -!508 = (!498 !499 !90 !91 !348 !349 !504 !505 !71 !72) -!509 = (!498 !499 !90 !91 !348 !349 !504 !505 !71 !72 !74) -!510 = (!498 !499 !90 !91 !348 !349 !504 !505 !76) -!511 = (!498 !499 !90 !91 !92) -!512 = (!498 !499 !90 !91 !92) -!513 = span !0 3545 3597 -!514 = span !0 3666 3670 -!515 = span !0 3671 3672 -!516 = span !0 3640 3673 -!517 = fn_call_path_span !0 3640 3665 -!518 = (!516 !517) -!519 = span !101 3624 3625 -!520 = (!516 !517 !519) -!521 = span !0 3618 3674 -!522 = span !0 3717 3724 -!523 = span !0 3700 3725 -!524 = fn_call_path_span !0 3700 3706 -!525 = (!523 !524) -!526 = (!523 !524 !109) -!527 = (!523 !524 !111) -!528 = (!523 !524 !113) -!529 = span !0 3675 3726 -!530 = span !0 3762 3769 -!531 = span !0 3762 3775 -!532 = fn_call_path_span !0 3770 3773 -!533 = (!531 !532) -!534 = (!531 !532 !69) -!535 = (!531 !532 !71 !72) -!536 = (!531 !532 !71 !72 !74) -!537 = (!531 !532 !76) -!538 = span !0 3777 3784 -!539 = span !0 3747 3797 -!540 = span !0 3804 3816 -!541 = span !0 3820 3830 -!542 = span !0 3804 3830 -!543 = span !0 3855 3862 -!544 = span !0 3855 3884 -!545 = fn_call_path_span !0 3863 3869 -!546 = (!544 !545 !90 !91 !348 !349 !500) -!547 = (!544 !545 !90 !91 !348 !349 !502) -!548 = (!544 !545 !90 !91 !348 !349 !504 !505) -!549 = (!544 !545 !90 !91 !348 !349 !504 !505 !69) -!550 = (!544 !545 !90 !91 !348 !349 !504 !505 !71 !72) -!551 = (!544 !545 !90 !91 !348 !349 !504 !505 !71 !72 !74) -!552 = (!544 !545 !90 !91 !348 !349 !504 !505 !76) -!553 = (!544 !545 !90 !91 !92) -!554 = (!544 !545 !90 !91 !92) -!555 = span !0 3833 3885 -!556 = span !0 3954 3958 -!557 = span !0 3959 3960 -!558 = span !0 3928 3961 -!559 = fn_call_path_span !0 3928 3953 -!560 = (!558 !559) -!561 = span !101 3708 3709 -!562 = (!558 !559 !561) -!563 = span !0 3906 3962 -!564 = span !0 4005 4012 -!565 = span !0 3988 4013 -!566 = fn_call_path_span !0 3988 3994 -!567 = (!565 !566) -!568 = (!565 !566 !109) -!569 = (!565 !566 !111) -!570 = (!565 !566 !113) -!571 = span !0 3963 4014 -!572 = span !0 4050 4057 -!573 = span !0 4050 4063 -!574 = fn_call_path_span !0 4058 4061 -!575 = (!573 !574) -!576 = (!573 !574 !69) -!577 = (!573 !574 !71 !72) -!578 = (!573 !574 !71 !72 !74) -!579 = (!573 !574 !76) -!580 = span !0 4065 4072 -!581 = span !0 4035 4085 -!582 = span !0 4092 4104 -!583 = span !0 4108 4119 -!584 = span !0 4092 4119 -!585 = span !0 4145 4152 -!586 = span !0 4145 4175 -!587 = fn_call_path_span !0 4153 4159 -!588 = (!586 !587 !90 !91 !348 !349 !500) -!589 = (!586 !587 !90 !91 !348 !349 !502) -!590 = (!586 !587 !90 !91 !348 !349 !504 !505) -!591 = (!586 !587 !90 !91 !348 !349 !504 !505 !69) -!592 = (!586 !587 !90 !91 !348 !349 !504 !505 !71 !72) -!593 = (!586 !587 !90 !91 !348 !349 !504 !505 !71 !72 !74) -!594 = (!586 !587 !90 !91 !348 !349 !504 !505 !76) -!595 = (!586 !587 !90 !91 !92) -!596 = (!586 !587 !90 !91 !92) -!597 = span !0 4122 4176 -!598 = span !0 4247 4251 -!599 = span !0 4252 4253 -!600 = span !0 4220 4254 -!601 = fn_call_path_span !0 4220 4246 -!602 = (!600 !601) -!603 = span !101 3880 3881 -!604 = (!600 !601 !603) -!605 = span !0 4197 4255 -!606 = span !0 4299 4306 -!607 = span !0 4281 4307 -!608 = fn_call_path_span !0 4281 4287 -!609 = (!607 !608) -!610 = (!607 !608 !109) -!611 = (!607 !608 !111) -!612 = (!607 !608 !113) -!613 = span !0 4256 4308 -!614 = span !0 4344 4351 -!615 = span !0 4344 4357 -!616 = fn_call_path_span !0 4352 4355 -!617 = (!615 !616) -!618 = (!615 !616 !69) -!619 = (!615 !616 !71 !72) -!620 = (!615 !616 !71 !72 !74) -!621 = (!615 !616 !76) -!622 = span !0 4359 4366 -!623 = span !0 4329 4379 -!624 = span !0 4386 4398 -!625 = span !0 4402 4413 -!626 = span !0 4386 4413 -!627 = span !0 4439 4446 -!628 = span !0 4439 4469 -!629 = fn_call_path_span !0 4447 4453 -!630 = (!628 !629 !90 !91 !348 !349 !500) -!631 = (!628 !629 !90 !91 !348 !349 !502) -!632 = (!628 !629 !90 !91 !348 !349 !504 !505) -!633 = (!628 !629 !90 !91 !348 !349 !504 !505 !69) -!634 = (!628 !629 !90 !91 !348 !349 !504 !505 !71 !72) -!635 = (!628 !629 !90 !91 !348 !349 !504 !505 !71 !72 !74) -!636 = (!628 !629 !90 !91 !348 !349 !504 !505 !76) -!637 = (!628 !629 !90 !91 !92) -!638 = (!628 !629 !90 !91 !92) -!639 = span !0 4416 4470 -!640 = span !0 4541 4545 -!641 = span !0 4546 4547 -!642 = span !0 4514 4548 -!643 = fn_call_path_span !0 4514 4540 -!644 = (!642 !643) -!645 = span !101 3969 3970 -!646 = (!642 !643 !645) -!647 = span !0 4491 4549 -!648 = span !0 4593 4600 -!649 = span !0 4575 4601 -!650 = fn_call_path_span !0 4575 4581 -!651 = (!649 !650) -!652 = (!649 !650 !109) -!653 = (!649 !650 !111) -!654 = (!649 !650 !113) -!655 = span !0 4550 4602 -!656 = span !0 4638 4645 -!657 = span !0 4638 4651 -!658 = fn_call_path_span !0 4646 4649 -!659 = (!657 !658) -!660 = (!657 !658 !69) -!661 = (!657 !658 !71 !72) -!662 = (!657 !658 !71 !72 !74) -!663 = (!657 !658 !76) -!664 = span !0 4653 4660 -!665 = span !0 4623 4673 -!666 = span !0 4680 4692 -!667 = span !0 4696 4706 -!668 = span !0 4680 4706 -!669 = span !0 4731 4738 -!670 = span !0 4731 4760 -!671 = fn_call_path_span !0 4739 4745 -!672 = (!670 !671 !90 !91 !348 !349 !500) -!673 = (!670 !671 !90 !91 !348 !349 !502) -!674 = (!670 !671 !90 !91 !348 !349 !504 !505) -!675 = (!670 !671 !90 !91 !348 !349 !504 !505 !69) -!676 = (!670 !671 !90 !91 !348 !349 !504 !505 !71 !72) -!677 = (!670 !671 !90 !91 !348 !349 !504 !505 !71 !72 !74) -!678 = (!670 !671 !90 !91 !348 !349 !504 !505 !76) -!679 = (!670 !671 !90 !91 !92) -!680 = (!670 !671 !90 !91 !92) -!681 = span !0 4709 4761 -!682 = span !0 4830 4834 -!683 = span !0 4835 4836 -!684 = span !0 4804 4837 -!685 = fn_call_path_span !0 4804 4829 -!686 = (!684 !685) -!687 = span !101 3792 3793 -!688 = (!684 !685 !687) -!689 = span !0 4782 4838 -!690 = span !0 4881 4888 -!691 = span !0 4864 4889 -!692 = fn_call_path_span !0 4864 4870 -!693 = (!691 !692) -!694 = (!691 !692 !109) -!695 = (!691 !692 !111) -!696 = (!691 !692 !113) -!697 = span !0 4839 4890 -!698 = span !0 4926 4933 -!699 = span !0 4926 4939 -!700 = fn_call_path_span !0 4934 4937 -!701 = (!699 !700) -!702 = (!699 !700 !69) -!703 = (!699 !700 !71 !72) -!704 = (!699 !700 !71 !72 !74) -!705 = (!699 !700 !76) -!706 = span !0 4941 4948 -!707 = span !0 4911 4961 -!708 = span !0 4968 4980 -!709 = span !0 4984 4999 -!710 = span !0 4968 4999 -!711 = span !0 5025 5032 -!712 = span !0 5025 5055 -!713 = fn_call_path_span !0 5033 5039 -!714 = (!712 !713 !90 !91 !92) -!715 = (!712 !713 !90 !91 !92) -!716 = span !0 5002 5056 -!717 = span !0 5131 5135 -!718 = span !0 5136 5137 -!719 = span !0 5100 5138 -!720 = fn_call_path_span !0 5100 5130 -!721 = (!719 !720) -!722 = span !101 4730 4731 -!723 = (!719 !720 !722) -!724 = span !0 5077 5139 -!725 = span !0 5183 5190 -!726 = span !0 5165 5191 -!727 = fn_call_path_span !0 5165 5171 -!728 = (!726 !727) -!729 = (!726 !727 !109) -!730 = (!726 !727 !111) -!731 = (!726 !727 !113) -!732 = span !0 5140 5192 -!733 = span !0 5228 5235 -!734 = span !0 5228 5241 -!735 = fn_call_path_span !0 5236 5239 -!736 = (!734 !735) -!737 = (!734 !735 !69) -!738 = (!734 !735 !71 !72) -!739 = (!734 !735 !71 !72 !74) -!740 = (!734 !735 !76) -!741 = span !0 5243 5250 -!742 = span !0 5213 5263 -!743 = span !0 5270 5282 -!744 = span !0 5286 5305 -!745 = span !0 5270 5305 -!746 = span !0 5336 5343 -!747 = span !0 5336 5371 -!748 = fn_call_path_span !0 5344 5350 -!749 = (!747 !748 !90 !91 !92) -!750 = (!747 !748 !90 !91 !92) -!751 = span !0 5308 5372 -!752 = span !0 5456 5460 -!753 = span !0 5461 5462 -!754 = span !0 5421 5463 -!755 = fn_call_path_span !0 5421 5455 -!756 = (!754 !755) -!757 = span !101 5278 5279 -!758 = (!754 !755 !757) -!759 = span !0 5393 5464 -!760 = span !0 5513 5520 -!761 = span !0 5490 5521 -!762 = fn_call_path_span !0 5490 5496 -!763 = (!761 !762) -!764 = (!761 !762 !109) -!765 = (!761 !762 !111) -!766 = (!761 !762 !113) -!767 = span !0 5465 5522 -!768 = span !0 5558 5565 -!769 = span !0 5558 5571 -!770 = fn_call_path_span !0 5566 5569 -!771 = (!769 !770) -!772 = (!769 !770 !69) -!773 = (!769 !770 !71 !72) -!774 = (!769 !770 !71 !72 !74) -!775 = (!769 !770 !76) -!776 = span !0 5573 5580 -!777 = span !0 5543 5593 -!778 = span !0 5600 5612 -!779 = span !0 5616 5639 -!780 = span !0 5600 5639 -!781 = span !0 5675 5682 -!782 = span !0 5675 5715 -!783 = fn_call_path_span !0 5683 5689 -!784 = (!782 !783 !90 !91 !92) -!785 = (!782 !783 !90 !91 !92) -!786 = span !0 5642 5716 -!787 = span !0 5809 5813 -!788 = span !0 5814 5815 -!789 = span !0 5770 5816 -!790 = fn_call_path_span !0 5770 5808 -!791 = (!789 !790) -!792 = span !101 4936 4937 -!793 = (!789 !790 !792) -!794 = span !0 5737 5817 -!795 = span !0 5871 5878 -!796 = span !0 5843 5879 -!797 = fn_call_path_span !0 5843 5849 -!798 = (!796 !797) -!799 = (!796 !797 !109) -!800 = (!796 !797 !111) -!801 = (!796 !797 !113) -!802 = span !0 5818 5880 -!803 = span !0 5916 5923 -!804 = span !0 5916 5929 -!805 = fn_call_path_span !0 5924 5927 -!806 = (!804 !805) -!807 = (!804 !805 !69) -!808 = (!804 !805 !71 !72) -!809 = (!804 !805 !71 !72 !74) -!810 = (!804 !805 !76) -!811 = span !0 5931 5938 -!812 = span !0 5901 5951 -!813 = span !0 5958 5970 -!814 = span !0 5974 5986 -!815 = span !0 5958 5986 -!816 = span !0 6007 6032 -!817 = fn_call_path_span !0 6015 6021 -!818 = (!816 !817 !90 !91 !92) -!819 = (!816 !817 !90 !91 !92) -!820 = (!816 !817 !90 !91 !92) -!821 = span !0 5989 6033 -!822 = span !0 6124 6147 -!823 = span !0 6149 6150 -!824 = span !0 6109 6151 -!825 = span !0 6158 6170 -!826 = span !0 6174 6186 -!827 = span !0 6158 6186 -!828 = span !0 6211 6218 -!829 = span !0 6211 6240 -!830 = fn_call_path_span !0 6219 6225 -!831 = span !6 71904 71932 -!832 = fn_call_path_span !6 71911 71923 -!833 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832 !53) -!834 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832) -!835 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832 !56) -!836 = (!829 !830 !90 !91 !348 !349 !348 !349 !831 !832 !59) -!837 = (!829 !830 !90 !91 !348 !349 !92) -!838 = (!829 !830 !90 !91 !348 !349 !92) -!839 = (!829 !830 !90 !91 !348 !349 !92) -!840 = (!829 !830 !90 !91 !92) -!841 = (!829 !830 !90 !91 !92) -!842 = span !0 6189 6241 -!843 = span !0 6312 6316 -!844 = span !0 6317 6318 -!845 = span !0 6284 6319 -!846 = fn_call_path_span !0 6284 6311 -!847 = (!845 !846) -!848 = (!845 !846 !722) -!849 = span !0 6262 6320 -!850 = span !0 6363 6370 -!851 = span !0 6346 6371 -!852 = fn_call_path_span !0 6346 6352 -!853 = (!851 !852) -!854 = (!851 !852 !109) -!855 = (!851 !852 !111) -!856 = (!851 !852 !113) -!857 = span !0 6321 6372 -!858 = span !0 6408 6415 -!859 = span !0 6408 6421 -!860 = fn_call_path_span !0 6416 6419 -!861 = (!859 !860) -!862 = (!859 !860 !69) -!863 = (!859 !860 !71 !72) -!864 = (!859 !860 !71 !72 !74) -!865 = (!859 !860 !76) -!866 = span !0 6423 6430 -!867 = span !0 6393 6443 -!868 = span !0 6450 6462 -!869 = span !0 6466 6478 -!870 = span !0 6450 6478 -!871 = span !0 6507 6514 -!872 = span !0 6507 6540 -!873 = fn_call_path_span !0 6515 6521 -!874 = (!872 !873 !90 !91 !92) -!875 = (!872 !873 !90 !91 !92) -!876 = span !0 6481 6541 -!877 = span !0 6616 6620 -!878 = span !0 6621 6622 -!879 = span !0 6588 6623 -!880 = fn_call_path_span !0 6588 6615 -!881 = (!879 !880) -!882 = (!879 !880 !757) -!883 = span !0 6562 6624 -!884 = span !0 6671 6678 -!885 = span !0 6650 6679 -!886 = fn_call_path_span !0 6650 6656 -!887 = (!885 !886) -!888 = (!885 !886 !109) -!889 = (!885 !886 !111) -!890 = (!885 !886 !113) -!891 = span !0 6625 6680 -!892 = span !0 6716 6723 -!893 = span !0 6716 6729 -!894 = fn_call_path_span !0 6724 6727 -!895 = (!893 !894) -!896 = (!893 !894 !69) -!897 = (!893 !894 !71 !72) -!898 = (!893 !894 !71 !72 !74) -!899 = (!893 !894 !76) -!900 = span !0 6731 6738 -!901 = span !0 6701 6751 -!902 = span !0 6758 6770 -!903 = span !0 6774 6786 -!904 = span !0 6758 6786 -!905 = span !0 6820 6827 -!906 = span !0 6820 6858 -!907 = fn_call_path_span !0 6828 6834 -!908 = (!906 !907 !90 !91 !92) -!909 = (!906 !907 !90 !91 !92) -!910 = span !0 6789 6859 -!911 = span !0 6939 6943 -!912 = span !0 6944 6945 -!913 = span !0 6911 6946 -!914 = fn_call_path_span !0 6911 6938 -!915 = (!913 !914) -!916 = (!913 !914 !792) -!917 = span !0 6880 6947 -!918 = span !0 6999 7006 -!919 = span !0 6973 7007 -!920 = fn_call_path_span !0 6973 6979 -!921 = (!919 !920) -!922 = (!919 !920 !109) -!923 = (!919 !920 !111) -!924 = (!919 !920 !113) -!925 = span !0 6948 7008 -!926 = span !0 7044 7051 -!927 = span !0 7044 7057 -!928 = fn_call_path_span !0 7052 7055 -!929 = (!927 !928) -!930 = (!927 !928 !69) -!931 = (!927 !928 !71 !72) -!932 = (!927 !928 !71 !72 !74) -!933 = (!927 !928 !76) -!934 = span !0 7059 7066 -!935 = span !0 7029 7079 -!936 = span !0 7086 7098 -!937 = span !0 7102 7114 -!938 = span !0 7086 7114 -!939 = span !0 7153 7160 -!940 = span !0 7153 7196 -!941 = fn_call_path_span !0 7161 7167 -!942 = (!940 !941 !90 !91 !92) -!943 = (!940 !941 !90 !91 !92) -!944 = span !0 7117 7197 -!945 = span !0 7282 7286 -!946 = span !0 7287 7288 -!947 = span !0 7254 7289 -!948 = fn_call_path_span !0 7254 7281 -!949 = (!947 !948) -!950 = span !101 5054 5055 -!951 = (!947 !948 !950) -!952 = span !0 7218 7290 -!953 = span !0 7347 7354 -!954 = span !0 7316 7355 -!955 = fn_call_path_span !0 7316 7322 -!956 = (!954 !955) -!957 = (!954 !955 !109) -!958 = (!954 !955 !111) -!959 = (!954 !955 !113) -!960 = span !0 7291 7356 -!961 = span !0 7392 7399 -!962 = span !0 7392 7405 -!963 = fn_call_path_span !0 7400 7403 -!964 = (!962 !963) -!965 = (!962 !963 !69) -!966 = (!962 !963 !71 !72) -!967 = (!962 !963 !71 !72 !74) -!968 = (!962 !963 !76) -!969 = span !0 7407 7414 -!970 = span !0 7377 7427 -!971 = span !0 7434 7446 -!972 = span !0 7450 7458 -!973 = span !0 7434 7458 -!974 = span !0 7480 7487 -!975 = span !0 7480 7506 -!976 = fn_call_path_span !0 7488 7494 -!977 = span !6 72535 72554 -!978 = fn_call_path_span !6 72542 72546 -!979 = (!975 !976 !90 !91 !348 !349 !977 !978) -!980 = span !6 72528 72555 -!981 = fn_call_path_span !6 72528 72534 -!982 = span !6 71980 72024 -!983 = (!975 !976 !90 !91 !348 !349 !980 !981 !982) -!984 = span !6 72580 72599 -!985 = fn_call_path_span !6 72587 72591 -!986 = (!975 !976 !90 !91 !348 !349 !984 !985) -!987 = span !6 72573 72600 -!988 = fn_call_path_span !6 72573 72579 -!989 = (!975 !976 !90 !91 !348 !349 !987 !988 !982) -!990 = span !6 72616 72617 -!991 = span !6 72611 72617 -!992 = fn_call_path_span !6 72613 72615 -!993 = (!975 !976 !90 !91 !348 !349 !991 !992) -!994 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/primitives.sw" -!995 = span !994 5415 5420 -!996 = (!975 !976 !90 !91 !348 !349 !991 !992) -!997 = span !6 72610 72622 -!998 = fn_call_path_span !6 72619 72620 -!999 = (!975 !976 !90 !91 !348 !349 !997 !998) -!1000 = (!975 !976 !90 !91 !92) -!1001 = (!975 !976 !90 !91 !92) -!1002 = (!975 !976 !90 !91 !92) -!1003 = span !0 7461 7507 -!1004 = span !0 7571 7575 -!1005 = span !0 7576 7577 -!1006 = span !0 7605 7627 -!1007 = fn_call_path_span !0 7605 7611 -!1008 = (!1006 !1007 !111) -!1009 = (!1006 !1007 !113) -!1010 = span !0 7580 7628 -!1011 = span !0 7664 7671 -!1012 = span !0 7664 7677 -!1013 = fn_call_path_span !0 7672 7675 -!1014 = (!1012 !1013) -!1015 = (!1012 !1013 !69) -!1016 = (!1012 !1013 !71 !72) -!1017 = (!1012 !1013 !71 !72 !74) -!1018 = (!1012 !1013 !76) -!1019 = span !0 7679 7686 -!1020 = span !0 7649 7699 -!1021 = span !0 7706 7718 -!1022 = span !0 7722 7731 -!1023 = span !0 7706 7731 -!1024 = span !0 7754 7761 -!1025 = span !0 7754 7781 -!1026 = fn_call_path_span !0 7762 7768 -!1027 = (!1025 !1026 !90 !91 !92) -!1028 = (!1025 !1026 !90 !91 !92) -!1029 = span !0 7734 7782 -!1030 = span !0 7848 7852 -!1031 = span !0 7853 7854 -!1032 = span !0 7823 7855 -!1033 = fn_call_path_span !0 7823 7847 -!1034 = (!1032 !1033) -!1035 = span !101 3461 3462 -!1036 = (!1032 !1033 !1035) -!1037 = span !0 7803 7856 -!1038 = span !0 7897 7904 -!1039 = span !0 7882 7905 -!1040 = fn_call_path_span !0 7882 7888 -!1041 = (!1039 !1040) -!1042 = (!1039 !1040 !109) -!1043 = (!1039 !1040 !111) -!1044 = (!1039 !1040 !113) -!1045 = span !0 7857 7906 -!1046 = span !0 7942 7949 -!1047 = span !0 7942 7955 -!1048 = fn_call_path_span !0 7950 7953 -!1049 = (!1047 !1048) -!1050 = (!1047 !1048 !69) -!1051 = (!1047 !1048 !71 !72) -!1052 = (!1047 !1048 !71 !72 !74) -!1053 = (!1047 !1048 !76) -!1054 = span !0 7957 7964 -!1055 = span !0 7927 7977 -!1056 = span !0 7984 7996 -!1057 = span !0 8000 8008 -!1058 = span !0 7984 8008 -!1059 = span !0 8030 8037 -!1060 = span !0 8030 8056 -!1061 = fn_call_path_span !0 8038 8044 -!1062 = (!1060 !1061 !90 !91 !348 !349) -!1063 = (!1060 !1061 !90 !91 !92) -!1064 = (!1060 !1061 !90 !91 !92) -!1065 = (!1060 !1061 !90 !91 !92) -!1066 = span !0 8011 8057 -!1067 = span !0 8121 8125 -!1068 = span !0 8126 8127 -!1069 = span !0 8155 8177 -!1070 = fn_call_path_span !0 8155 8161 -!1071 = (!1069 !1070 !111) -!1072 = (!1069 !1070 !113) -!1073 = span !0 8130 8178 -!1074 = span !0 8214 8221 -!1075 = span !0 8214 8227 -!1076 = fn_call_path_span !0 8222 8225 -!1077 = (!1075 !1076) -!1078 = (!1075 !1076 !69) -!1079 = (!1075 !1076 !71 !72) -!1080 = (!1075 !1076 !71 !72 !74) -!1081 = (!1075 !1076 !76) -!1082 = span !0 8229 8236 -!1083 = span !0 8199 8249 -!1084 = span !0 8256 8268 -!1085 = span !0 8272 8280 -!1086 = span !0 8256 8280 -!1087 = span !0 8302 8309 -!1088 = span !0 8302 8328 -!1089 = fn_call_path_span !0 8310 8316 -!1090 = (!1088 !1089 !90 !91 !348 !349 !831 !832 !53) -!1091 = (!1088 !1089 !90 !91 !348 !349 !831 !832) -!1092 = (!1088 !1089 !90 !91 !348 !349 !831 !832 !56) -!1093 = (!1088 !1089 !90 !91 !348 !349 !831 !832 !59) -!1094 = (!1088 !1089 !90 !91 !92) -!1095 = (!1088 !1089 !90 !91 !92) -!1096 = (!1088 !1089 !90 !91 !92) -!1097 = span !0 8283 8329 -!1098 = span !0 8393 8397 -!1099 = span !0 8398 8399 -!1100 = span !0 8427 8449 -!1101 = fn_call_path_span !0 8427 8433 -!1102 = (!1100 !1101 !111) -!1103 = (!1100 !1101 !113) -!1104 = span !0 8402 8450 -!1105 = span !0 8486 8493 -!1106 = span !0 8486 8499 -!1107 = fn_call_path_span !0 8494 8497 -!1108 = (!1106 !1107) -!1109 = (!1106 !1107 !69) -!1110 = (!1106 !1107 !71 !72) -!1111 = (!1106 !1107 !71 !72 !74) -!1112 = (!1106 !1107 !76) -!1113 = span !0 8501 8508 -!1114 = span !0 8471 8521 -!1115 = span !0 8528 8540 -!1116 = span !0 8544 8551 -!1117 = span !0 8528 8551 -!1118 = span !0 8572 8579 -!1119 = span !0 8572 8597 -!1120 = fn_call_path_span !0 8580 8586 -!1121 = span !6 72720 72739 -!1122 = fn_call_path_span !6 72727 72731 -!1123 = (!1119 !1120 !90 !91 !348 !349 !1121 !1122) -!1124 = (!1119 !1120 !90 !91 !92) -!1125 = (!1119 !1120 !90 !91 !92) -!1126 = (!1119 !1120 !90 !91 !92) -!1127 = span !0 8554 8598 -!1128 = span !0 8660 8664 -!1129 = span !0 8665 8666 -!1130 = span !0 8694 8715 -!1131 = fn_call_path_span !0 8694 8700 -!1132 = (!1130 !1131 !111) -!1133 = (!1130 !1131 !113) -!1134 = span !0 8669 8716 -!1135 = span !0 8752 8759 -!1136 = span !0 8752 8765 -!1137 = fn_call_path_span !0 8760 8763 -!1138 = (!1136 !1137) -!1139 = (!1136 !1137 !69) -!1140 = (!1136 !1137 !71 !72) -!1141 = (!1136 !1137 !71 !72 !74) -!1142 = (!1136 !1137 !76) -!1143 = span !0 8767 8774 -!1144 = span !0 8737 8787 -!1145 = span !0 8813 8816 -!1146 = span !0 8804 8817 -!1147 = span !6 3128 3132 -!1148 = span !6 3134 3139 -!1149 = span !6 3102 3321 -!1150 = fn_name_span !6 3109 3119 -!1151 = (!1149 !1150) -!1152 = span !6 3190 3207 -!1153 = span !6 3169 3248 -!1154 = span !6 3257 3300 -!1155 = span !6 3310 3315 -!1156 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/ops.sw" -!1157 = span !1156 35686 36058 -!1158 = fn_name_span !1156 35689 35691 -!1159 = (!1157 !1158) -!1160 = span !1156 35732 35736 -!1161 = span !1156 35746 35751 -!1162 = span !1156 35732 35757 -!1163 = fn_call_path_span !1156 35743 35745 -!1164 = span !1156 15555 15569 -!1165 = fn_call_path_span !1156 15560 15562 -!1166 = (!1162 !1163 !1164 !1165) -!1167 = span !1156 12573 12578 -!1168 = span !1156 15554 15576 -!1169 = fn_call_path_span !1156 15571 15574 -!1170 = (!1162 !1163 !1168 !1169) -!1171 = span !1156 35772 35777 -!1172 = span !1156 35822 35826 -!1173 = span !1156 35865 35870 -!1174 = span !1156 35901 35905 -!1175 = span !1156 35925 36042 -!1176 = span !1156 35987 36002 -!1177 = "test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core/src/str.sw" -!1178 = span !1177 281 403 -!1179 = fn_name_span !1177 288 291 -!1180 = (!1178 !1179) -!1181 = span !1177 337 341 -!1182 = span !1177 90 219 -!1183 = fn_name_span !1177 97 103 -!1184 = (!1182 !1183) -!1185 = span !1177 153 157 -!1186 = span !6 89760 89766 -!1187 = span !6 89738 90238 -!1188 = fn_name_span !6 89741 89751 -!1189 = inline "never" -!1190 = (!1187 !1188 !1189) -!1191 = span !6 89822 89842 -!1192 = span !6 89858 89864 -!1193 = (!1192 !111) -!1194 = (!1192 !113) -!1195 = span !6 89891 89904 -!1196 = span !6 89875 89905 -!1197 = span !6 89998 90003 -!1198 = span !6 90045 90046 -!1199 = (!1198 !111) -!1200 = (!1198 !113) -!1201 = span !6 90027 90028 -!1202 = span !6 90063 90068 -!1203 = fn_call_path_span !6 90065 90066 -!1204 = (!1202 !1203) -!1205 = span !6 90089 90090 -!1206 = (!1205 !111) -!1207 = (!1205 !113) -!1208 = span !6 90165 90185 -!1209 = fn_call_path_span !6 90172 90178 -!1210 = (!1208 !1209 !90 !91 !831 !832 !53) -!1211 = (!1208 !1209 !90 !91 !831 !832) -!1212 = (!1208 !1209 !90 !91 !831 !832 !56) -!1213 = (!1208 !1209 !90 !91 !831 !832 !59) -!1214 = span !6 90157 90185 -!1215 = span !6 90204 90205 -!1216 = span !6 90199 90205 -!1217 = fn_call_path_span !6 90201 90203 -!1218 = (!1216 !1217) -!1219 = span !6 4674 4678 -!1220 = span !6 4660 4805 -!1221 = fn_name_span !6 4663 4673 -!1222 = (!1220 !1221) -!1223 = span !6 4768 4774 -!1224 = span !6 87 114 -!1225 = span !6 4716 4799 -!1226 = span !6 160 260 -!1227 = fn_name_span !6 167 170 -!1228 = (!1226 !1227) -!1229 = span !6 191 254 -!1230 = span !6 499 591 -!1231 = fn_name_span !6 502 514 -!1232 = (!1230 !1231) -!1233 = span !6 573 577 -!1234 = span !6 20711 20939 -!1235 = fn_name_span !6 20714 20724 -!1236 = (!1234 !1235) -!1237 = span !6 20767 20791 -!1238 = span !6 20812 20813 -!1239 = span !6 20830 20835 -!1240 = fn_call_path_span !6 20832 20833 -!1241 = (!1239 !1240) -!1242 = span !6 20859 20863 -!1243 = span !6 20859 20866 -!1244 = span !6 20878 20884 -!1245 = span !6 20850 20885 -!1246 = span !6 20904 20905 -!1247 = span !6 20899 20905 -!1248 = fn_call_path_span !6 20901 20903 -!1249 = (!1247 !1248) -!1250 = span !6 20927 20933 -!1251 = span !68 3372 3452 -!1252 = fn_name_span !68 3379 3382 -!1253 = (!1251 !1252) -!1254 = span !68 3409 3425 -!1255 = fn_call_path_span !68 3409 3419 -!1256 = (!1254 !1255) -!1257 = (!1254 !1255 !74) -!1258 = (!1187 !1188 !1189) -!1259 = (!1192 !111) -!1260 = (!1192 !113) -!1261 = (!1198 !111) -!1262 = (!1198 !113) -!1263 = (!1202 !1203) -!1264 = (!1205 !111) -!1265 = (!1205 !113) -!1266 = (!1208 !1209 !90 !91 !831 !832 !53) -!1267 = (!1208 !1209 !90 !91 !831 !832) -!1268 = (!1208 !1209 !90 !91 !831 !832 !56) -!1269 = (!1208 !1209 !90 !91 !831 !832 !59) -!1270 = (!1216 !1217) -!1271 = (!1234 !1235) -!1272 = (!1239 !1240) -!1273 = (!1247 !1248) -!1274 = (!1187 !1188 !1189) -!1275 = (!1192 !111) -!1276 = (!1192 !113) -!1277 = (!1198 !111) -!1278 = (!1198 !113) -!1279 = (!1202 !1203) -!1280 = (!1205 !111) -!1281 = (!1205 !113) -!1282 = (!1208 !1209 !90 !91 !831 !832 !53) -!1283 = (!1208 !1209 !90 !91 !831 !832) -!1284 = (!1208 !1209 !90 !91 !831 !832 !56) -!1285 = (!1208 !1209 !90 !91 !831 !832 !59) -!1286 = (!1216 !1217) -!1287 = (!1234 !1235) -!1288 = (!1239 !1240) -!1289 = (!1247 !1248) -!1290 = (!1187 !1188 !1189) -!1291 = (!1192 !111) -!1292 = (!1192 !113) -!1293 = (!1198 !111) -!1294 = (!1198 !113) -!1295 = (!1202 !1203) -!1296 = (!1205 !111) -!1297 = (!1205 !113) -!1298 = (!1208 !1209 !90 !91 !831 !832 !53) -!1299 = (!1208 !1209 !90 !91 !831 !832) -!1300 = (!1208 !1209 !90 !91 !831 !832 !56) -!1301 = (!1208 !1209 !90 !91 !831 !832 !59) -!1302 = (!1216 !1217) -!1303 = (!1234 !1235) -!1304 = (!1239 !1240) -!1305 = (!1247 !1248) -!1306 = (!1187 !1188 !1189) -!1307 = (!1192 !111) -!1308 = (!1192 !113) -!1309 = (!1198 !111) -!1310 = (!1198 !113) -!1311 = (!1202 !1203) -!1312 = (!1205 !111) -!1313 = (!1205 !113) -!1314 = (!1208 !1209 !90 !91 !831 !832 !53) -!1315 = (!1208 !1209 !90 !91 !831 !832) -!1316 = (!1208 !1209 !90 !91 !831 !832 !56) -!1317 = (!1208 !1209 !90 !91 !831 !832 !59) -!1318 = (!1216 !1217) -!1319 = (!1234 !1235) -!1320 = (!1239 !1240) -!1321 = (!1247 !1248) -!1322 = (!1187 !1188 !1189) -!1323 = (!1192 !111) -!1324 = (!1192 !113) -!1325 = (!1198 !111) -!1326 = (!1198 !113) -!1327 = (!1202 !1203) -!1328 = (!1205 !111) -!1329 = (!1205 !113) -!1330 = (!1208 !1209 !90 !91 !831 !832 !53) -!1331 = (!1208 !1209 !90 !91 !831 !832) -!1332 = (!1208 !1209 !90 !91 !831 !832 !56) -!1333 = (!1208 !1209 !90 !91 !831 !832 !59) -!1334 = (!1216 !1217) -!1335 = (!1234 !1235) -!1336 = (!1239 !1240) -!1337 = (!1247 !1248) -!1338 = span !6 71602 71608 -!1339 = span !6 71580 71678 -!1340 = fn_name_span !6 71583 71593 -!1341 = (!1339 !1340) -!1342 = span !6 71642 71672 -!1343 = fn_call_path_span !6 71649 71662 -!1344 = (!1342 !1343 !53) -!1345 = (!1342 !1343) -!1346 = span !6 2972 3030 -!1347 = (!1342 !1343 !1346) -!1348 = span !6 3039 3079 -!1349 = (!1342 !1343 !1348) -!1350 = span !6 3089 3090 -!1351 = (!1342 !1343 !1350) -!1352 = span !6 4303 4448 -!1353 = fn_name_span !6 4306 4316 -!1354 = (!1352 !1353) -!1355 = span !6 4411 4417 -!1356 = span !6 4426 4430 -!1357 = span !6 4359 4442 -!1358 = span !6 3350 3354 -!1359 = span !6 3327 3871 -!1360 = fn_name_span !6 3334 3338 -!1361 = (!1359 !1360) -!1362 = span !6 3640 3733 -!1363 = span !6 3682 3695 -!1364 = span !6 3747 3786 -!1365 = span !6 4119 4123 -!1366 = span !6 4105 4250 -!1367 = fn_name_span !6 4108 4118 -!1368 = (!1366 !1367) -!1369 = span !6 4213 4219 -!1370 = span !6 4161 4244 -!1371 = span !0 174 180 -!1372 = span !0 152 359 -!1373 = fn_name_span !0 155 165 -!1374 = (!1372 !1373) -!1375 = span !0 245 267 -!1376 = fn_call_path_span !0 252 258 -!1377 = (!1375 !1376 !90 !91 !831 !832 !53) -!1378 = (!1375 !1376 !90 !91 !831 !832) -!1379 = (!1375 !1376 !90 !91 !831 !832 !56) -!1380 = (!1375 !1376 !90 !91 !831 !832 !59) -!1381 = span !0 285 286 -!1382 = span !0 285 318 -!1383 = fn_call_path_span !0 285 318 -!1384 = (!1382 !1383) -!1385 = span !101 274 293 -!1386 = span !0 296 316 -!1387 = fn_call_path_span !0 303 309 -!1388 = (!1386 !1387 !90 !91 !831 !832) -!1389 = (!1386 !1387 !90 !91 !831 !832 !56) -!1390 = (!1386 !1387 !90 !91 !831 !832 !59) -!1391 = span !0 335 336 -!1392 = span !0 326 337 -!1393 = span !0 152 492 -!1394 = (!1393 !1373) -!1395 = span !0 233 446 -!1396 = span !0 239 243 -!1397 = span !0 246 442 -!1398 = fn_call_path_span !0 246 442 -!1399 = (!1397 !1398) -!1400 = span !0 317 323 -!1401 = span !0 301 305 -!1402 = span !0 288 325 -!1403 = span !0 194 200 -!1404 = span !0 172 414 -!1405 = fn_name_span !0 175 185 -!1406 = (!1404 !1405) -!1407 = span !0 265 287 -!1408 = fn_call_path_span !0 272 278 -!1409 = (!1407 !1408 !90 !91 !831 !832 !53) -!1410 = (!1407 !1408 !90 !91 !831 !832) -!1411 = (!1407 !1408 !90 !91 !831 !832 !56) -!1412 = (!1407 !1408 !90 !91 !831 !832 !59) -!1413 = span !0 305 306 -!1414 = span !0 305 338 -!1415 = fn_call_path_span !0 305 338 -!1416 = (!1414 !1415) -!1417 = span !101 294 322 -!1418 = span !0 316 336 -!1419 = fn_call_path_span !0 323 329 -!1420 = (!1418 !1419 !90 !91 !831 !832) -!1421 = (!1418 !1419 !90 !91 !831 !832 !56) -!1422 = (!1418 !1419 !90 !91 !831 !832 !59) -!1423 = span !0 340 341 -!1424 = span !0 340 373 -!1425 = fn_call_path_span !0 340 373 -!1426 = (!1424 !1425) -!1427 = span !0 351 371 -!1428 = (!1427 !107 !90 !91 !831 !832) -!1429 = (!1427 !107 !90 !91 !831 !832 !56) -!1430 = (!1427 !107 !90 !91 !831 !832 !59) -!1431 = span !0 390 391 -!1432 = span !0 381 392 -!1433 = span !0 172 710 -!1434 = (!1433 !1405) -!1435 = span !0 253 664 -!1436 = span !0 259 263 -!1437 = span !0 266 462 -!1438 = fn_call_path_span !0 266 462 -!1439 = (!1437 !1438) -!1440 = span !0 337 343 -!1441 = span !0 321 325 -!1442 = span !0 308 345 -!1443 = span !0 464 660 -!1444 = fn_call_path_span !0 464 660 -!1445 = (!1443 !1444) -!1446 = span !0 535 541 -!1447 = span !0 519 523 -!1448 = span !0 506 543 -!1449 = span !0 214 220 -!1450 = span !0 192 469 -!1451 = fn_name_span !0 195 205 -!1452 = (!1450 !1451) -!1453 = span !0 285 307 -!1454 = fn_call_path_span !0 292 298 -!1455 = (!1453 !1454 !90 !91 !831 !832 !53) -!1456 = (!1453 !1454 !90 !91 !831 !832) -!1457 = (!1453 !1454 !90 !91 !831 !832 !56) -!1458 = (!1453 !1454 !90 !91 !831 !832 !59) -!1459 = span !0 325 326 -!1460 = span !0 325 358 -!1461 = fn_call_path_span !0 325 358 -!1462 = (!1460 !1461) -!1463 = span !101 323 360 -!1464 = span !0 336 356 -!1465 = fn_call_path_span !0 343 349 -!1466 = (!1464 !1465 !90 !91 !831 !832) -!1467 = (!1464 !1465 !90 !91 !831 !832 !56) -!1468 = (!1464 !1465 !90 !91 !831 !832 !59) -!1469 = span !0 360 361 -!1470 = span !0 360 393 -!1471 = fn_call_path_span !0 360 393 -!1472 = (!1470 !1471) -!1473 = span !0 371 391 -!1474 = fn_call_path_span !0 378 384 -!1475 = (!1473 !1474 !90 !91 !831 !832) -!1476 = (!1473 !1474 !90 !91 !831 !832 !56) -!1477 = (!1473 !1474 !90 !91 !831 !832 !59) -!1478 = span !0 395 396 -!1479 = span !0 395 428 -!1480 = fn_call_path_span !0 395 428 -!1481 = (!1479 !1480) -!1482 = span !0 406 426 -!1483 = fn_call_path_span !0 413 419 -!1484 = (!1482 !1483 !90 !91 !831 !832) -!1485 = (!1482 !1483 !90 !91 !831 !832 !56) -!1486 = (!1482 !1483 !90 !91 !831 !832 !59) -!1487 = span !0 445 446 -!1488 = span !0 436 447 -!1489 = span !0 192 928 -!1490 = (!1489 !1451) -!1491 = span !0 273 882 -!1492 = span !0 279 283 -!1493 = span !0 286 482 -!1494 = fn_call_path_span !0 286 482 -!1495 = (!1493 !1494) -!1496 = span !0 357 363 -!1497 = span !0 341 345 -!1498 = span !0 328 365 -!1499 = span !0 484 680 -!1500 = fn_call_path_span !0 484 680 -!1501 = (!1499 !1500) -!1502 = span !0 555 561 -!1503 = span !0 539 543 -!1504 = span !0 526 563 -!1505 = span !0 682 878 -!1506 = fn_call_path_span !0 682 878 -!1507 = (!1505 !1506) -!1508 = span !0 753 759 -!1509 = span !0 737 741 -!1510 = span !0 724 761 -!1511 = span !6 5645 5790 -!1512 = fn_name_span !6 5648 5658 -!1513 = (!1511 !1512) -!1514 = span !6 5753 5759 -!1515 = span !6 5768 5772 -!1516 = span !6 5701 5784 -!1517 = (!1511 !1512) -!1518 = (!1511 !1512) -!1519 = (!1511 !1512) -!1520 = (!1511 !1512) -!1521 = span !0 152 277 -!1522 = (!1521 !1373) -!1523 = span !0 236 256 -!1524 = fn_call_path_span !0 243 249 -!1525 = (!1523 !1524 !90 !91 !831 !832 !53) -!1526 = (!1523 !1524 !90 !91 !831 !832) -!1527 = (!1523 !1524 !90 !91 !831 !832 !56) -!1528 = (!1523 !1524 !90 !91 !831 !832 !59) -!1529 = span !0 226 259 -!1530 = span !0 152 305 -!1531 = (!1530 !1373) -!1532 = span !101 54 58 -!1533 = span !0 172 321 -!1534 = (!1533 !1405) -!1535 = span !0 256 276 -!1536 = fn_call_path_span !0 263 269 -!1537 = (!1535 !1536 !90 !91 !831 !832 !53) -!1538 = (!1535 !1536 !90 !91 !831 !832) -!1539 = (!1535 !1536 !90 !91 !831 !832 !56) -!1540 = (!1535 !1536 !90 !91 !831 !832 !59) -!1541 = span !0 280 300 -!1542 = fn_call_path_span !0 287 293 -!1543 = (!1541 !1542 !90 !91 !831 !832) -!1544 = (!1541 !1542 !90 !91 !831 !832 !56) -!1545 = (!1541 !1542 !90 !91 !831 !832 !59) -!1546 = span !0 246 303 -!1547 = span !0 192 425 -!1548 = (!1547 !1451) -!1549 = span !101 198 202 -!1550 = span !0 260 299 -!1551 = span !101 232 236 -!1552 = span !0 300 339 -!1553 = span !101 266 270 -!1554 = span !6 42917 43081 -!1555 = fn_name_span !6 42920 42930 -!1556 = (!1554 !1555) -!1557 = span !6 42991 42992 -!1558 = span !6 42973 43012 -!1559 = span !6 43039 43040 -!1560 = span !6 115798 115804 -!1561 = span !6 115776 115913 -!1562 = fn_name_span !6 115779 115789 -!1563 = (!1561 !1562) -!1564 = span !6 115839 115860 -!1565 = fn_call_path_span !6 115839 115852 -!1566 = (!1564 !1565 !831 !832 !53) -!1567 = (!1564 !1565 !831 !832) -!1568 = (!1564 !1565 !831 !832 !56) -!1569 = (!1564 !1565 !831 !832 !59) -!1570 = span !6 115862 115883 -!1571 = fn_call_path_span !6 115862 115875 -!1572 = (!1570 !1571 !831 !832) -!1573 = (!1570 !1571 !831 !832 !56) -!1574 = (!1570 !1571 !831 !832 !59) -!1575 = span !6 115885 115906 -!1576 = fn_call_path_span !6 115885 115898 -!1577 = (!1575 !1576 !831 !832) -!1578 = (!1575 !1576 !831 !832 !56) -!1579 = (!1575 !1576 !831 !832 !59) -!1580 = span !6 115838 115907 -!1581 = span !6 116066 116072 -!1582 = span !6 116044 116263 -!1583 = fn_name_span !6 116047 116057 -!1584 = (!1582 !1583) -!1585 = span !6 116120 116141 -!1586 = fn_call_path_span !6 116120 116133 -!1587 = (!1585 !1586 !831 !832 !53) -!1588 = (!1585 !1586 !831 !832) -!1589 = (!1585 !1586 !831 !832 !56) -!1590 = (!1585 !1586 !831 !832 !59) -!1591 = span !6 116155 116176 -!1592 = fn_call_path_span !6 116155 116168 -!1593 = (!1591 !1592 !831 !832) -!1594 = (!1591 !1592 !831 !832 !56) -!1595 = (!1591 !1592 !831 !832 !59) -!1596 = span !6 116190 116211 -!1597 = fn_call_path_span !6 116190 116203 -!1598 = (!1596 !1597 !831 !832) -!1599 = (!1596 !1597 !831 !832 !56) -!1600 = (!1596 !1597 !831 !832 !59) -!1601 = span !6 116225 116246 -!1602 = fn_call_path_span !6 116225 116238 -!1603 = (!1601 !1602 !831 !832) -!1604 = (!1601 !1602 !831 !832 !56) -!1605 = (!1601 !1602 !831 !832 !59) -!1606 = span !6 116106 116257 -!1607 = span !6 43531 43791 -!1608 = fn_name_span !6 43534 43544 -!1609 = (!1607 !1608) -!1610 = span !6 43605 43606 -!1611 = span !6 43587 43626 -!1612 = span !6 43653 43654 -!1613 = span !6 43635 43674 -!1614 = span !6 43701 43702 -!1615 = span !6 43683 43722 -!1616 = span !6 43749 43750 -!1617 = span !6 5030 5034 -!1618 = span !6 5016 5161 -!1619 = fn_name_span !6 5019 5029 -!1620 = (!1618 !1619) -!1621 = span !6 5124 5130 -!1622 = span !6 5072 5155 -!1623 = span !6 71734 71740 -!1624 = span !6 71712 71810 -!1625 = fn_name_span !6 71715 71725 -!1626 = (!1624 !1625) -!1627 = span !6 71774 71804 -!1628 = fn_call_path_span !6 71781 71794 -!1629 = (!1627 !1628 !53) -!1630 = (!1627 !1628) -!1631 = (!1627 !1628 !1346) -!1632 = (!1627 !1628 !1348) -!1633 = (!1627 !1628 !1350) -!1634 = span !6 4482 4627 -!1635 = fn_name_span !6 4485 4495 -!1636 = (!1634 !1635) -!1637 = span !6 4590 4596 -!1638 = span !6 4605 4609 -!1639 = span !6 4538 4621 -!1640 = span !6 72165 72171 -!1641 = span !6 72143 72426 -!1642 = fn_name_span !6 72146 72156 -!1643 = (!1641 !1642) -!1644 = span !6 72219 72238 -!1645 = fn_call_path_span !6 72226 72230 -!1646 = (!1644 !1645) -!1647 = span !6 72212 72239 -!1648 = fn_call_path_span !6 72212 72218 -!1649 = (!1647 !1648 !982) -!1650 = span !6 72264 72283 -!1651 = fn_call_path_span !6 72271 72275 -!1652 = (!1650 !1651) -!1653 = span !6 72257 72284 -!1654 = fn_call_path_span !6 72257 72263 -!1655 = (!1653 !1654 !982) -!1656 = span !6 72309 72328 -!1657 = fn_call_path_span !6 72316 72320 -!1658 = (!1656 !1657) -!1659 = span !6 72302 72329 -!1660 = fn_call_path_span !6 72302 72308 -!1661 = (!1659 !1660 !982) -!1662 = span !6 72354 72373 -!1663 = fn_call_path_span !6 72361 72365 -!1664 = (!1662 !1663) -!1665 = span !6 72347 72374 -!1666 = fn_call_path_span !6 72347 72353 -!1667 = (!1665 !1666 !982) -!1668 = span !6 72390 72392 -!1669 = span !6 72385 72392 -!1670 = fn_call_path_span !6 72387 72389 -!1671 = (!1669 !1670) -!1672 = span !994 3962 3972 -!1673 = span !6 72402 72404 -!1674 = span !6 72397 72404 -!1675 = fn_call_path_span !6 72399 72401 -!1676 = (!1674 !1675) -!1677 = span !6 72384 72405 -!1678 = fn_call_path_span !6 72394 72395 -!1679 = (!1677 !1678) -!1680 = span !6 72414 72415 -!1681 = span !6 72409 72415 -!1682 = fn_call_path_span !6 72411 72413 -!1683 = (!1681 !1682) -!1684 = span !6 72384 72416 -!1685 = fn_call_path_span !6 72406 72407 -!1686 = (!1684 !1685) -!1687 = span !6 72384 72420 -!1688 = fn_call_path_span !6 72417 72418 -!1689 = (!1687 !1688) -!1690 = span !6 4852 4856 -!1691 = span !6 4838 4983 -!1692 = fn_name_span !6 4841 4851 -!1693 = (!1691 !1692) -!1694 = span !6 4946 4952 -!1695 = span !6 4894 4977 -!1696 = span !6 5207 5211 -!1697 = span !6 5193 5338 -!1698 = fn_name_span !6 5196 5206 -!1699 = (!1697 !1698) -!1700 = span !6 5301 5307 -!1701 = span !6 5249 5332 -!1702 = span !101 5843 5924 -!1703 = fn_name_span !101 5846 5861 -!1704 = decl_index 43420 -!1705 = (!1702 !1703 !1704) -!1706 = span !101 5894 5905 -!1707 = span !101 407 414 -!1708 = span !101 5915 5920 -!1709 = span !101 5878 5921 -!1710 = span !6 139161 139172 -!1711 = (!1709 !1710) -!1712 = span !6 139132 139174 -!1713 = (!1709 !1712) -!1714 = span !6 139209 139213 -!1715 = (!1709 !1714) -!1716 = span !6 139202 139214 -!1717 = fn_call_path_span !6 139202 139208 -!1718 = (!1709 !1716 !1717) -!1719 = (!1709 !1716 !1717 !109) -!1720 = span !6 70852 70882 -!1721 = fn_call_path_span !6 70857 70867 -!1722 = (!1709 !1716 !1717 !1720 !1721) -!1723 = (!1709 !1716 !1717 !1720 !1721) -!1724 = span !6 42787 42791 -!1725 = (!1709 !1716 !1717 !1720 !1721 !1724) -!1726 = span !6 42792 42793 -!1727 = (!1709 !1716 !1717 !1720 !1721 !1726) -!1728 = (!1709 !1716 !1717 !1720 !1721) -!1729 = span !6 42805 42811 -!1730 = (!1709 !1716 !1717 !1720 !1721 !1729) -!1731 = span !6 42774 42813 -!1732 = (!1709 !1716 !1717 !1720 !1721 !1731) -!1733 = span !6 42822 42828 -!1734 = (!1709 !1716 !1717 !1720 !1721 !1733) -!1735 = (!1709 !1716 !1717 !111) -!1736 = (!1709 !1716 !1717 !113) -!1737 = span !6 139179 139215 -!1738 = (!1709 !1737) -!1739 = span !6 139250 139261 -!1740 = (!1709 !1739) -!1741 = span !6 139278 139293 -!1742 = (!1709 !1741) -!1743 = span !6 139278 139299 -!1744 = fn_call_path_span !6 139294 139297 -!1745 = (!1709 !1743 !1744) -!1746 = (!1709 !1743 !1744 !69) -!1747 = (!1709 !1743 !1744 !71 !72) -!1748 = (!1709 !1743 !1744 !71 !72 !74) -!1749 = (!1709 !1743 !1744 !76) -!1750 = span !6 139271 139331 -!1751 = (!1709 !1750) -!1752 = span !6 139348 139364 -!1753 = (!1709 !1752) -!1754 = span !6 139348 139370 -!1755 = fn_call_path_span !6 139365 139368 -!1756 = (!1709 !1754 !1755) -!1757 = (!1709 !1754 !1755 !69) -!1758 = (!1709 !1754 !1755 !71 !72) -!1759 = (!1709 !1754 !1755 !71 !72 !74) -!1760 = (!1709 !1754 !1755 !76) -!1761 = span !6 139341 139402 -!1762 = (!1709 !1761) -!1763 = span !6 139240 139409 -!1764 = (!1709 !1763) -!1765 = (!1709 !1763) -!1766 = (!1709 !1763) -!1767 = (!1709 !1763) -!1768 = (!1709 !1763) -!1769 = (!1709 !1763) -!1770 = span !6 139220 139411 -!1771 = (!1709 !1770) -!1772 = span !6 139423 139426 -!1773 = (!1709 !1772 !111) -!1774 = (!1709 !1772 !113) -!1775 = span !6 139449 139455 -!1776 = (!1709 !1775) -!1777 = span !6 139449 139461 -!1778 = fn_call_path_span !6 139456 139459 -!1779 = (!1709 !1777 !1778) -!1780 = (!1709 !1777 !1778 !69) -!1781 = (!1709 !1777 !1778 !71 !72) -!1782 = (!1709 !1777 !1778 !71 !72 !74) -!1783 = (!1709 !1777 !1778 !76) -!1784 = span !6 139470 139478 -!1785 = (!1709 !1784) -!1786 = span !6 139433 139484 -!1787 = (!1709 !1786) -!1788 = span !6 139500 139534 -!1789 = (!1709 !1788) -!1790 = span !6 139594 139597 -!1791 = (!1709 !1790 !111) -!1792 = (!1709 !1790 !113) -!1793 = span !6 139621 139655 -!1794 = fn_call_path_span !6 139621 139645 -!1795 = span !6 735 755 -!1796 = (!1709 !1793 !1794 !1795) -!1797 = (!1709 !1793 !1794) -!1798 = (!1709 !1793 !1794 !1795) -!1799 = span !6 139604 139656 -!1800 = (!1709 !1799) -!1801 = span !6 139667 139670 -!1802 = (!1709 !1801 !111) -!1803 = (!1709 !1801 !113) -!1804 = span !6 139699 139705 -!1805 = (!1709 !1804) -!1806 = span !6 139685 139706 -!1807 = fn_call_path_span !6 139685 139698 -!1808 = (!1709 !1806 !1807 !350 !351) -!1809 = (!1709 !1806 !1807 !354 !355) -!1810 = (!1709 !1806 !1807 !354) -!1811 = (!1709 !1806 !1807 !360 !361) -!1812 = (!1709 !1806 !1807 !360) -!1813 = (!1709 !1806 !1807 !366) -!1814 = span !6 139718 139721 -!1815 = (!1709 !1814 !111) -!1816 = (!1709 !1814 !113) -!1817 = span !6 70770 70911 -!1818 = fn_name_span !6 70777 70783 -!1819 = (!1817 !1818) -!1820 = (!1720 !1721) -!1821 = span !6 5515 5521 -!1822 = (!1720 !1721 !1821) -!1823 = (!1720 !1721 !1224) -!1824 = span !6 5530 5534 -!1825 = (!1720 !1721 !1824) -!1826 = span !6 5463 5546 -!1827 = (!1720 !1721 !1826) -!1828 = (!1817 !1818) -!1829 = (!1720 !1721) -!1830 = span !6 43262 43263 -!1831 = (!1720 !1721 !1830) -!1832 = span !6 43244 43283 -!1833 = (!1720 !1721 !1832) -!1834 = span !6 43310 43311 -!1835 = (!1720 !1721 !1834) -!1836 = span !6 43292 43331 -!1837 = (!1720 !1721 !1836) -!1838 = span !6 43358 43359 -!1839 = (!1720 !1721 !1838) -!1840 = span !6 43340 43379 -!1841 = (!1720 !1721 !1840) -!1842 = span !101 5964 6037 -!1843 = fn_name_span !101 5967 5980 -!1844 = decl_index 43590 -!1845 = (!1842 !1843 !1844) -!1846 = span !101 6013 6024 -!1847 = span !101 479 484 -!1848 = span !101 6032 6033 -!1849 = span !101 5997 6034 -!1850 = (!1849 !1710) -!1851 = (!1849 !1712) -!1852 = (!1849 !1714) -!1853 = (!1849 !1716 !1717) -!1854 = (!1849 !1716 !1717 !109) -!1855 = (!1849 !1716 !1717 !1720 !1721) -!1856 = (!1849 !1716 !1717 !1720 !1721) -!1857 = (!1849 !1716 !1717 !1720 !1721 !1724) -!1858 = (!1849 !1716 !1717 !1720 !1721 !1726) -!1859 = (!1849 !1716 !1717 !1720 !1721) -!1860 = (!1849 !1716 !1717 !1720 !1721 !1729) -!1861 = (!1849 !1716 !1717 !1720 !1721 !1731) -!1862 = (!1849 !1716 !1717 !1720 !1721 !1733) -!1863 = (!1849 !1716 !1717 !111) -!1864 = (!1849 !1716 !1717 !113) -!1865 = (!1849 !1737) -!1866 = (!1849 !1739) -!1867 = (!1849 !1741) -!1868 = (!1849 !1743 !1744) -!1869 = (!1849 !1743 !1744 !69) -!1870 = (!1849 !1743 !1744 !71 !72) -!1871 = (!1849 !1743 !1744 !71 !72 !74) -!1872 = (!1849 !1743 !1744 !76) -!1873 = (!1849 !1750) -!1874 = (!1849 !1752) -!1875 = (!1849 !1754 !1755) -!1876 = (!1849 !1754 !1755 !69) -!1877 = (!1849 !1754 !1755 !71 !72) -!1878 = (!1849 !1754 !1755 !71 !72 !74) -!1879 = (!1849 !1754 !1755 !76) -!1880 = (!1849 !1761) -!1881 = (!1849 !1763) -!1882 = (!1849 !1763) -!1883 = (!1849 !1763) -!1884 = (!1849 !1763) -!1885 = (!1849 !1763) -!1886 = (!1849 !1763) -!1887 = (!1849 !1770) -!1888 = (!1849 !1772 !111) -!1889 = (!1849 !1772 !113) -!1890 = (!1849 !1775) -!1891 = (!1849 !1777 !1778) -!1892 = (!1849 !1777 !1778 !69) -!1893 = (!1849 !1777 !1778 !71 !72) -!1894 = (!1849 !1777 !1778 !71 !72 !74) -!1895 = (!1849 !1777 !1778 !76) -!1896 = (!1849 !1784) -!1897 = (!1849 !1786) -!1898 = (!1849 !1788) -!1899 = (!1849 !1790 !111) -!1900 = (!1849 !1790 !113) -!1901 = (!1849 !1793 !1794 !1795) -!1902 = (!1849 !1793 !1794) -!1903 = (!1849 !1793 !1794 !1795) -!1904 = (!1849 !1799) -!1905 = (!1849 !1801 !111) -!1906 = (!1849 !1801 !113) -!1907 = (!1849 !1804) -!1908 = (!1849 !1806 !1807 !1121 !1122) -!1909 = (!1849 !1814 !111) -!1910 = (!1849 !1814 !113) -!1911 = span !101 6076 6151 -!1912 = fn_name_span !101 6079 6093 -!1913 = decl_index 43768 -!1914 = (!1911 !1912 !1913) -!1915 = span !101 6126 6137 -!1916 = span !101 544 550 -!1917 = span !101 6146 6147 -!1918 = span !101 6110 6148 -!1919 = (!1918 !1710) -!1920 = (!1918 !1712) -!1921 = (!1918 !1714) -!1922 = (!1918 !1716 !1717) -!1923 = (!1918 !1716 !1717 !109) -!1924 = (!1918 !1716 !1717 !1720 !1721) -!1925 = (!1918 !1716 !1717 !1720 !1721) -!1926 = (!1918 !1716 !1717 !1720 !1721 !1724) -!1927 = (!1918 !1716 !1717 !1720 !1721 !1726) -!1928 = (!1918 !1716 !1717 !1720 !1721) -!1929 = (!1918 !1716 !1717 !1720 !1721 !1729) -!1930 = (!1918 !1716 !1717 !1720 !1721 !1731) -!1931 = (!1918 !1716 !1717 !1720 !1721 !1733) -!1932 = (!1918 !1716 !1717 !111) -!1933 = (!1918 !1716 !1717 !113) -!1934 = (!1918 !1737) -!1935 = (!1918 !1739) -!1936 = (!1918 !1741) -!1937 = (!1918 !1743 !1744) -!1938 = (!1918 !1743 !1744 !69) -!1939 = (!1918 !1743 !1744 !71 !72) -!1940 = (!1918 !1743 !1744 !71 !72 !74) -!1941 = (!1918 !1743 !1744 !76) -!1942 = (!1918 !1750) -!1943 = (!1918 !1752) -!1944 = (!1918 !1754 !1755) -!1945 = (!1918 !1754 !1755 !69) -!1946 = (!1918 !1754 !1755 !71 !72) -!1947 = (!1918 !1754 !1755 !71 !72 !74) -!1948 = (!1918 !1754 !1755 !76) -!1949 = (!1918 !1761) -!1950 = (!1918 !1763) -!1951 = (!1918 !1763) -!1952 = (!1918 !1763) -!1953 = (!1918 !1763) -!1954 = (!1918 !1763) -!1955 = (!1918 !1763) -!1956 = (!1918 !1770) -!1957 = (!1918 !1772 !111) -!1958 = (!1918 !1772 !113) -!1959 = (!1918 !1775) -!1960 = (!1918 !1777 !1778) -!1961 = (!1918 !1777 !1778 !69) -!1962 = (!1918 !1777 !1778 !71 !72) -!1963 = (!1918 !1777 !1778 !71 !72 !74) -!1964 = (!1918 !1777 !1778 !76) -!1965 = (!1918 !1784) -!1966 = (!1918 !1786) -!1967 = (!1918 !1788) -!1968 = (!1918 !1790 !111) -!1969 = (!1918 !1790 !113) -!1970 = (!1918 !1793 !1794 !1795) -!1971 = (!1918 !1793 !1794) -!1972 = (!1918 !1793 !1794 !1795) -!1973 = (!1918 !1799) -!1974 = (!1918 !1801 !111) -!1975 = (!1918 !1801 !113) -!1976 = (!1918 !1804) -!1977 = (!1918 !1806 !1807 !977 !978) -!1978 = (!1918 !1806 !1807 !984 !985) -!1979 = (!1918 !1814 !111) -!1980 = (!1918 !1814 !113) -!1981 = span !101 6191 6266 -!1982 = fn_name_span !101 6194 6208 -!1983 = decl_index 43960 -!1984 = (!1981 !1982 !1983) -!1985 = span !101 6241 6252 -!1986 = span !101 613 619 -!1987 = span !101 6261 6262 -!1988 = span !101 6225 6263 -!1989 = (!1988 !1710) -!1990 = (!1988 !1712) -!1991 = (!1988 !1714) -!1992 = (!1988 !1716 !1717) -!1993 = (!1988 !1716 !1717 !109) -!1994 = (!1988 !1716 !1717 !1720 !1721) -!1995 = (!1988 !1716 !1717 !1720 !1721) -!1996 = (!1988 !1716 !1717 !1720 !1721 !1724) -!1997 = (!1988 !1716 !1717 !1720 !1721 !1726) -!1998 = (!1988 !1716 !1717 !1720 !1721) -!1999 = (!1988 !1716 !1717 !1720 !1721 !1729) -!2000 = (!1988 !1716 !1717 !1720 !1721 !1731) -!2001 = (!1988 !1716 !1717 !1720 !1721 !1733) -!2002 = (!1988 !1716 !1717 !111) -!2003 = (!1988 !1716 !1717 !113) -!2004 = (!1988 !1737) -!2005 = (!1988 !1739) -!2006 = (!1988 !1741) -!2007 = (!1988 !1743 !1744) -!2008 = (!1988 !1743 !1744 !69) -!2009 = (!1988 !1743 !1744 !71 !72) -!2010 = (!1988 !1743 !1744 !71 !72 !74) -!2011 = (!1988 !1743 !1744 !76) -!2012 = (!1988 !1750) -!2013 = (!1988 !1752) -!2014 = (!1988 !1754 !1755) -!2015 = (!1988 !1754 !1755 !69) -!2016 = (!1988 !1754 !1755 !71 !72) -!2017 = (!1988 !1754 !1755 !71 !72 !74) -!2018 = (!1988 !1754 !1755 !76) -!2019 = (!1988 !1761) -!2020 = (!1988 !1763) -!2021 = (!1988 !1763) -!2022 = (!1988 !1763) -!2023 = (!1988 !1763) -!2024 = (!1988 !1763) -!2025 = (!1988 !1763) -!2026 = (!1988 !1770) -!2027 = (!1988 !1772 !111) -!2028 = (!1988 !1772 !113) -!2029 = (!1988 !1775) -!2030 = (!1988 !1777 !1778) -!2031 = (!1988 !1777 !1778 !69) -!2032 = (!1988 !1777 !1778 !71 !72) -!2033 = (!1988 !1777 !1778 !71 !72 !74) -!2034 = (!1988 !1777 !1778 !76) -!2035 = (!1988 !1784) -!2036 = (!1988 !1786) -!2037 = (!1988 !1788) -!2038 = (!1988 !1790 !111) -!2039 = (!1988 !1790 !113) -!2040 = (!1988 !1793 !1794 !1795) -!2041 = (!1988 !1793 !1794) -!2042 = (!1988 !1793 !1794 !1795) -!2043 = (!1988 !1799) -!2044 = (!1988 !1801 !111) -!2045 = (!1988 !1801 !113) -!2046 = (!1988 !1804) -!2047 = (!1988 !1806 !1807) -!2048 = (!1988 !1814 !111) -!2049 = (!1988 !1814 !113) -!2050 = span !101 6306 6381 -!2051 = fn_name_span !101 6309 6323 -!2052 = decl_index 44128 -!2053 = (!2050 !2051 !2052) -!2054 = span !101 6356 6367 -!2055 = span !101 682 688 -!2056 = span !101 6376 6377 -!2057 = span !101 6340 6378 -!2058 = (!2057 !1710) -!2059 = (!2057 !1712) -!2060 = (!2057 !1714) -!2061 = (!2057 !1716 !1717) -!2062 = (!2057 !1716 !1717 !109) -!2063 = (!2057 !1716 !1717 !111) -!2064 = (!2057 !1716 !1717 !113) -!2065 = (!2057 !1737) -!2066 = (!2057 !1739) -!2067 = (!2057 !1741) -!2068 = (!2057 !1743 !1744) -!2069 = (!2057 !1743 !1744 !69) -!2070 = (!2057 !1743 !1744 !71 !72) -!2071 = (!2057 !1743 !1744 !71 !72 !74) -!2072 = (!2057 !1743 !1744 !76) -!2073 = (!2057 !1750) -!2074 = (!2057 !1752) -!2075 = (!2057 !1754 !1755) -!2076 = (!2057 !1754 !1755 !69) -!2077 = (!2057 !1754 !1755 !71 !72) -!2078 = (!2057 !1754 !1755 !71 !72 !74) -!2079 = (!2057 !1754 !1755 !76) -!2080 = (!2057 !1761) -!2081 = (!2057 !1763) -!2082 = (!2057 !1763) -!2083 = (!2057 !1763) -!2084 = (!2057 !1763) -!2085 = (!2057 !1763) -!2086 = (!2057 !1763) -!2087 = (!2057 !1770) -!2088 = (!2057 !1772 !111) -!2089 = (!2057 !1772 !113) -!2090 = (!2057 !1775) -!2091 = (!2057 !1777 !1778) -!2092 = (!2057 !1777 !1778 !69) -!2093 = (!2057 !1777 !1778 !71 !72) -!2094 = (!2057 !1777 !1778 !71 !72 !74) -!2095 = (!2057 !1777 !1778 !76) -!2096 = (!2057 !1784) -!2097 = (!2057 !1786) -!2098 = (!2057 !1788) -!2099 = (!2057 !1790 !111) -!2100 = (!2057 !1790 !113) -!2101 = (!2057 !1793 !1794 !1795) -!2102 = (!2057 !1793 !1794) -!2103 = (!2057 !1793 !1794 !1795) -!2104 = (!2057 !1799) -!2105 = (!2057 !1801 !111) -!2106 = (!2057 !1801 !113) -!2107 = (!2057 !1804) -!2108 = (!2057 !1806 !1807 !831 !832 !53) -!2109 = (!2057 !1806 !1807 !831 !832) -!2110 = (!2057 !1806 !1807 !831 !832 !56) -!2111 = (!2057 !1806 !1807 !831 !832 !59) -!2112 = (!2057 !1814 !111) -!2113 = (!2057 !1814 !113) -!2114 = span !101 6422 6568 -!2115 = fn_name_span !101 6425 6440 -!2116 = decl_index 44296 -!2117 = (!2114 !2115 !2116) -!2118 = span !101 6473 6484 -!2119 = span !101 752 759 -!2120 = span !101 6457 6565 -!2121 = (!2120 !1710) -!2122 = (!2120 !1712) -!2123 = (!2120 !1714) -!2124 = (!2120 !1716 !1717) -!2125 = (!2120 !1716 !1717 !109) -!2126 = (!2120 !1716 !1717 !1720 !1721) -!2127 = (!2120 !1716 !1717 !1720 !1721) -!2128 = (!2120 !1716 !1717 !1720 !1721 !1724) -!2129 = (!2120 !1716 !1717 !1720 !1721 !1726) -!2130 = (!2120 !1716 !1717 !1720 !1721 !1729) -!2131 = (!2120 !1716 !1717 !1720 !1721 !1731) -!2132 = (!2120 !1716 !1717 !1720 !1721 !1733) -!2133 = (!2120 !1716 !1717 !111) -!2134 = (!2120 !1716 !1717 !113) -!2135 = (!2120 !1737) -!2136 = (!2120 !1739) -!2137 = (!2120 !1741) -!2138 = (!2120 !1743 !1744) -!2139 = (!2120 !1743 !1744 !69) -!2140 = (!2120 !1743 !1744 !71 !72) -!2141 = (!2120 !1743 !1744 !71 !72 !74) -!2142 = (!2120 !1743 !1744 !76) -!2143 = (!2120 !1750) -!2144 = (!2120 !1752) -!2145 = (!2120 !1754 !1755) -!2146 = (!2120 !1754 !1755 !69) -!2147 = (!2120 !1754 !1755 !71 !72) -!2148 = (!2120 !1754 !1755 !71 !72 !74) -!2149 = (!2120 !1754 !1755 !76) -!2150 = (!2120 !1761) -!2151 = (!2120 !1763) -!2152 = (!2120 !1763) -!2153 = (!2120 !1763) -!2154 = (!2120 !1763) -!2155 = (!2120 !1763) -!2156 = (!2120 !1763) -!2157 = (!2120 !1770) -!2158 = (!2120 !1772 !111) -!2159 = (!2120 !1772 !113) -!2160 = (!2120 !1775) -!2161 = (!2120 !1777 !1778) -!2162 = (!2120 !1777 !1778 !69) -!2163 = (!2120 !1777 !1778 !71 !72) -!2164 = (!2120 !1777 !1778 !71 !72 !74) -!2165 = (!2120 !1777 !1778 !76) -!2166 = (!2120 !1784) -!2167 = (!2120 !1786) -!2168 = (!2120 !1788) -!2169 = (!2120 !1790 !111) -!2170 = (!2120 !1790 !113) -!2171 = (!2120 !1793 !1794 !1795) -!2172 = (!2120 !1793 !1794) -!2173 = (!2120 !1793 !1794 !1795) -!2174 = (!2120 !1799) -!2175 = (!2120 !1801 !111) -!2176 = (!2120 !1801 !113) -!2177 = (!2120 !1804) -!2178 = span !6 139677 139707 -!2179 = (!2120 !2178) -!2180 = (!2120 !1814 !111) -!2181 = (!2120 !1814 !113) -!2182 = span !6 139728 139729 -!2183 = (!2120 !2182) -!2184 = span !101 6449 6566 -!2185 = span !101 6610 6752 -!2186 = fn_name_span !101 6613 6628 -!2187 = decl_index 44464 -!2188 = (!2185 !2186 !2187) -!2189 = span !101 6661 6672 -!2190 = span !101 826 833 -!2191 = span !101 6645 6749 -!2192 = (!2191 !1710) -!2193 = (!2191 !1712) -!2194 = (!2191 !1714) -!2195 = (!2191 !1716 !1717) -!2196 = (!2191 !1716 !1717 !109) -!2197 = (!2191 !1716 !1717 !1720 !1721) -!2198 = (!2191 !1716 !1717 !1720 !1721) -!2199 = (!2191 !1716 !1717 !1720 !1721 !1724) -!2200 = (!2191 !1716 !1717 !1720 !1721 !1726) -!2201 = (!2191 !1716 !1717 !1720 !1721 !1729) -!2202 = (!2191 !1716 !1717 !1720 !1721 !1731) -!2203 = (!2191 !1716 !1717 !1720 !1721 !1733) -!2204 = (!2191 !1716 !1717 !111) -!2205 = (!2191 !1716 !1717 !113) -!2206 = (!2191 !1737) -!2207 = (!2191 !1739) -!2208 = (!2191 !1741) -!2209 = (!2191 !1743 !1744) -!2210 = (!2191 !1743 !1744 !69) -!2211 = (!2191 !1743 !1744 !71 !72) -!2212 = (!2191 !1743 !1744 !71 !72 !74) -!2213 = (!2191 !1743 !1744 !76) -!2214 = (!2191 !1750) -!2215 = (!2191 !1752) -!2216 = (!2191 !1754 !1755) -!2217 = (!2191 !1754 !1755 !69) -!2218 = (!2191 !1754 !1755 !71 !72) -!2219 = (!2191 !1754 !1755 !71 !72 !74) -!2220 = (!2191 !1754 !1755 !76) -!2221 = (!2191 !1761) -!2222 = (!2191 !1763) -!2223 = (!2191 !1763) -!2224 = (!2191 !1763) -!2225 = (!2191 !1763) -!2226 = (!2191 !1763) -!2227 = (!2191 !1763) -!2228 = (!2191 !1770) -!2229 = (!2191 !1772 !111) -!2230 = (!2191 !1772 !113) -!2231 = (!2191 !1775) -!2232 = (!2191 !1777 !1778) -!2233 = (!2191 !1777 !1778 !69) -!2234 = (!2191 !1777 !1778 !71 !72) -!2235 = (!2191 !1777 !1778 !71 !72 !74) -!2236 = (!2191 !1777 !1778 !76) -!2237 = (!2191 !1784) -!2238 = (!2191 !1786) -!2239 = (!2191 !1788) -!2240 = (!2191 !1790 !111) -!2241 = (!2191 !1790 !113) -!2242 = (!2191 !1793 !1794 !1795) -!2243 = (!2191 !1793 !1794) -!2244 = (!2191 !1793 !1794 !1795) -!2245 = (!2191 !1799) -!2246 = (!2191 !1801 !111) -!2247 = (!2191 !1801 !113) -!2248 = (!2191 !1804) -!2249 = (!2191 !2178) -!2250 = (!2191 !1814 !111) -!2251 = (!2191 !1814 !113) -!2252 = (!2191 !2182) -!2253 = span !101 6637 6750 -!2254 = span !101 6794 6890 -!2255 = fn_name_span !101 6797 6813 -!2256 = decl_index 44638 -!2257 = (!2254 !2255 !2256) -!2258 = span !101 6846 6857 -!2259 = span !101 900 908 -!2260 = span !101 6830 6887 -!2261 = (!2260 !1710) -!2262 = (!2260 !1712) -!2263 = (!2260 !1714) -!2264 = (!2260 !1716 !1717) -!2265 = (!2260 !1716 !1717 !109) -!2266 = (!2260 !1716 !1717 !1720 !1721) -!2267 = (!2260 !1716 !1717 !1720 !1721) -!2268 = (!2260 !1716 !1717 !1720 !1721 !1724) -!2269 = (!2260 !1716 !1717 !1720 !1721 !1726) -!2270 = (!2260 !1716 !1717 !1720 !1721 !1729) -!2271 = (!2260 !1716 !1717 !1720 !1721 !1731) -!2272 = (!2260 !1716 !1717 !1720 !1721 !1733) -!2273 = (!2260 !1716 !1717 !111) -!2274 = (!2260 !1716 !1717 !113) -!2275 = (!2260 !1737) -!2276 = (!2260 !1739) -!2277 = (!2260 !1741) -!2278 = (!2260 !1743 !1744) -!2279 = (!2260 !1743 !1744 !69) -!2280 = (!2260 !1743 !1744 !71 !72) -!2281 = (!2260 !1743 !1744 !71 !72 !74) -!2282 = (!2260 !1743 !1744 !76) -!2283 = (!2260 !1750) -!2284 = (!2260 !1752) -!2285 = (!2260 !1754 !1755) -!2286 = (!2260 !1754 !1755 !69) -!2287 = (!2260 !1754 !1755 !71 !72) -!2288 = (!2260 !1754 !1755 !71 !72 !74) -!2289 = (!2260 !1754 !1755 !76) -!2290 = (!2260 !1761) -!2291 = (!2260 !1763) -!2292 = (!2260 !1763) -!2293 = (!2260 !1763) -!2294 = (!2260 !1763) -!2295 = (!2260 !1763) -!2296 = (!2260 !1763) -!2297 = (!2260 !1770) -!2298 = (!2260 !1772 !111) -!2299 = (!2260 !1772 !113) -!2300 = (!2260 !1775) -!2301 = (!2260 !1777 !1778) -!2302 = (!2260 !1777 !1778 !69) -!2303 = (!2260 !1777 !1778 !71 !72) -!2304 = (!2260 !1777 !1778 !71 !72 !74) -!2305 = (!2260 !1777 !1778 !76) -!2306 = (!2260 !1784) -!2307 = (!2260 !1786) -!2308 = (!2260 !1788) -!2309 = (!2260 !1790 !111) -!2310 = (!2260 !1790 !113) -!2311 = (!2260 !1793 !1794 !1795) -!2312 = (!2260 !1793 !1794) -!2313 = (!2260 !1793 !1794 !1795) -!2314 = (!2260 !1799) -!2315 = (!2260 !1801 !111) -!2316 = (!2260 !1801 !113) -!2317 = (!2260 !1804) -!2318 = (!2260 !1806 !1807 !500) -!2319 = (!2260 !1806 !1807 !502) -!2320 = (!2260 !1806 !1807 !504 !505) -!2321 = (!2260 !1806 !1807 !504 !505 !69) -!2322 = (!2260 !1806 !1807 !504 !505 !71 !72) -!2323 = (!2260 !1806 !1807 !504 !505 !71 !72 !74) -!2324 = (!2260 !1806 !1807 !504 !505 !76) -!2325 = (!2260 !2178) -!2326 = (!2260 !1814 !111) -!2327 = (!2260 !1814 !113) -!2328 = (!2260 !2182) -!2329 = span !101 6822 6888 -!2330 = span !101 6932 7029 -!2331 = fn_name_span !101 6935 6951 -!2332 = decl_index 44812 -!2333 = (!2330 !2331 !2332) -!2334 = span !101 6984 6995 -!2335 = span !101 979 987 -!2336 = span !101 6968 7026 -!2337 = (!2336 !1710) -!2338 = (!2336 !1712) -!2339 = (!2336 !1714) -!2340 = (!2336 !1716 !1717) -!2341 = (!2336 !1716 !1717 !109) -!2342 = (!2336 !1716 !1717 !1720 !1721) -!2343 = (!2336 !1716 !1717 !1720 !1721) -!2344 = (!2336 !1716 !1717 !1720 !1721 !1724) -!2345 = (!2336 !1716 !1717 !1720 !1721 !1726) -!2346 = (!2336 !1716 !1717 !1720 !1721 !1729) -!2347 = (!2336 !1716 !1717 !1720 !1721 !1731) -!2348 = (!2336 !1716 !1717 !1720 !1721 !1733) -!2349 = (!2336 !1716 !1717 !111) -!2350 = (!2336 !1716 !1717 !113) -!2351 = (!2336 !1737) -!2352 = (!2336 !1739) -!2353 = (!2336 !1741) -!2354 = (!2336 !1743 !1744) -!2355 = (!2336 !1743 !1744 !69) -!2356 = (!2336 !1743 !1744 !71 !72) -!2357 = (!2336 !1743 !1744 !71 !72 !74) -!2358 = (!2336 !1743 !1744 !76) -!2359 = (!2336 !1750) -!2360 = (!2336 !1752) -!2361 = (!2336 !1754 !1755) -!2362 = (!2336 !1754 !1755 !69) -!2363 = (!2336 !1754 !1755 !71 !72) -!2364 = (!2336 !1754 !1755 !71 !72 !74) -!2365 = (!2336 !1754 !1755 !76) -!2366 = (!2336 !1761) -!2367 = (!2336 !1763) -!2368 = (!2336 !1763) -!2369 = (!2336 !1763) -!2370 = (!2336 !1763) -!2371 = (!2336 !1763) -!2372 = (!2336 !1763) -!2373 = (!2336 !1770) -!2374 = (!2336 !1772 !111) -!2375 = (!2336 !1772 !113) -!2376 = (!2336 !1775) -!2377 = (!2336 !1777 !1778) -!2378 = (!2336 !1777 !1778 !69) -!2379 = (!2336 !1777 !1778 !71 !72) -!2380 = (!2336 !1777 !1778 !71 !72 !74) -!2381 = (!2336 !1777 !1778 !76) -!2382 = (!2336 !1784) -!2383 = (!2336 !1786) -!2384 = (!2336 !1788) -!2385 = (!2336 !1790 !111) -!2386 = (!2336 !1790 !113) -!2387 = (!2336 !1793 !1794 !1795) -!2388 = (!2336 !1793 !1794) -!2389 = (!2336 !1793 !1794 !1795) -!2390 = (!2336 !1799) -!2391 = (!2336 !1801 !111) -!2392 = (!2336 !1801 !113) -!2393 = (!2336 !1804) -!2394 = (!2336 !1806 !1807 !500) -!2395 = (!2336 !1806 !1807 !502) -!2396 = (!2336 !1806 !1807 !504 !505) -!2397 = (!2336 !1806 !1807 !504 !505 !69) -!2398 = (!2336 !1806 !1807 !504 !505 !71 !72) -!2399 = (!2336 !1806 !1807 !504 !505 !71 !72 !74) -!2400 = (!2336 !1806 !1807 !504 !505 !76) -!2401 = (!2336 !2178) -!2402 = (!2336 !1814 !111) -!2403 = (!2336 !1814 !113) -!2404 = (!2336 !2182) -!2405 = span !101 6960 7027 -!2406 = span !101 7071 7175 -!2407 = fn_name_span !101 7074 7090 -!2408 = decl_index 44986 -!2409 = (!2406 !2407 !2408) -!2410 = span !101 7123 7134 -!2411 = span !101 1058 1066 -!2412 = span !101 7107 7172 -!2413 = (!2412 !1710) -!2414 = (!2412 !1712) -!2415 = (!2412 !1714) -!2416 = (!2412 !1716 !1717) -!2417 = (!2412 !1716 !1717 !109) -!2418 = (!2412 !1716 !1717 !1720 !1721) -!2419 = (!2412 !1716 !1717 !1720 !1721) -!2420 = (!2412 !1716 !1717 !1720 !1721 !1724) -!2421 = (!2412 !1716 !1717 !1720 !1721 !1726) -!2422 = (!2412 !1716 !1717 !1720 !1721 !1729) -!2423 = (!2412 !1716 !1717 !1720 !1721 !1731) -!2424 = (!2412 !1716 !1717 !1720 !1721 !1733) -!2425 = (!2412 !1716 !1717 !111) -!2426 = (!2412 !1716 !1717 !113) -!2427 = (!2412 !1737) -!2428 = (!2412 !1739) -!2429 = (!2412 !1741) -!2430 = (!2412 !1743 !1744) -!2431 = (!2412 !1743 !1744 !69) -!2432 = (!2412 !1743 !1744 !71 !72) -!2433 = (!2412 !1743 !1744 !71 !72 !74) -!2434 = (!2412 !1743 !1744 !76) -!2435 = (!2412 !1750) -!2436 = (!2412 !1752) -!2437 = (!2412 !1754 !1755) -!2438 = (!2412 !1754 !1755 !69) -!2439 = (!2412 !1754 !1755 !71 !72) -!2440 = (!2412 !1754 !1755 !71 !72 !74) -!2441 = (!2412 !1754 !1755 !76) -!2442 = (!2412 !1761) -!2443 = (!2412 !1763) -!2444 = (!2412 !1763) -!2445 = (!2412 !1763) -!2446 = (!2412 !1763) -!2447 = (!2412 !1763) -!2448 = (!2412 !1763) -!2449 = (!2412 !1770) -!2450 = (!2412 !1772 !111) -!2451 = (!2412 !1772 !113) -!2452 = (!2412 !1775) -!2453 = (!2412 !1777 !1778) -!2454 = (!2412 !1777 !1778 !69) -!2455 = (!2412 !1777 !1778 !71 !72) -!2456 = (!2412 !1777 !1778 !71 !72 !74) -!2457 = (!2412 !1777 !1778 !76) -!2458 = (!2412 !1784) -!2459 = (!2412 !1786) -!2460 = (!2412 !1788) -!2461 = (!2412 !1790 !111) -!2462 = (!2412 !1790 !113) -!2463 = (!2412 !1793 !1794 !1795) -!2464 = (!2412 !1793 !1794) -!2465 = (!2412 !1793 !1794 !1795) -!2466 = (!2412 !1799) -!2467 = (!2412 !1801 !111) -!2468 = (!2412 !1801 !113) -!2469 = (!2412 !1804) -!2470 = (!2412 !1806 !1807 !500) -!2471 = (!2412 !1806 !1807 !502) -!2472 = (!2412 !1806 !1807 !504 !505) -!2473 = (!2412 !1806 !1807 !504 !505 !69) -!2474 = (!2412 !1806 !1807 !504 !505 !71 !72) -!2475 = (!2412 !1806 !1807 !504 !505 !71 !72 !74) -!2476 = (!2412 !1806 !1807 !504 !505 !76) -!2477 = (!2412 !2178) -!2478 = (!2412 !1814 !111) -!2479 = (!2412 !1814 !113) -!2480 = (!2412 !2182) -!2481 = span !101 7099 7173 -!2482 = span !101 7218 7332 -!2483 = fn_name_span !101 7221 7238 -!2484 = decl_index 45160 -!2485 = (!2482 !2483 !2484) -!2486 = span !101 7271 7282 -!2487 = span !101 1138 1147 -!2488 = span !101 7255 7329 -!2489 = (!2488 !1710) -!2490 = (!2488 !1712) -!2491 = (!2488 !1714) -!2492 = (!2488 !1716 !1717) -!2493 = (!2488 !1716 !1717 !109) -!2494 = (!2488 !1716 !1717 !1720 !1721) -!2495 = (!2488 !1716 !1717 !1720 !1721) -!2496 = (!2488 !1716 !1717 !1720 !1721 !1724) -!2497 = (!2488 !1716 !1717 !1720 !1721 !1726) -!2498 = (!2488 !1716 !1717 !1720 !1721 !1729) -!2499 = (!2488 !1716 !1717 !1720 !1721 !1731) -!2500 = (!2488 !1716 !1717 !1720 !1721 !1733) -!2501 = (!2488 !1716 !1717 !111) -!2502 = (!2488 !1716 !1717 !113) -!2503 = (!2488 !1737) -!2504 = (!2488 !1739) -!2505 = (!2488 !1741) -!2506 = (!2488 !1743 !1744) -!2507 = (!2488 !1743 !1744 !69) -!2508 = (!2488 !1743 !1744 !71 !72) -!2509 = (!2488 !1743 !1744 !71 !72 !74) -!2510 = (!2488 !1743 !1744 !76) -!2511 = (!2488 !1750) -!2512 = (!2488 !1752) -!2513 = (!2488 !1754 !1755) -!2514 = (!2488 !1754 !1755 !69) -!2515 = (!2488 !1754 !1755 !71 !72) -!2516 = (!2488 !1754 !1755 !71 !72 !74) -!2517 = (!2488 !1754 !1755 !76) -!2518 = (!2488 !1761) -!2519 = (!2488 !1763) -!2520 = (!2488 !1763) -!2521 = (!2488 !1763) -!2522 = (!2488 !1763) -!2523 = (!2488 !1763) -!2524 = (!2488 !1763) -!2525 = (!2488 !1770) -!2526 = (!2488 !1772 !111) -!2527 = (!2488 !1772 !113) -!2528 = (!2488 !1775) -!2529 = (!2488 !1777 !1778) -!2530 = (!2488 !1777 !1778 !69) -!2531 = (!2488 !1777 !1778 !71 !72) -!2532 = (!2488 !1777 !1778 !71 !72 !74) -!2533 = (!2488 !1777 !1778 !76) -!2534 = (!2488 !1784) -!2535 = (!2488 !1786) -!2536 = (!2488 !1788) -!2537 = (!2488 !1790 !111) -!2538 = (!2488 !1790 !113) -!2539 = (!2488 !1793 !1794 !1795) -!2540 = (!2488 !1793 !1794) -!2541 = (!2488 !1793 !1794 !1795) -!2542 = (!2488 !1799) -!2543 = (!2488 !1801 !111) -!2544 = (!2488 !1801 !113) -!2545 = (!2488 !1804) -!2546 = (!2488 !1806 !1807 !500) -!2547 = (!2488 !1806 !1807 !502) -!2548 = (!2488 !1806 !1807 !504 !505) -!2549 = (!2488 !1806 !1807 !504 !505 !69) -!2550 = (!2488 !1806 !1807 !504 !505 !71 !72) -!2551 = (!2488 !1806 !1807 !504 !505 !71 !72 !74) -!2552 = (!2488 !1806 !1807 !504 !505 !76) -!2553 = (!2488 !2178) -!2554 = (!2488 !1814 !111) -!2555 = (!2488 !1814 !113) -!2556 = (!2488 !2182) -!2557 = span !101 7247 7330 -!2558 = span !101 7376 7506 -!2559 = fn_name_span !101 7379 7396 -!2560 = decl_index 45334 -!2561 = (!2558 !2559 !2560) -!2562 = span !101 7429 7440 -!2563 = span !101 1222 1231 -!2564 = span !101 7413 7503 -!2565 = (!2564 !1710) -!2566 = (!2564 !1712) -!2567 = (!2564 !1714) -!2568 = (!2564 !1716 !1717) -!2569 = (!2564 !1716 !1717 !109) -!2570 = (!2564 !1716 !1717 !1720 !1721) -!2571 = (!2564 !1716 !1717 !1720 !1721) -!2572 = (!2564 !1716 !1717 !1720 !1721 !1724) -!2573 = (!2564 !1716 !1717 !1720 !1721 !1726) -!2574 = (!2564 !1716 !1717 !1720 !1721 !1729) -!2575 = (!2564 !1716 !1717 !1720 !1721 !1731) -!2576 = (!2564 !1716 !1717 !1720 !1721 !1733) -!2577 = (!2564 !1716 !1717 !111) -!2578 = (!2564 !1716 !1717 !113) -!2579 = (!2564 !1737) -!2580 = (!2564 !1739) -!2581 = (!2564 !1741) -!2582 = (!2564 !1743 !1744) -!2583 = (!2564 !1743 !1744 !69) -!2584 = (!2564 !1743 !1744 !71 !72) -!2585 = (!2564 !1743 !1744 !71 !72 !74) -!2586 = (!2564 !1743 !1744 !76) -!2587 = (!2564 !1750) -!2588 = (!2564 !1752) -!2589 = (!2564 !1754 !1755) -!2590 = (!2564 !1754 !1755 !69) -!2591 = (!2564 !1754 !1755 !71 !72) -!2592 = (!2564 !1754 !1755 !71 !72 !74) -!2593 = (!2564 !1754 !1755 !76) -!2594 = (!2564 !1761) -!2595 = (!2564 !1763) -!2596 = (!2564 !1763) -!2597 = (!2564 !1763) -!2598 = (!2564 !1763) -!2599 = (!2564 !1763) -!2600 = (!2564 !1763) -!2601 = (!2564 !1770) -!2602 = (!2564 !1772 !111) -!2603 = (!2564 !1772 !113) -!2604 = (!2564 !1775) -!2605 = (!2564 !1777 !1778) -!2606 = (!2564 !1777 !1778 !69) -!2607 = (!2564 !1777 !1778 !71 !72) -!2608 = (!2564 !1777 !1778 !71 !72 !74) -!2609 = (!2564 !1777 !1778 !76) -!2610 = (!2564 !1784) -!2611 = (!2564 !1786) -!2612 = (!2564 !1788) -!2613 = (!2564 !1790 !111) -!2614 = (!2564 !1790 !113) -!2615 = (!2564 !1793 !1794 !1795) -!2616 = (!2564 !1793 !1794) -!2617 = (!2564 !1793 !1794 !1795) -!2618 = (!2564 !1799) -!2619 = (!2564 !1801 !111) -!2620 = (!2564 !1801 !113) -!2621 = (!2564 !1804) -!2622 = (!2564 !1806 !1807 !500) -!2623 = (!2564 !1806 !1807 !502) -!2624 = (!2564 !1806 !1807 !504 !505) -!2625 = (!2564 !1806 !1807 !504 !505 !69) -!2626 = (!2564 !1806 !1807 !504 !505 !71 !72) -!2627 = (!2564 !1806 !1807 !504 !505 !71 !72 !74) -!2628 = (!2564 !1806 !1807 !504 !505 !76) -!2629 = (!2564 !2178) -!2630 = (!2564 !1814 !111) -!2631 = (!2564 !1814 !113) -!2632 = (!2564 !2182) -!2633 = span !101 7405 7504 -!2634 = span !101 7551 7635 -!2635 = fn_name_span !101 7554 7572 -!2636 = decl_index 45574 -!2637 = (!2634 !2635 !2636) -!2638 = span !101 7605 7616 -!2639 = span !101 1307 1317 -!2640 = span !101 7629 7631 -!2641 = span !101 7589 7632 -!2642 = (!2641 !1710) -!2643 = (!2641 !1712) -!2644 = (!2641 !1714) -!2645 = (!2641 !1716 !1717) -!2646 = (!2641 !1716 !1717 !109) -!2647 = (!2641 !1716 !1717 !1720 !1721) -!2648 = (!2641 !1716 !1717 !1720 !1721) -!2649 = (!2641 !1716 !1717 !1720 !1721 !1724) -!2650 = (!2641 !1716 !1717 !1720 !1721 !1726) -!2651 = (!2641 !1716 !1717 !1720 !1721 !1729) -!2652 = (!2641 !1716 !1717 !1720 !1721 !1731) -!2653 = (!2641 !1716 !1717 !1720 !1721 !1733) -!2654 = (!2641 !1716 !1717 !111) -!2655 = (!2641 !1716 !1717 !113) -!2656 = (!2641 !1737) -!2657 = (!2641 !1739) -!2658 = (!2641 !1741) -!2659 = (!2641 !1743 !1744) -!2660 = (!2641 !1743 !1744 !69) -!2661 = (!2641 !1743 !1744 !71 !72) -!2662 = (!2641 !1743 !1744 !71 !72 !74) -!2663 = (!2641 !1743 !1744 !76) -!2664 = (!2641 !1750) -!2665 = (!2641 !1752) -!2666 = (!2641 !1754 !1755) -!2667 = (!2641 !1754 !1755 !69) -!2668 = (!2641 !1754 !1755 !71 !72) -!2669 = (!2641 !1754 !1755 !71 !72 !74) -!2670 = (!2641 !1754 !1755 !76) -!2671 = (!2641 !1761) -!2672 = (!2641 !1763) -!2673 = (!2641 !1763) -!2674 = (!2641 !1763) -!2675 = (!2641 !1763) -!2676 = (!2641 !1763) -!2677 = (!2641 !1763) -!2678 = (!2641 !1770) -!2679 = (!2641 !1772 !111) -!2680 = (!2641 !1772 !113) -!2681 = (!2641 !1775) -!2682 = (!2641 !1777 !1778) -!2683 = (!2641 !1777 !1778 !69) -!2684 = (!2641 !1777 !1778 !71 !72) -!2685 = (!2641 !1777 !1778 !71 !72 !74) -!2686 = (!2641 !1777 !1778 !76) -!2687 = (!2641 !1784) -!2688 = (!2641 !1786) -!2689 = (!2641 !1788) -!2690 = (!2641 !1790 !111) -!2691 = (!2641 !1790 !113) -!2692 = (!2641 !1793 !1794 !1795) -!2693 = (!2641 !1793 !1794) -!2694 = (!2641 !1793 !1794 !1795) -!2695 = (!2641 !1799) -!2696 = (!2641 !1801 !111) -!2697 = (!2641 !1801 !113) -!2698 = (!2641 !1804) -!2699 = (!2641 !2178) -!2700 = (!2641 !1814 !111) -!2701 = (!2641 !1814 !113) -!2702 = (!2641 !2182) -!2703 = span !101 7581 7633 -!2704 = span !101 7681 7766 -!2705 = fn_name_span !101 7684 7702 -!2706 = decl_index 45814 -!2707 = (!2704 !2705 !2706) -!2708 = span !101 7735 7746 -!2709 = span !101 1396 1406 -!2710 = span !101 7759 7762 -!2711 = span !101 7760 7761 -!2712 = span !101 7719 7763 -!2713 = (!2712 !1710) -!2714 = (!2712 !1712) -!2715 = (!2712 !1714) -!2716 = (!2712 !1716 !1717) -!2717 = (!2712 !1716 !1717 !109) -!2718 = (!2712 !1716 !1717 !1720 !1721) -!2719 = (!2712 !1716 !1717 !1720 !1721) -!2720 = (!2712 !1716 !1717 !1720 !1721 !1724) -!2721 = (!2712 !1716 !1717 !1720 !1721 !1726) -!2722 = (!2712 !1716 !1717 !1720 !1721 !1729) -!2723 = (!2712 !1716 !1717 !1720 !1721 !1731) -!2724 = (!2712 !1716 !1717 !1720 !1721 !1733) -!2725 = (!2712 !1716 !1717 !111) -!2726 = (!2712 !1716 !1717 !113) -!2727 = (!2712 !1737) -!2728 = (!2712 !1739) -!2729 = (!2712 !1741) -!2730 = (!2712 !1743 !1744) -!2731 = (!2712 !1743 !1744 !69) -!2732 = (!2712 !1743 !1744 !71 !72) -!2733 = (!2712 !1743 !1744 !71 !72 !74) -!2734 = (!2712 !1743 !1744 !76) -!2735 = (!2712 !1750) -!2736 = (!2712 !1752) -!2737 = (!2712 !1754 !1755) -!2738 = (!2712 !1754 !1755 !69) -!2739 = (!2712 !1754 !1755 !71 !72) -!2740 = (!2712 !1754 !1755 !71 !72 !74) -!2741 = (!2712 !1754 !1755 !76) -!2742 = (!2712 !1761) -!2743 = (!2712 !1763) -!2744 = (!2712 !1763) -!2745 = (!2712 !1763) -!2746 = (!2712 !1763) -!2747 = (!2712 !1763) -!2748 = (!2712 !1763) -!2749 = (!2712 !1770) -!2750 = (!2712 !1772 !111) -!2751 = (!2712 !1772 !113) -!2752 = (!2712 !1775) -!2753 = (!2712 !1777 !1778) -!2754 = (!2712 !1777 !1778 !69) -!2755 = (!2712 !1777 !1778 !71 !72) -!2756 = (!2712 !1777 !1778 !71 !72 !74) -!2757 = (!2712 !1777 !1778 !76) -!2758 = (!2712 !1784) -!2759 = (!2712 !1786) -!2760 = (!2712 !1788) -!2761 = (!2712 !1790 !111) -!2762 = (!2712 !1790 !113) -!2763 = (!2712 !1793 !1794 !1795) -!2764 = (!2712 !1793 !1794) -!2765 = (!2712 !1793 !1794 !1795) -!2766 = (!2712 !1799) -!2767 = (!2712 !1801 !111) -!2768 = (!2712 !1801 !113) -!2769 = (!2712 !1804) -!2770 = (!2712 !2178) -!2771 = (!2712 !1814 !111) -!2772 = (!2712 !1814 !113) -!2773 = (!2712 !2182) -!2774 = span !101 7711 7764 -!2775 = span !101 7812 7918 -!2776 = fn_name_span !101 7815 7833 -!2777 = decl_index 46054 -!2778 = (!2775 !2776 !2777) -!2779 = span !101 7866 7877 -!2780 = span !101 1485 1495 -!2781 = span !101 7890 7914 -!2782 = span !101 7891 7892 -!2783 = span !101 7850 7915 -!2784 = (!2783 !1710) -!2785 = (!2783 !1712) -!2786 = (!2783 !1714) -!2787 = (!2783 !1716 !1717) -!2788 = (!2783 !1716 !1717 !109) -!2789 = (!2783 !1716 !1717 !1720 !1721) -!2790 = (!2783 !1716 !1717 !1720 !1721) -!2791 = (!2783 !1716 !1717 !1720 !1721 !1724) -!2792 = (!2783 !1716 !1717 !1720 !1721 !1726) -!2793 = (!2783 !1716 !1717 !1720 !1721 !1729) -!2794 = (!2783 !1716 !1717 !1720 !1721 !1731) -!2795 = (!2783 !1716 !1717 !1720 !1721 !1733) -!2796 = (!2783 !1716 !1717 !111) -!2797 = (!2783 !1716 !1717 !113) -!2798 = (!2783 !1737) -!2799 = (!2783 !1739) -!2800 = (!2783 !1741) -!2801 = (!2783 !1743 !1744) -!2802 = (!2783 !1743 !1744 !69) -!2803 = (!2783 !1743 !1744 !71 !72) -!2804 = (!2783 !1743 !1744 !71 !72 !74) -!2805 = (!2783 !1743 !1744 !76) -!2806 = (!2783 !1750) -!2807 = (!2783 !1752) -!2808 = (!2783 !1754 !1755) -!2809 = (!2783 !1754 !1755 !69) -!2810 = (!2783 !1754 !1755 !71 !72) -!2811 = (!2783 !1754 !1755 !71 !72 !74) -!2812 = (!2783 !1754 !1755 !76) -!2813 = (!2783 !1761) -!2814 = (!2783 !1763) -!2815 = (!2783 !1763) -!2816 = (!2783 !1763) -!2817 = (!2783 !1763) -!2818 = (!2783 !1763) -!2819 = (!2783 !1763) -!2820 = (!2783 !1770) -!2821 = (!2783 !1772 !111) -!2822 = (!2783 !1772 !113) -!2823 = (!2783 !1775) -!2824 = (!2783 !1777 !1778) -!2825 = (!2783 !1777 !1778 !69) -!2826 = (!2783 !1777 !1778 !71 !72) -!2827 = (!2783 !1777 !1778 !71 !72 !74) -!2828 = (!2783 !1777 !1778 !76) -!2829 = (!2783 !1784) -!2830 = (!2783 !1786) -!2831 = (!2783 !1788) -!2832 = (!2783 !1790 !111) -!2833 = (!2783 !1790 !113) -!2834 = (!2783 !1793 !1794 !1795) -!2835 = (!2783 !1793 !1794) -!2836 = (!2783 !1793 !1794 !1795) -!2837 = (!2783 !1799) -!2838 = (!2783 !1801 !111) -!2839 = (!2783 !1801 !113) -!2840 = (!2783 !1804) -!2841 = (!2783 !2178) -!2842 = (!2783 !1814 !111) -!2843 = (!2783 !1814 !113) -!2844 = (!2783 !2182) -!2845 = span !101 7842 7916 -!2846 = span !101 7965 8097 -!2847 = fn_name_span !101 7968 7987 -!2848 = decl_index 46294 -!2849 = (!2846 !2847 !2848) -!2850 = span !101 8020 8031 -!2851 = span !101 1575 1586 -!2852 = span !101 8045 8093 -!2853 = span !101 8046 8047 -!2854 = span !101 8004 8094 -!2855 = (!2854 !1710) -!2856 = (!2854 !1712) -!2857 = (!2854 !1714) -!2858 = (!2854 !1716 !1717) -!2859 = (!2854 !1716 !1717 !109) -!2860 = (!2854 !1716 !1717 !1720 !1721) -!2861 = (!2854 !1716 !1717 !1720 !1721) -!2862 = (!2854 !1716 !1717 !1720 !1721 !1724) -!2863 = (!2854 !1716 !1717 !1720 !1721 !1726) -!2864 = (!2854 !1716 !1717 !1720 !1721 !1729) -!2865 = (!2854 !1716 !1717 !1720 !1721 !1731) -!2866 = (!2854 !1716 !1717 !1720 !1721 !1733) -!2867 = (!2854 !1716 !1717 !111) -!2868 = (!2854 !1716 !1717 !113) -!2869 = (!2854 !1737) -!2870 = (!2854 !1739) -!2871 = (!2854 !1741) -!2872 = (!2854 !1743 !1744) -!2873 = (!2854 !1743 !1744 !69) -!2874 = (!2854 !1743 !1744 !71 !72) -!2875 = (!2854 !1743 !1744 !71 !72 !74) -!2876 = (!2854 !1743 !1744 !76) -!2877 = (!2854 !1750) -!2878 = (!2854 !1752) -!2879 = (!2854 !1754 !1755) -!2880 = (!2854 !1754 !1755 !69) -!2881 = (!2854 !1754 !1755 !71 !72) -!2882 = (!2854 !1754 !1755 !71 !72 !74) -!2883 = (!2854 !1754 !1755 !76) -!2884 = (!2854 !1761) -!2885 = (!2854 !1763) -!2886 = (!2854 !1763) -!2887 = (!2854 !1763) -!2888 = (!2854 !1763) -!2889 = (!2854 !1763) -!2890 = (!2854 !1763) -!2891 = (!2854 !1770) -!2892 = (!2854 !1772 !111) -!2893 = (!2854 !1772 !113) -!2894 = (!2854 !1775) -!2895 = (!2854 !1777 !1778) -!2896 = (!2854 !1777 !1778 !69) -!2897 = (!2854 !1777 !1778 !71 !72) -!2898 = (!2854 !1777 !1778 !71 !72 !74) -!2899 = (!2854 !1777 !1778 !76) -!2900 = (!2854 !1784) -!2901 = (!2854 !1786) -!2902 = (!2854 !1788) -!2903 = (!2854 !1790 !111) -!2904 = (!2854 !1790 !113) -!2905 = (!2854 !1793 !1794 !1795) -!2906 = (!2854 !1793 !1794) -!2907 = (!2854 !1793 !1794 !1795) -!2908 = (!2854 !1799) -!2909 = (!2854 !1801 !111) -!2910 = (!2854 !1801 !113) -!2911 = (!2854 !1804) -!2912 = (!2854 !2178) -!2913 = (!2854 !1814 !111) -!2914 = (!2854 !1814 !113) -!2915 = (!2854 !2182) -!2916 = span !101 7996 8095 -!2917 = span !101 8145 8325 -!2918 = fn_name_span !101 8148 8167 -!2919 = decl_index 46534 -!2920 = (!2917 !2918 !2919) -!2921 = span !101 8200 8211 -!2922 = span !101 1669 1680 -!2923 = span !101 8225 8321 -!2924 = span !101 8226 8227 -!2925 = span !101 8184 8322 -!2926 = (!2925 !1710) -!2927 = (!2925 !1712) -!2928 = (!2925 !1714) -!2929 = (!2925 !1716 !1717) -!2930 = (!2925 !1716 !1717 !109) -!2931 = (!2925 !1716 !1717 !1720 !1721) -!2932 = (!2925 !1716 !1717 !1720 !1721) -!2933 = (!2925 !1716 !1717 !1720 !1721 !1724) -!2934 = (!2925 !1716 !1717 !1720 !1721 !1726) -!2935 = (!2925 !1716 !1717 !1720 !1721 !1729) -!2936 = (!2925 !1716 !1717 !1720 !1721 !1731) -!2937 = (!2925 !1716 !1717 !1720 !1721 !1733) -!2938 = (!2925 !1716 !1717 !111) -!2939 = (!2925 !1716 !1717 !113) -!2940 = (!2925 !1737) -!2941 = (!2925 !1739) -!2942 = (!2925 !1741) -!2943 = (!2925 !1743 !1744) -!2944 = (!2925 !1743 !1744 !69) -!2945 = (!2925 !1743 !1744 !71 !72) -!2946 = (!2925 !1743 !1744 !71 !72 !74) -!2947 = (!2925 !1743 !1744 !76) -!2948 = (!2925 !1750) -!2949 = (!2925 !1752) -!2950 = (!2925 !1754 !1755) -!2951 = (!2925 !1754 !1755 !69) -!2952 = (!2925 !1754 !1755 !71 !72) -!2953 = (!2925 !1754 !1755 !71 !72 !74) -!2954 = (!2925 !1754 !1755 !76) -!2955 = (!2925 !1761) -!2956 = (!2925 !1763) -!2957 = (!2925 !1763) -!2958 = (!2925 !1763) -!2959 = (!2925 !1763) -!2960 = (!2925 !1763) -!2961 = (!2925 !1763) -!2962 = (!2925 !1770) -!2963 = (!2925 !1772 !111) -!2964 = (!2925 !1772 !113) -!2965 = (!2925 !1775) -!2966 = (!2925 !1777 !1778) -!2967 = (!2925 !1777 !1778 !69) -!2968 = (!2925 !1777 !1778 !71 !72) -!2969 = (!2925 !1777 !1778 !71 !72 !74) -!2970 = (!2925 !1777 !1778 !76) -!2971 = (!2925 !1784) -!2972 = (!2925 !1786) -!2973 = (!2925 !1788) -!2974 = (!2925 !1790 !111) -!2975 = (!2925 !1790 !113) -!2976 = (!2925 !1793 !1794 !1795) -!2977 = (!2925 !1793 !1794) -!2978 = (!2925 !1793 !1794 !1795) -!2979 = (!2925 !1799) -!2980 = (!2925 !1801 !111) -!2981 = (!2925 !1801 !113) -!2982 = (!2925 !1804) -!2983 = (!2925 !2178) -!2984 = (!2925 !1814 !111) -!2985 = (!2925 !1814 !113) -!2986 = (!2925 !2182) -!2987 = span !101 8176 8323 -!2988 = span !101 8373 8649 -!2989 = fn_name_span !101 8376 8395 -!2990 = decl_index 46774 -!2991 = (!2988 !2989 !2990) -!2992 = span !101 8428 8439 -!2993 = span !101 1763 1774 -!2994 = span !101 8453 8645 -!2995 = span !101 8454 8455 -!2996 = span !101 8412 8646 -!2997 = (!2996 !1710) -!2998 = (!2996 !1712) -!2999 = (!2996 !1714) -!3000 = (!2996 !1716 !1717) -!3001 = (!2996 !1716 !1717 !109) -!3002 = (!2996 !1716 !1717 !1720 !1721) -!3003 = (!2996 !1716 !1717 !1720 !1721) -!3004 = (!2996 !1716 !1717 !1720 !1721 !1724) -!3005 = (!2996 !1716 !1717 !1720 !1721 !1726) -!3006 = (!2996 !1716 !1717 !1720 !1721 !1729) -!3007 = (!2996 !1716 !1717 !1720 !1721 !1731) -!3008 = (!2996 !1716 !1717 !1720 !1721 !1733) -!3009 = (!2996 !1716 !1717 !111) -!3010 = (!2996 !1716 !1717 !113) -!3011 = (!2996 !1737) -!3012 = (!2996 !1739) -!3013 = (!2996 !1741) -!3014 = (!2996 !1743 !1744) -!3015 = (!2996 !1743 !1744 !69) -!3016 = (!2996 !1743 !1744 !71 !72) -!3017 = (!2996 !1743 !1744 !71 !72 !74) -!3018 = (!2996 !1743 !1744 !76) -!3019 = (!2996 !1750) -!3020 = (!2996 !1752) -!3021 = (!2996 !1754 !1755) -!3022 = (!2996 !1754 !1755 !69) -!3023 = (!2996 !1754 !1755 !71 !72) -!3024 = (!2996 !1754 !1755 !71 !72 !74) -!3025 = (!2996 !1754 !1755 !76) -!3026 = (!2996 !1761) -!3027 = (!2996 !1763) -!3028 = (!2996 !1763) -!3029 = (!2996 !1763) -!3030 = (!2996 !1763) -!3031 = (!2996 !1763) -!3032 = (!2996 !1763) -!3033 = (!2996 !1770) -!3034 = (!2996 !1772 !111) -!3035 = (!2996 !1772 !113) -!3036 = (!2996 !1775) -!3037 = (!2996 !1777 !1778) -!3038 = (!2996 !1777 !1778 !69) -!3039 = (!2996 !1777 !1778 !71 !72) -!3040 = (!2996 !1777 !1778 !71 !72 !74) -!3041 = (!2996 !1777 !1778 !76) -!3042 = (!2996 !1784) -!3043 = (!2996 !1786) -!3044 = (!2996 !1788) -!3045 = (!2996 !1790 !111) -!3046 = (!2996 !1790 !113) -!3047 = (!2996 !1793 !1794 !1795) -!3048 = (!2996 !1793 !1794) -!3049 = (!2996 !1793 !1794 !1795) -!3050 = (!2996 !1799) -!3051 = (!2996 !1801 !111) -!3052 = (!2996 !1801 !113) -!3053 = (!2996 !1804) -!3054 = (!2996 !2178) -!3055 = (!2996 !1814 !111) -!3056 = (!2996 !1814 !113) -!3057 = (!2996 !2182) -!3058 = span !101 8404 8647 -!3059 = span !101 8696 8780 -!3060 = fn_name_span !101 8699 8717 -!3061 = decl_index 46941 -!3062 = (!3059 !3060 !3061) -!3063 = span !101 8750 8761 -!3064 = span !101 1856 1866 -!3065 = span !101 8774 8776 -!3066 = span !101 8734 8777 -!3067 = (!3066 !1710) -!3068 = (!3066 !1712) -!3069 = (!3066 !1714) -!3070 = (!3066 !1716 !1717) -!3071 = (!3066 !1716 !1717 !109) -!3072 = (!3066 !1716 !1717 !1720 !1721) -!3073 = (!3066 !1716 !1717 !1720 !1721) -!3074 = (!3066 !1716 !1717 !1720 !1721 !1729) -!3075 = span !6 42787 42812 -!3076 = fn_call_path_span !6 42794 42804 -!3077 = (!3066 !1716 !1717 !1720 !1721 !3075 !3076) -!3078 = span !6 42621 42627 -!3079 = (!3066 !1716 !1717 !1720 !1721 !3075 !3076 !3078) -!3080 = (!3066 !1716 !1717 !1720 !1721 !1731) -!3081 = (!3066 !1716 !1717 !1720 !1721 !1733) -!3082 = (!3066 !1716 !1717 !111) -!3083 = (!3066 !1716 !1717 !113) -!3084 = (!3066 !1737) -!3085 = (!3066 !1739) -!3086 = (!3066 !1741) -!3087 = (!3066 !1743 !1744) -!3088 = (!3066 !1743 !1744 !69) -!3089 = (!3066 !1743 !1744 !71 !72) -!3090 = (!3066 !1743 !1744 !71 !72 !74) -!3091 = (!3066 !1743 !1744 !76) -!3092 = (!3066 !1750) -!3093 = (!3066 !1752) -!3094 = (!3066 !1754 !1755) -!3095 = (!3066 !1754 !1755 !69) -!3096 = (!3066 !1754 !1755 !71 !72) -!3097 = (!3066 !1754 !1755 !71 !72 !74) -!3098 = (!3066 !1754 !1755 !76) -!3099 = (!3066 !1761) -!3100 = (!3066 !1763) -!3101 = (!3066 !1763) -!3102 = (!3066 !1763) -!3103 = (!3066 !1763) -!3104 = (!3066 !1763) -!3105 = (!3066 !1763) -!3106 = (!3066 !1770) -!3107 = (!3066 !1772 !111) -!3108 = (!3066 !1772 !113) -!3109 = (!3066 !1775) -!3110 = (!3066 !1777 !1778) -!3111 = (!3066 !1777 !1778 !69) -!3112 = (!3066 !1777 !1778 !71 !72) -!3113 = (!3066 !1777 !1778 !71 !72 !74) -!3114 = (!3066 !1777 !1778 !76) -!3115 = (!3066 !1784) -!3116 = (!3066 !1786) -!3117 = (!3066 !1788) -!3118 = (!3066 !1790 !111) -!3119 = (!3066 !1790 !113) -!3120 = (!3066 !1793 !1794 !1795) -!3121 = (!3066 !1793 !1794) -!3122 = (!3066 !1793 !1794 !1795) -!3123 = (!3066 !1799) -!3124 = (!3066 !1801 !111) -!3125 = (!3066 !1801 !113) -!3126 = (!3066 !1814 !111) -!3127 = (!3066 !1814 !113) -!3128 = span !101 8826 8912 -!3129 = fn_name_span !101 8829 8847 -!3130 = decl_index 47117 -!3131 = (!3128 !3129 !3130) -!3132 = span !101 8880 8891 -!3133 = span !101 1933 1943 -!3134 = span !101 8904 8908 -!3135 = span !101 8905 8906 -!3136 = span !101 8864 8909 -!3137 = (!3136 !1710) -!3138 = (!3136 !1712) -!3139 = (!3136 !1714) -!3140 = (!3136 !1737) -!3141 = (!3136 !1739) -!3142 = (!3136 !1741) -!3143 = (!3136 !1743 !1744) -!3144 = (!3136 !1743 !1744 !69) -!3145 = (!3136 !1743 !1744 !71 !72) -!3146 = (!3136 !1743 !1744 !71 !72 !74) -!3147 = (!3136 !1743 !1744 !76) -!3148 = (!3136 !1750) -!3149 = (!3136 !1752) -!3150 = (!3136 !1754 !1755) -!3151 = (!3136 !1754 !1755 !69) -!3152 = (!3136 !1754 !1755 !71 !72) -!3153 = (!3136 !1754 !1755 !71 !72 !74) -!3154 = (!3136 !1754 !1755 !76) -!3155 = (!3136 !1761) -!3156 = (!3136 !1763) -!3157 = (!3136 !1763) -!3158 = (!3136 !1763) -!3159 = (!3136 !1763) -!3160 = (!3136 !1763) -!3161 = (!3136 !1763) -!3162 = (!3136 !1770) -!3163 = (!3136 !1772 !111) -!3164 = (!3136 !1772 !113) -!3165 = (!3136 !1775) -!3166 = (!3136 !1777 !1778) -!3167 = (!3136 !1777 !1778 !69) -!3168 = (!3136 !1777 !1778 !71 !72) -!3169 = (!3136 !1777 !1778 !71 !72 !74) -!3170 = (!3136 !1777 !1778 !76) -!3171 = (!3136 !1784) -!3172 = (!3136 !1786) -!3173 = (!3136 !1788) -!3174 = (!3136 !1790 !111) -!3175 = (!3136 !1790 !113) -!3176 = (!3136 !1793 !1794 !1795) -!3177 = (!3136 !1793 !1794) -!3178 = (!3136 !1793 !1794 !1795) -!3179 = (!3136 !1799) -!3180 = (!3136 !1801 !111) -!3181 = (!3136 !1801 !113) -!3182 = (!3136 !1804) -!3183 = (!3136 !1806 !1807 !348 !349 !831 !832 !53) -!3184 = (!3136 !1806 !1807 !348 !349 !831 !832) -!3185 = (!3136 !1806 !1807 !348 !349 !831 !832 !56) -!3186 = (!3136 !1806 !1807 !348 !349 !831 !832 !59) -!3187 = (!3136 !1806 !1807 !92) -!3188 = (!3136 !1806 !1807 !92) -!3189 = (!3136 !1806 !1807 !92) -!3190 = (!3136 !2178) -!3191 = (!3136 !1814 !111) -!3192 = (!3136 !1814 !113) -!3193 = (!3136 !2182) -!3194 = span !101 8856 8910 -!3195 = span !101 8958 9045 -!3196 = fn_name_span !101 8961 8979 -!3197 = decl_index 47302 -!3198 = (!3195 !3196 !3197) -!3199 = span !101 9012 9023 -!3200 = span !101 2018 2028 -!3201 = span !101 9036 9041 -!3202 = span !101 9037 9038 -!3203 = span !101 9039 9040 -!3204 = span !101 8996 9042 -!3205 = (!3204 !1710) -!3206 = (!3204 !1712) -!3207 = (!3204 !1714) -!3208 = (!3204 !1737) -!3209 = (!3204 !1739) -!3210 = (!3204 !1741) -!3211 = (!3204 !1743 !1744) -!3212 = (!3204 !1743 !1744 !69) -!3213 = (!3204 !1743 !1744 !71 !72) -!3214 = (!3204 !1743 !1744 !71 !72 !74) -!3215 = (!3204 !1743 !1744 !76) -!3216 = (!3204 !1750) -!3217 = (!3204 !1752) -!3218 = (!3204 !1754 !1755) -!3219 = (!3204 !1754 !1755 !69) -!3220 = (!3204 !1754 !1755 !71 !72) -!3221 = (!3204 !1754 !1755 !71 !72 !74) -!3222 = (!3204 !1754 !1755 !76) -!3223 = (!3204 !1761) -!3224 = (!3204 !1763) -!3225 = (!3204 !1763) -!3226 = (!3204 !1763) -!3227 = (!3204 !1763) -!3228 = (!3204 !1763) -!3229 = (!3204 !1763) -!3230 = (!3204 !1770) -!3231 = (!3204 !1772 !111) -!3232 = (!3204 !1772 !113) -!3233 = (!3204 !1775) -!3234 = (!3204 !1777 !1778) -!3235 = (!3204 !1777 !1778 !69) -!3236 = (!3204 !1777 !1778 !71 !72) -!3237 = (!3204 !1777 !1778 !71 !72 !74) -!3238 = (!3204 !1777 !1778 !76) -!3239 = (!3204 !1784) -!3240 = (!3204 !1786) -!3241 = (!3204 !1788) -!3242 = (!3204 !1790 !111) -!3243 = (!3204 !1790 !113) -!3244 = (!3204 !1793 !1794 !1795) -!3245 = (!3204 !1793 !1794) -!3246 = (!3204 !1793 !1794 !1795) -!3247 = (!3204 !1799) -!3248 = (!3204 !1801 !111) -!3249 = (!3204 !1801 !113) -!3250 = (!3204 !1804) -!3251 = (!3204 !2178) -!3252 = (!3204 !1814 !111) -!3253 = (!3204 !1814 !113) -!3254 = (!3204 !2182) -!3255 = span !101 8988 9043 -!3256 = span !101 9091 9180 -!3257 = fn_name_span !101 9094 9112 -!3258 = decl_index 47496 -!3259 = (!3256 !3257 !3258) -!3260 = span !101 9145 9156 -!3261 = span !101 2111 2121 -!3262 = span !101 9169 9176 -!3263 = span !101 9170 9171 -!3264 = span !101 9172 9173 -!3265 = span !101 9174 9175 -!3266 = span !101 9129 9177 -!3267 = (!3266 !1710) -!3268 = (!3266 !1712) -!3269 = (!3266 !1714) -!3270 = (!3266 !1737) -!3271 = (!3266 !1739) -!3272 = (!3266 !1741) -!3273 = (!3266 !1743 !1744) -!3274 = (!3266 !1743 !1744 !69) -!3275 = (!3266 !1743 !1744 !71 !72) -!3276 = (!3266 !1743 !1744 !71 !72 !74) -!3277 = (!3266 !1743 !1744 !76) -!3278 = (!3266 !1750) -!3279 = (!3266 !1752) -!3280 = (!3266 !1754 !1755) -!3281 = (!3266 !1754 !1755 !69) -!3282 = (!3266 !1754 !1755 !71 !72) -!3283 = (!3266 !1754 !1755 !71 !72 !74) -!3284 = (!3266 !1754 !1755 !76) -!3285 = (!3266 !1761) -!3286 = (!3266 !1763) -!3287 = (!3266 !1763) -!3288 = (!3266 !1763) -!3289 = (!3266 !1763) -!3290 = (!3266 !1763) -!3291 = (!3266 !1763) -!3292 = (!3266 !1770) -!3293 = (!3266 !1772 !111) -!3294 = (!3266 !1772 !113) -!3295 = (!3266 !1775) -!3296 = (!3266 !1777 !1778) -!3297 = (!3266 !1777 !1778 !69) -!3298 = (!3266 !1777 !1778 !71 !72) -!3299 = (!3266 !1777 !1778 !71 !72 !74) -!3300 = (!3266 !1777 !1778 !76) -!3301 = (!3266 !1784) -!3302 = (!3266 !1786) -!3303 = (!3266 !1788) -!3304 = (!3266 !1790 !111) -!3305 = (!3266 !1790 !113) -!3306 = (!3266 !1793 !1794 !1795) -!3307 = (!3266 !1793 !1794) -!3308 = (!3266 !1793 !1794 !1795) -!3309 = (!3266 !1799) -!3310 = (!3266 !1801 !111) -!3311 = (!3266 !1801 !113) -!3312 = (!3266 !1804) -!3313 = (!3266 !2178) -!3314 = (!3266 !1814 !111) -!3315 = (!3266 !1814 !113) -!3316 = (!3266 !2182) -!3317 = span !101 9121 9178 -!3318 = span !101 9226 9317 -!3319 = fn_name_span !101 9229 9247 -!3320 = decl_index 47699 -!3321 = (!3318 !3319 !3320) -!3322 = span !101 9280 9291 -!3323 = span !101 2214 2224 -!3324 = span !101 9304 9313 -!3325 = span !101 9305 9306 -!3326 = span !101 9307 9308 -!3327 = span !101 9309 9310 -!3328 = span !101 9311 9312 -!3329 = span !101 9264 9314 -!3330 = (!3329 !1710) -!3331 = (!3329 !1712) -!3332 = (!3329 !1714) -!3333 = (!3329 !1716 !1717) -!3334 = (!3329 !1716 !1717 !109) -!3335 = (!3329 !1716 !1717 !1720 !1721) -!3336 = (!3329 !1716 !1717 !1720 !1721) -!3337 = (!3329 !1716 !1717 !1720 !1721 !1724) -!3338 = (!3329 !1716 !1717 !1720 !1721 !1726) -!3339 = (!3329 !1716 !1717 !1720 !1721 !1729) -!3340 = (!3329 !1716 !1717 !1720 !1721 !1731) -!3341 = (!3329 !1716 !1717 !1720 !1721 !1733) -!3342 = (!3329 !1716 !1717 !111) -!3343 = (!3329 !1716 !1717 !113) -!3344 = (!3329 !1737) -!3345 = (!3329 !1739) -!3346 = (!3329 !1741) -!3347 = (!3329 !1743 !1744) -!3348 = (!3329 !1743 !1744 !69) -!3349 = (!3329 !1743 !1744 !71 !72) -!3350 = (!3329 !1743 !1744 !71 !72 !74) -!3351 = (!3329 !1743 !1744 !76) -!3352 = (!3329 !1750) -!3353 = (!3329 !1752) -!3354 = (!3329 !1754 !1755) -!3355 = (!3329 !1754 !1755 !69) -!3356 = (!3329 !1754 !1755 !71 !72) -!3357 = (!3329 !1754 !1755 !71 !72 !74) -!3358 = (!3329 !1754 !1755 !76) -!3359 = (!3329 !1761) -!3360 = (!3329 !1763) -!3361 = (!3329 !1763) -!3362 = (!3329 !1763) -!3363 = (!3329 !1763) -!3364 = (!3329 !1763) -!3365 = (!3329 !1763) -!3366 = (!3329 !1770) -!3367 = (!3329 !1772 !111) -!3368 = (!3329 !1772 !113) -!3369 = (!3329 !1775) -!3370 = (!3329 !1777 !1778) -!3371 = (!3329 !1777 !1778 !69) -!3372 = (!3329 !1777 !1778 !71 !72) -!3373 = (!3329 !1777 !1778 !71 !72 !74) -!3374 = (!3329 !1777 !1778 !76) -!3375 = (!3329 !1784) -!3376 = (!3329 !1786) -!3377 = (!3329 !1788) -!3378 = (!3329 !1790 !111) -!3379 = (!3329 !1790 !113) -!3380 = (!3329 !1793 !1794 !1795) -!3381 = (!3329 !1793 !1794) -!3382 = (!3329 !1793 !1794 !1795) -!3383 = (!3329 !1799) -!3384 = (!3329 !1801 !111) -!3385 = (!3329 !1801 !113) -!3386 = (!3329 !1804) -!3387 = (!3329 !2178) -!3388 = (!3329 !1814 !111) -!3389 = (!3329 !1814 !113) -!3390 = (!3329 !2182) -!3391 = span !101 9256 9315 -!3392 = span !101 9367 9458 -!3393 = fn_name_span !101 9370 9383 -!3394 = decl_index 47901 -!3395 = (!3392 !3393 !3394) -!3396 = span !101 9416 9427 -!3397 = span !101 2331 2344 -!3398 = span !101 9443 9454 -!3399 = span !101 9451 9452 -!3400 = span !101 9400 9455 -!3401 = (!3400 !1710) -!3402 = (!3400 !1712) -!3403 = (!3400 !1714) -!3404 = (!3400 !1737) -!3405 = (!3400 !1739) -!3406 = (!3400 !1741) -!3407 = (!3400 !1743 !1744) -!3408 = (!3400 !1743 !1744 !69) -!3409 = (!3400 !1743 !1744 !71 !72) -!3410 = (!3400 !1743 !1744 !71 !72 !74) -!3411 = (!3400 !1743 !1744 !76) -!3412 = (!3400 !1750) -!3413 = (!3400 !1752) -!3414 = (!3400 !1754 !1755) -!3415 = (!3400 !1754 !1755 !69) -!3416 = (!3400 !1754 !1755 !71 !72) -!3417 = (!3400 !1754 !1755 !71 !72 !74) -!3418 = (!3400 !1754 !1755 !76) -!3419 = (!3400 !1761) -!3420 = (!3400 !1763) -!3421 = (!3400 !1763) -!3422 = (!3400 !1763) -!3423 = (!3400 !1763) -!3424 = (!3400 !1763) -!3425 = (!3400 !1763) -!3426 = (!3400 !1770) -!3427 = (!3400 !1772 !111) -!3428 = (!3400 !1772 !113) -!3429 = (!3400 !1775) -!3430 = (!3400 !1777 !1778) -!3431 = (!3400 !1777 !1778 !69) -!3432 = (!3400 !1777 !1778 !71 !72) -!3433 = (!3400 !1777 !1778 !71 !72 !74) -!3434 = (!3400 !1777 !1778 !76) -!3435 = (!3400 !1784) -!3436 = (!3400 !1786) -!3437 = (!3400 !1788) -!3438 = (!3400 !1790 !111) -!3439 = (!3400 !1790 !113) -!3440 = (!3400 !1793 !1794 !1795) -!3441 = (!3400 !1793 !1794) -!3442 = (!3400 !1793 !1794 !1795) -!3443 = (!3400 !1799) -!3444 = (!3400 !1801 !111) -!3445 = (!3400 !1801 !113) -!3446 = (!3400 !1804) -!3447 = (!3400 !2178) -!3448 = (!3400 !1814 !111) -!3449 = (!3400 !1814 !113) -!3450 = (!3400 !2182) -!3451 = span !101 9392 9456 -!3452 = (!1817 !1818) -!3453 = (!1720 !1721) -!3454 = (!1720 !1721 !1726) -!3455 = (!1720 !1721 !1731) -!3456 = span !101 9516 9621 -!3457 = fn_name_span !101 9519 9536 -!3458 = decl_index 48127 -!3459 = (!3456 !3457 !3458) -!3460 = span !101 9569 9580 -!3461 = span !101 2437 2454 -!3462 = span !101 9600 9617 -!3463 = span !101 9608 9609 -!3464 = span !101 9614 9615 -!3465 = span !101 9553 9618 -!3466 = (!3465 !1710) -!3467 = (!3465 !1712) -!3468 = (!3465 !1714) -!3469 = (!3465 !1737) -!3470 = (!3465 !1739) -!3471 = (!3465 !1741) -!3472 = (!3465 !1743 !1744) -!3473 = (!3465 !1743 !1744 !69) -!3474 = (!3465 !1743 !1744 !71 !72) -!3475 = (!3465 !1743 !1744 !71 !72 !74) -!3476 = (!3465 !1743 !1744 !76) -!3477 = (!3465 !1750) -!3478 = (!3465 !1752) -!3479 = (!3465 !1754 !1755) -!3480 = (!3465 !1754 !1755 !69) -!3481 = (!3465 !1754 !1755 !71 !72) -!3482 = (!3465 !1754 !1755 !71 !72 !74) -!3483 = (!3465 !1754 !1755 !76) -!3484 = (!3465 !1761) -!3485 = (!3465 !1763) -!3486 = (!3465 !1763) -!3487 = (!3465 !1763) -!3488 = (!3465 !1763) -!3489 = (!3465 !1763) -!3490 = (!3465 !1763) -!3491 = (!3465 !1770) -!3492 = (!3465 !1772 !111) -!3493 = (!3465 !1772 !113) -!3494 = (!3465 !1775) -!3495 = (!3465 !1777 !1778) -!3496 = (!3465 !1777 !1778 !69) -!3497 = (!3465 !1777 !1778 !71 !72) -!3498 = (!3465 !1777 !1778 !71 !72 !74) -!3499 = (!3465 !1777 !1778 !76) -!3500 = (!3465 !1784) -!3501 = (!3465 !1786) -!3502 = (!3465 !1788) -!3503 = (!3465 !1790 !111) -!3504 = (!3465 !1790 !113) -!3505 = (!3465 !1793 !1794 !1795) -!3506 = (!3465 !1793 !1794) -!3507 = (!3465 !1793 !1794 !1795) -!3508 = (!3465 !1799) -!3509 = (!3465 !1801 !111) -!3510 = (!3465 !1801 !113) -!3511 = (!3465 !1804) -!3512 = (!3465 !2178) -!3513 = (!3465 !1814 !111) -!3514 = (!3465 !1814 !113) -!3515 = (!3465 !2182) -!3516 = span !101 9545 9619 -!3517 = (!1817 !1818) -!3518 = (!1720 !1721) -!3519 = (!1720 !1721 !1726) -!3520 = (!1720 !1721 !1731) -!3521 = span !101 9687 9806 -!3522 = fn_name_span !101 9690 9711 -!3523 = decl_index 48377 -!3524 = (!3521 !3522 !3523) -!3525 = span !101 9744 9755 -!3526 = span !101 2561 2582 -!3527 = span !101 9779 9802 -!3528 = span !101 9787 9788 -!3529 = span !101 9793 9794 -!3530 = span !101 9799 9800 -!3531 = span !101 9728 9803 -!3532 = (!3531 !1710) -!3533 = (!3531 !1712) -!3534 = (!3531 !1714) -!3535 = (!3531 !1737) -!3536 = (!3531 !1739) -!3537 = (!3531 !1741) -!3538 = (!3531 !1743 !1744) -!3539 = (!3531 !1743 !1744 !69) -!3540 = (!3531 !1743 !1744 !71 !72) -!3541 = (!3531 !1743 !1744 !71 !72 !74) -!3542 = (!3531 !1743 !1744 !76) -!3543 = (!3531 !1750) -!3544 = (!3531 !1752) -!3545 = (!3531 !1754 !1755) -!3546 = (!3531 !1754 !1755 !69) -!3547 = (!3531 !1754 !1755 !71 !72) -!3548 = (!3531 !1754 !1755 !71 !72 !74) -!3549 = (!3531 !1754 !1755 !76) -!3550 = (!3531 !1761) -!3551 = (!3531 !1763) -!3552 = (!3531 !1763) -!3553 = (!3531 !1763) -!3554 = (!3531 !1763) -!3555 = (!3531 !1763) -!3556 = (!3531 !1763) -!3557 = (!3531 !1770) -!3558 = (!3531 !1772 !111) -!3559 = (!3531 !1772 !113) -!3560 = (!3531 !1775) -!3561 = (!3531 !1777 !1778) -!3562 = (!3531 !1777 !1778 !69) -!3563 = (!3531 !1777 !1778 !71 !72) -!3564 = (!3531 !1777 !1778 !71 !72 !74) -!3565 = (!3531 !1777 !1778 !76) -!3566 = (!3531 !1784) -!3567 = (!3531 !1786) -!3568 = (!3531 !1788) -!3569 = (!3531 !1790 !111) -!3570 = (!3531 !1790 !113) -!3571 = (!3531 !1793 !1794 !1795) -!3572 = (!3531 !1793 !1794) -!3573 = (!3531 !1793 !1794 !1795) -!3574 = (!3531 !1799) -!3575 = (!3531 !1801 !111) -!3576 = (!3531 !1801 !113) -!3577 = (!3531 !1804) -!3578 = (!3531 !2178) -!3579 = (!3531 !1814 !111) -!3580 = (!3531 !1814 !113) -!3581 = (!3531 !2182) -!3582 = span !101 9720 9804 -!3583 = (!1817 !1818) -!3584 = (!1720 !1721) -!3585 = (!1720 !1721 !1726) -!3586 = (!1720 !1721 !1731) -!3587 = span !101 9866 9950 -!3588 = fn_name_span !101 9869 9880 -!3589 = decl_index 48599 -!3590 = (!3587 !3588 !3589) -!3591 = span !101 9913 9924 -!3592 = span !101 2693 2704 -!3593 = span !101 9944 9945 -!3594 = span !101 9897 9947 -!3595 = (!3594 !1710) -!3596 = (!3594 !1712) -!3597 = (!3594 !1714) -!3598 = (!3594 !1716 !1717) -!3599 = (!3594 !1716 !1717 !109) -!3600 = (!3594 !1716 !1717 !1720 !1721) -!3601 = (!3594 !1716 !1717 !1720 !1721) -!3602 = (!3594 !1716 !1717 !1720 !1721 !1724) -!3603 = (!3594 !1716 !1717 !1720 !1721 !1726) -!3604 = (!3594 !1716 !1717 !1720 !1721 !1729) -!3605 = (!3594 !1716 !1717 !1720 !1721 !1731) -!3606 = (!3594 !1716 !1717 !1720 !1721 !1733) -!3607 = (!3594 !1716 !1717 !111) -!3608 = (!3594 !1716 !1717 !113) -!3609 = (!3594 !1737) -!3610 = (!3594 !1739) -!3611 = (!3594 !1741) -!3612 = (!3594 !1743 !1744) -!3613 = (!3594 !1743 !1744 !69) -!3614 = (!3594 !1743 !1744 !71 !72) -!3615 = (!3594 !1743 !1744 !71 !72 !74) -!3616 = (!3594 !1743 !1744 !76) -!3617 = (!3594 !1750) -!3618 = (!3594 !1752) -!3619 = (!3594 !1754 !1755) -!3620 = (!3594 !1754 !1755 !69) -!3621 = (!3594 !1754 !1755 !71 !72) -!3622 = (!3594 !1754 !1755 !71 !72 !74) -!3623 = (!3594 !1754 !1755 !76) -!3624 = (!3594 !1761) -!3625 = (!3594 !1763) -!3626 = (!3594 !1763) -!3627 = (!3594 !1763) -!3628 = (!3594 !1763) -!3629 = (!3594 !1763) -!3630 = (!3594 !1763) -!3631 = (!3594 !1770) -!3632 = (!3594 !1772 !111) -!3633 = (!3594 !1772 !113) -!3634 = (!3594 !1775) -!3635 = (!3594 !1777 !1778) -!3636 = (!3594 !1777 !1778 !69) -!3637 = (!3594 !1777 !1778 !71 !72) -!3638 = (!3594 !1777 !1778 !71 !72 !74) -!3639 = (!3594 !1777 !1778 !76) -!3640 = (!3594 !1784) -!3641 = (!3594 !1786) -!3642 = (!3594 !1788) -!3643 = (!3594 !1790 !111) -!3644 = (!3594 !1790 !113) -!3645 = (!3594 !1793 !1794 !1795) -!3646 = (!3594 !1793 !1794) -!3647 = (!3594 !1793 !1794 !1795) -!3648 = (!3594 !1799) -!3649 = (!3594 !1801 !111) -!3650 = (!3594 !1801 !113) -!3651 = (!3594 !1804) -!3652 = (!3594 !2178) -!3653 = (!3594 !1814 !111) -!3654 = (!3594 !1814 !113) -!3655 = (!3594 !2182) -!3656 = span !101 9889 9948 -!3657 = span !101 10004 10096 -!3658 = fn_name_span !101 10007 10022 -!3659 = decl_index 48855 -!3660 = (!3657 !3658 !3659) -!3661 = span !101 10055 10066 -!3662 = span !101 2789 2804 -!3663 = span !101 10090 10091 -!3664 = span !101 10039 10093 -!3665 = (!3664 !1710) -!3666 = (!3664 !1712) -!3667 = (!3664 !1714) -!3668 = (!3664 !1716 !1717) -!3669 = (!3664 !1716 !1717 !109) -!3670 = (!3664 !1716 !1717 !1720 !1721) -!3671 = (!3664 !1716 !1717 !1720 !1721) -!3672 = (!3664 !1716 !1717 !1720 !1721 !1724) -!3673 = (!3664 !1716 !1717 !1720 !1721 !1726) -!3674 = (!3664 !1716 !1717 !1720 !1721 !1729) -!3675 = (!3664 !1716 !1717 !1720 !1721 !1731) -!3676 = (!3664 !1716 !1717 !1720 !1721 !1733) -!3677 = (!3664 !1716 !1717 !111) -!3678 = (!3664 !1716 !1717 !113) -!3679 = (!3664 !1737) -!3680 = (!3664 !1739) -!3681 = (!3664 !1741) -!3682 = (!3664 !1743 !1744) -!3683 = (!3664 !1743 !1744 !69) -!3684 = (!3664 !1743 !1744 !71 !72) -!3685 = (!3664 !1743 !1744 !71 !72 !74) -!3686 = (!3664 !1743 !1744 !76) -!3687 = (!3664 !1750) -!3688 = (!3664 !1752) -!3689 = (!3664 !1754 !1755) -!3690 = (!3664 !1754 !1755 !69) -!3691 = (!3664 !1754 !1755 !71 !72) -!3692 = (!3664 !1754 !1755 !71 !72 !74) -!3693 = (!3664 !1754 !1755 !76) -!3694 = (!3664 !1761) -!3695 = (!3664 !1763) -!3696 = (!3664 !1763) -!3697 = (!3664 !1763) -!3698 = (!3664 !1763) -!3699 = (!3664 !1763) -!3700 = (!3664 !1763) -!3701 = (!3664 !1770) -!3702 = (!3664 !1772 !111) -!3703 = (!3664 !1772 !113) -!3704 = (!3664 !1775) -!3705 = (!3664 !1777 !1778) -!3706 = (!3664 !1777 !1778 !69) -!3707 = (!3664 !1777 !1778 !71 !72) -!3708 = (!3664 !1777 !1778 !71 !72 !74) -!3709 = (!3664 !1777 !1778 !76) -!3710 = (!3664 !1784) -!3711 = (!3664 !1786) -!3712 = (!3664 !1788) -!3713 = (!3664 !1790 !111) -!3714 = (!3664 !1790 !113) -!3715 = (!3664 !1793 !1794 !1795) -!3716 = (!3664 !1793 !1794) -!3717 = (!3664 !1793 !1794 !1795) -!3718 = (!3664 !1799) -!3719 = (!3664 !1801 !111) -!3720 = (!3664 !1801 !113) -!3721 = (!3664 !1804) -!3722 = (!3664 !2178) -!3723 = (!3664 !1814 !111) -!3724 = (!3664 !1814 !113) -!3725 = (!3664 !2182) -!3726 = span !101 10031 10094 -!3727 = span !101 10158 10258 -!3728 = fn_name_span !101 10161 10180 -!3729 = decl_index 49145 -!3730 = (!3727 !3728 !3729) -!3731 = span !101 10213 10224 -!3732 = span !101 2907 2926 -!3733 = span !101 10252 10253 -!3734 = span !101 10197 10255 -!3735 = (!3734 !1710) -!3736 = (!3734 !1712) -!3737 = (!3734 !1714) -!3738 = (!3734 !1716 !1717) -!3739 = (!3734 !1716 !1717 !109) -!3740 = (!3734 !1716 !1717 !1720 !1721) -!3741 = (!3734 !1716 !1717 !1720 !1721) -!3742 = (!3734 !1716 !1717 !1720 !1721 !1724) -!3743 = (!3734 !1716 !1717 !1720 !1721 !1726) -!3744 = (!3734 !1716 !1717 !1720 !1721 !1729) -!3745 = (!3734 !1716 !1717 !1720 !1721 !1731) -!3746 = (!3734 !1716 !1717 !1720 !1721 !1733) -!3747 = (!3734 !1716 !1717 !111) -!3748 = (!3734 !1716 !1717 !113) -!3749 = (!3734 !1737) -!3750 = (!3734 !1739) -!3751 = (!3734 !1741) -!3752 = (!3734 !1743 !1744) -!3753 = (!3734 !1743 !1744 !69) -!3754 = (!3734 !1743 !1744 !71 !72) -!3755 = (!3734 !1743 !1744 !71 !72 !74) -!3756 = (!3734 !1743 !1744 !76) -!3757 = (!3734 !1750) -!3758 = (!3734 !1752) -!3759 = (!3734 !1754 !1755) -!3760 = (!3734 !1754 !1755 !69) -!3761 = (!3734 !1754 !1755 !71 !72) -!3762 = (!3734 !1754 !1755 !71 !72 !74) -!3763 = (!3734 !1754 !1755 !76) -!3764 = (!3734 !1761) -!3765 = (!3734 !1763) -!3766 = (!3734 !1763) -!3767 = (!3734 !1763) -!3768 = (!3734 !1763) -!3769 = (!3734 !1763) -!3770 = (!3734 !1763) -!3771 = (!3734 !1770) -!3772 = (!3734 !1772 !111) -!3773 = (!3734 !1772 !113) -!3774 = (!3734 !1775) -!3775 = (!3734 !1777 !1778) -!3776 = (!3734 !1777 !1778 !69) -!3777 = (!3734 !1777 !1778 !71 !72) -!3778 = (!3734 !1777 !1778 !71 !72 !74) -!3779 = (!3734 !1777 !1778 !76) -!3780 = (!3734 !1784) -!3781 = (!3734 !1786) -!3782 = (!3734 !1788) -!3783 = (!3734 !1790 !111) -!3784 = (!3734 !1790 !113) -!3785 = (!3734 !1793 !1794 !1795) -!3786 = (!3734 !1793 !1794) -!3787 = (!3734 !1793 !1794 !1795) -!3788 = (!3734 !1799) -!3789 = (!3734 !1801 !111) -!3790 = (!3734 !1801 !113) -!3791 = (!3734 !1804) -!3792 = (!3734 !2178) -!3793 = (!3734 !1814 !111) -!3794 = (!3734 !1814 !113) -!3795 = (!3734 !2182) -!3796 = span !101 10189 10256 - - Finished release [optimized + fuel] target(s) [55.368 KB] in ??? ->>>>>>> 58e204d50 (better tests to measure cost of contract calls) -======= -======= ->>>>>>> 5f2f098c4 (update test snapshot) -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 101 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD - Finished release [optimized + fuel] target(s) [40.528 KB] in ??? ->>>>>>> dbd26f625 (bring whole snapshot test back) -<<<<<<< HEAD ->>>>>>> 8cc595443 (bring whole snapshot test back) -======= -======= - Finished release [optimized + fuel] target(s) [38.76 KB] in ??? ->>>>>>> 3d8d19bf9 (fix snapshot test harness) -<<<<<<< HEAD ->>>>>>> 044822ba8 (fix snapshot test harness) -======= -======= - Finished release [optimized + fuel] target(s) [36.248 KB] in ??? ->>>>>>> a763fb282 (rename tests for better historic comparison) -<<<<<<< HEAD ->>>>>>> 1aaba9b99 (rename tests for better historic comparison) -======= -======= - Finished release [optimized + fuel] target(s) [38.76 KB] in ??? ->>>>>>> 41c12b7bb (fix CI) -<<<<<<< HEAD ->>>>>>> 65a8b88af (fix CI) -======= -======= - Finished release [optimized + fuel] target(s) [36.568 KB] in ??? ->>>>>>> 62f7022c1 (improve method selection on contracts) ->>>>>>> 7ad706b99 (improve method selection on contracts) -======= - Finished release [optimized + fuel] target(s) [32.624 KB] in ??? ->>>>>>> 5f2f098c4 (update test snapshot) - Running 29 tests, filtered 0 tests - -tested -- const_of_contract_call - -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD -<<<<<<< HEAD - test cost_of_in_bool ... ok (???, 14600 gas) - test cost_of_in_u8 ... ok (???, 18427 gas) - test cost_of_in_u16 ... ok (???, 17781 gas) - test cost_of_in_u32 ... ok (???, 18557 gas) - test cost_of_in_u64 ... ok (???, 18536 gas) - test cost_of_in_u256 ... ok (???, 18265 gas) - test cost_of_in_b256 ... ok (???, 14378 gas) - test cost_of_in_str_0 ... ok (???, 15302 gas) - test cost_of_in_str_1 ... ok (???, 15805 gas) - test cost_of_in_str_8 ... ok (???, 16528 gas) - test cost_of_in_str_16 ... ok (???, 15865 gas) - test cost_of_in_str_32 ... ok (???, 16205 gas) - test cost_of_in_array_0 ... FAILED (???, 12886 gas) - test cost_of_in_array_1 ... ok (???, 13775 gas) - test cost_of_in_array_8 ... ok (???, 18788 gas) - test cost_of_in_array_16 ... ok (???, 19141 gas) - test cost_of_in_array_32 ... ok (???, 25119 gas) - test cost_of_in_array_64 ... ok (???, 36762 gas) - test cost_of_in_tuple_0 ... ok (???, 16648 gas) - test cost_of_in_tuple_1 ... ok (???, 17622 gas) - test cost_of_in_tuple_2 ... ok (???, 18257 gas) - test cost_of_in_tuple_3 ... ok (???, 18849 gas) - test cost_of_in_tuple_4 ... ok (???, 19471 gas) - test in_struct_u64 ... ok (???, 16337 gas) - test in_struct_u64_u64 ... ok (???, 16791 gas) - test in_struct_u64_u64_u64 ... ok (???, 17241 gas) - test in_enum_u64 ... ok (???, 15575 gas) - test in_enum_u64_u64 ... ok (???, 15362 gas) - test in_enum_u64_u64_u64 ... ok (???, 15551 gas) -======= -======= ->>>>>>> 8cc595443 (bring whole snapshot test back) -======= ->>>>>>> 044822ba8 (fix snapshot test harness) -======= ->>>>>>> 1aaba9b99 (rename tests for better historic comparison) -======= ->>>>>>> 65a8b88af (fix CI) -======= ->>>>>>> 7ad706b99 (improve method selection on contracts) -<<<<<<< HEAD - test cost_of_in_bool ... ok (???, 2082 gas) - test cost_of_in_u8 ... ok (???, 4331 gas) - test cost_of_in_u16 ... ok (???, 3948 gas) - test cost_of_in_u32 ... ok (???, 4389 gas) - test cost_of_in_u64 ... ok (???, 4397 gas) - test cost_of_in_u256 ... ok (???, 4240 gas) - test cost_of_in_b256 ... ok (???, 1954 gas) - test cost_of_in_str_0 ... ok (???, 2505 gas) - test cost_of_in_str_1 ... ok (???, 2806 gas) - test cost_of_in_str_8 ... ok (???, 3229 gas) - test cost_of_in_str_16 ... ok (???, 2837 gas) - test cost_of_in_str_32 ... ok (???, 3035 gas) - test cost_of_in_array_0 ... FAILED (???, 1095 gas) - test cost_of_in_array_1 ... ok (???, 1589 gas) - test cost_of_in_array_8 ... ok (???, 4192 gas) - test cost_of_in_array_16 ... ok (???, 4563 gas) - test cost_of_in_array_32 ... ok (???, 7889 gas) - test cost_of_in_array_64 ... ok (???, 14352 gas) - test cost_of_in_tuple_0 ... ok (???, 3289 gas) - test cost_of_in_tuple_1 ... ok (???, 3860 gas) - test cost_of_in_tuple_2 ... ok (???, 4228 gas) - test cost_of_in_tuple_3 ... ok (???, 4571 gas) - test cost_of_in_tuple_4 ... ok (???, 4935 gas) - test in_struct_u64 ... ok (???, 3103 gas) - test in_struct_u64_u64 ... ok (???, 3364 gas) - test in_struct_u64_u64_u64 ... ok (???, 3623 gas) - test in_enum_u64 ... ok (???, 2653 gas) - test in_enum_u64_u64 ... ok (???, 2528 gas) - test in_enum_u64_u64_u64 ... ok (???, 2640 gas) ->>>>>>> ce8248b66 (better tests to measure cost of contract calls) -======= - test cost_of_in_bool ... ok (???, 969 gas) - test cost_of_in_u8 ... ok (???, 952 gas) - test cost_of_in_u16 ... ok (???, 1017 gas) - test cost_of_in_u32 ... ok (???, 1152 gas) - test cost_of_in_u64 ... ok (???, 973 gas) - test cost_of_in_u256 ... ok (???, 1040 gas) - test cost_of_in_b256 ... ok (???, 1033 gas) - test cost_of_in_str_0 ... ok (???, 1028 gas) - test cost_of_in_str_1 ... ok (???, 1138 gas) - test cost_of_in_str_8 ... ok (???, 1146 gas) - test cost_of_in_str_16 ... ok (???, 1144 gas) - test cost_of_in_str_32 ... ok (???, 1149 gas) - test cost_of_in_array_0 ... FAILED (???, 866 gas) - test cost_of_in_array_1 ... ok (???, 1167 gas) - test cost_of_in_array_8 ... ok (???, 3251 gas) - test cost_of_in_array_16 ... ok (???, 4112 gas) - test cost_of_in_array_32 ... ok (???, 7277 gas) - test cost_of_in_array_64 ... ok (???, 13579 gas) - test cost_of_in_tuple_0 ... ok (???, 692 gas) - test cost_of_in_tuple_1 ... ok (???, 1071 gas) - test cost_of_in_tuple_2 ... ok (???, 1249 gas) - test cost_of_in_tuple_3 ... ok (???, 1398 gas) - test cost_of_in_tuple_4 ... ok (???, 1570 gas) - test in_struct_u64 ... ok (???, 1086 gas) - test in_struct_u64_u64 ... ok (???, 1245 gas) - test in_struct_u64_u64_u64 ... ok (???, 1398 gas) - test in_enum_u64 ... ok (???, 1286 gas) - test in_enum_u64_u64 ... ok (???, 1296 gas) - test in_enum_u64_u64_u64 ... ok (???, 1305 gas) ->>>>>>> 5f2f098c4 (update test snapshot) - - failures: - test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 - revert code: 0 - - - -test result: FAILED. 28 passed; 1 failed; finished in ??? - - Finished in ??? -error: Some tests failed. - -> Block: ARRAY0 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 101 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.48 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - -<<<<<<< HEAD - test isolated_cost_of_in_array_0 ... FAILED (???, 10911 gas) -======= - test isolated_cost_of_in_array_0 ... FAILED (???, 623 gas) ->>>>>>> 5f2f098c4 (update test snapshot) - - failures: - test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 - revert code: 0 - - - -test result: FAILED. 0 passed; 1 failed; finished in ??? - - Finished in ??? -error: Some tests failed. - -> Block: ARRAY1 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.656 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - -<<<<<<< HEAD - test isolated_cost_of_in_array_1 ... ok (???, 11355 gas) -======= - test isolated_cost_of_in_array_1 ... ok (???, 852 gas) ->>>>>>> 5f2f098c4 (update test snapshot) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ARRAY16 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.688 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - -<<<<<<< HEAD - test isolated_cost_of_in_array_16 ... ok (???, 15174 gas) -======= - test isolated_cost_of_in_array_16 ... ok (???, 2933 gas) ->>>>>>> 5f2f098c4 (update test snapshot) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ARRAY32 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.688 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - -<<<<<<< HEAD - test isolated_cost_of_in_array_32 ... ok (???, 19221 gas) -======= - test isolated_cost_of_in_array_32 ... ok (???, 5138 gas) ->>>>>>> 5f2f098c4 (update test snapshot) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ARRAY64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) -<<<<<<< HEAD - Finished release [optimized + fuel] target(s) [2.008 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_array_64 ... ok (???, 27369 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ARRAY8 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.104 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_array_8 ... ok (???, 14558 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: B256 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.808 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_b256 ... ok (???, 11220 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: BOOL -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.696 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_bool ... ok (???, 11100 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ENUM_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.008 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test in_enum_u64 ... ok (???, 11617 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ENUM_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.16 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test in_enum_u64_u64 ... ok (???, 11654 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: ENUM_U64_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.344 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test in_enum_u64_u64_u64 ... ok (???, 11675 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STR0 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) -======= ->>>>>>> 5f2f098c4 (update test snapshot) - Finished release [optimized + fuel] target(s) [1.728 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - -<<<<<<< HEAD - test isolated_cost_of_in_str_0 ... ok (???, 11250 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STR1 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.928 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_str_1 ... ok (???, 11411 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STR16 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.976 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_str_16 ... ok (???, 11425 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STR32 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.992 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_str_32 ... ok (???, 11431 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STR8 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.944 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_str_8 ... ok (???, 11421 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STRUCT_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.824 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test in_struct_u64 ... ok (???, 11211 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STRUCT_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.96 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test in_struct_u64_u64 ... ok (???, 11561 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: STRUCT_U64_U64_U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.032 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test in_struct_u64_u64_u64 ... ok (???, 11829 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: TUPLE0 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.12 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_tuple_0 ... ok (???, 10630 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: TUPLE1 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.768 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_tuple_1 ... ok (???, 11172 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: TUPLE2 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.944 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_tuple_2 ... ok (???, 11560 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: TUPLE3 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.016 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_tuple_3 ... ok (???, 11829 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: TUPLE4 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.08 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_tuple_4 ... ok (???, 12097 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: U16 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.72 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_u16 ... ok (???, 11232 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: U256 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.808 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_u256 ... ok (???, 11220 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: U32 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.832 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_u32 ... ok (???, 11475 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: U64 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.624 KB] in ??? - Running 1 test, filtered 0 tests - -tested -- const_of_contract_call - - test isolated_cost_of_in_u64 ... ok (???, 11059 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? - -> Block: U8 -> replace-file src/main.sw "fn cost_of_in" "fn isolated_cost_of_in" - -> forc test --path test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call --release --experimental const_generics -exit status: 0 -output: - Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call - Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) - Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [1.664 KB] in ??? - Running 1 test, filtered 0 tests + Finished release [optimized + fuel] target(s) [32.624 KB] in ??? + Running 29 tests, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_u8 ... ok (???, 11085 gas) - -test result: OK. 1 passed; 0 failed; finished in ??? - - Finished in ??? -======= - test cost_of_in_bool ... ok (???, 3371 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_u8 ... ok (???, 5610 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_u16 ... ok (???, 5227 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_u32 ... ok (???, 5672 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_u64 ... ok (???, 5673 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_u256 ... ok (???, 5520 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_b256 ... ok (???, 3250 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_str_0 ... ok (???, 3784 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_str_1 ... ok (???, 4091 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_str_8 ... ok (???, 4512 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_str_16 ... ok (???, 4122 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_str_32 ... ok (???, 4318 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_array_0 ... ok (???, 3174 gas) - decoded log values: -100, log rb: 1515152261580153489 -0, log rb: 1515152261580153489 -0, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -0, log rb: 1515152261580153489 -0, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_array_1 ... ok (???, 4031 gas) - decoded log values: -100, log rb: 1515152261580153489 -1, log rb: 1515152261580153489 -1, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -1, log rb: 1515152261580153489 -1, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_array_8 ... ok (???, 9221 gas) - decoded log values: -100, log rb: 1515152261580153489 -8, log rb: 1515152261580153489 -8, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -[0, 0, 0, 0, 0, 0, 0, 0], log rb: 3565715504387854074 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -8, log rb: 1515152261580153489 -8, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_array_16 ... FAILED (???, 5970 gas) - decoded log values: -100, log rb: 1515152261580153489 -16, log rb: 1515152261580153489 -16, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 - test cost_of_in_array_32 ... FAILED (???, 7884 gas) - decoded log values: -100, log rb: 1515152261580153489 -32, log rb: 1515152261580153489 -32, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 - test cost_of_in_array_64 ... FAILED (???, 11544 gas) - decoded log values: -100, log rb: 1515152261580153489 -64, log rb: 1515152261580153489 -64, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 -2, log rb: 1515152261580153489 - test cost_of_in_tuple_0 ... ok (???, 4538 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_tuple_1 ... ok (???, 5114 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_tuple_2 ... ok (???, 5484 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_tuple_3 ... ok (???, 5828 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test cost_of_in_tuple_4 ... ok (???, 6188 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test in_struct_u64 ... ok (???, 4357 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test in_struct_u64_u64 ... ok (???, 4612 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test in_struct_u64_u64_u64 ... ok (???, 4872 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test in_enum_u64 ... ok (???, 3910 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test in_enum_u64_u64 ... ok (???, 3781 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 - test in_enum_u64_u64_u64 ... ok (???, 3891 gas) - decoded log values: -100, log rb: 1515152261580153489 -101, log rb: 1515152261580153489 -102, log rb: 1515152261580153489 -103, log rb: 1515152261580153489 -======= - test cost_of_in_bool ... ok (???, 2590 gas) - test cost_of_in_u8 ... ok (???, 4829 gas) - test cost_of_in_u16 ... ok (???, 4446 gas) - test cost_of_in_u32 ... ok (???, 4879 gas) - test cost_of_in_u64 ... ok (???, 4888 gas) - test cost_of_in_u256 ... ok (???, 4730 gas) - test cost_of_in_b256 ... ok (???, 2460 gas) - test cost_of_in_str_0 ... ok (???, 2997 gas) - test cost_of_in_str_1 ... ok (???, 3299 gas) - test cost_of_in_str_8 ... ok (???, 3720 gas) - test cost_of_in_str_16 ... ok (???, 3330 gas) - test cost_of_in_str_32 ... ok (???, 3526 gas) - test cost_of_in_array_0 ... ok (???, 1976 gas) - test cost_of_in_array_1 ... ok (???, 3164 gas) - test cost_of_in_array_8 ... ok (???, 10767 gas) - test cost_of_in_array_16 ... ok (???, 16726 gas) - test cost_of_in_array_32 ... ok (???, 31337 gas) - test cost_of_in_array_64 ... ok (???, 60382 gas) - test cost_of_in_tuple_0 ... ok (???, 3777 gas) - test cost_of_in_tuple_1 ... ok (???, 4346 gas) - test cost_of_in_tuple_2 ... ok (???, 4711 gas) - test cost_of_in_tuple_3 ... ok (???, 5058 gas) - test cost_of_in_tuple_4 ... ok (???, 5422 gas) - test in_struct_u64 ... ok (???, 3589 gas) - test in_struct_u64_u64 ... ok (???, 3847 gas) - test in_struct_u64_u64_u64 ... ok (???, 4110 gas) - test in_enum_u64 ... ok (???, 3149 gas) - test in_enum_u64_u64 ... ok (???, 3020 gas) - test in_enum_u64_u64_u64 ... ok (???, 3130 gas) ->>>>>>> dbd26f625 (bring whole snapshot test back) -======= -======= ->>>>>>> 41c12b7bb (fix CI) - test cost_of_in_bool ... ok (???, 2627 gas) - test cost_of_in_u8 ... ok (???, 4874 gas) - test cost_of_in_u16 ... ok (???, 4493 gas) - test cost_of_in_u32 ... ok (???, 4926 gas) - test cost_of_in_u64 ... ok (???, 4934 gas) - test cost_of_in_u256 ... ok (???, 4777 gas) - test cost_of_in_b256 ... ok (???, 2491 gas) - test cost_of_in_str_0 ... ok (???, 3043 gas) - test cost_of_in_str_1 ... ok (???, 3345 gas) - test cost_of_in_str_8 ... ok (???, 3768 gas) - test cost_of_in_str_16 ... ok (???, 3374 gas) - test cost_of_in_str_32 ... ok (???, 3572 gas) - test cost_of_in_array_0 ... FAILED (???, 1632 gas) - test cost_of_in_array_1 ... ok (???, 2125 gas) - test cost_of_in_array_8 ... ok (???, 4724 gas) - test cost_of_in_array_16 ... ok (???, 5096 gas) - test cost_of_in_array_32 ... ok (???, 8421 gas) - test cost_of_in_array_64 ... ok (???, 14895 gas) - test cost_of_in_tuple_0 ... ok (???, 3822 gas) - test cost_of_in_tuple_1 ... ok (???, 4392 gas) - test cost_of_in_tuple_2 ... ok (???, 4761 gas) - test cost_of_in_tuple_3 ... ok (???, 5104 gas) - test cost_of_in_tuple_4 ... ok (???, 5468 gas) - test in_struct_u64 ... ok (???, 3635 gas) - test in_struct_u64_u64 ... ok (???, 3897 gas) - test in_struct_u64_u64_u64 ... ok (???, 4156 gas) - test in_enum_u64 ... ok (???, 3186 gas) - test in_enum_u64_u64 ... ok (???, 3061 gas) - test in_enum_u64_u64_u64 ... ok (???, 3173 gas) -<<<<<<< HEAD ->>>>>>> 3d8d19bf9 (fix snapshot test harness) -======= - test cost_of_in_bool ... ok (???, 2279 gas) - test cost_of_in_u8 ... ok (???, 4526 gas) - test cost_of_in_u16 ... ok (???, 4141 gas) - test cost_of_in_u32 ... ok (???, 4582 gas) - test cost_of_in_u64 ... ok (???, 4589 gas) - test cost_of_in_u256 ... ok (???, 4433 gas) - test cost_of_in_b256 ... ok (???, 2147 gas) - test cost_of_in_str_0 ... ok (???, 2697 gas) - test cost_of_in_str_1 ... ok (???, 2998 gas) - test cost_of_in_str_8 ... ok (???, 3421 gas) - test cost_of_in_str_16 ... ok (???, 3030 gas) - test cost_of_in_str_32 ... ok (???, 3227 gas) - test cost_of_in_array_0 ... FAILED (???, 1285 gas) - test cost_of_in_array_1 ... ok (???, 1779 gas) - test cost_of_in_array_8 ... ok (???, 4382 gas) - test cost_of_in_array_16 ... ok (???, 4753 gas) - test cost_of_in_array_32 ... ok (???, 8079 gas) - test cost_of_in_array_64 ... ok (???, 14545 gas) - test cost_of_in_tuple_0 ... ok (???, 3479 gas) - test cost_of_in_tuple_1 ... ok (???, 4050 gas) - test cost_of_in_tuple_2 ... ok (???, 4418 gas) - test cost_of_in_tuple_3 ... ok (???, 4761 gas) - test cost_of_in_tuple_4 ... ok (???, 5126 gas) - test in_struct_u64 ... ok (???, 3293 gas) - test in_struct_u64_u64 ... ok (???, 3554 gas) - test in_struct_u64_u64_u64 ... ok (???, 3813 gas) - test in_enum_u64 ... ok (???, 2843 gas) - test in_enum_u64_u64 ... ok (???, 2718 gas) - test in_enum_u64_u64_u64 ... ok (???, 2830 gas) ->>>>>>> a763fb282 (rename tests for better historic comparison) -======= ->>>>>>> 41c12b7bb (fix CI) -======= - test cost_of_in_bool ... ok (???, 1514 gas) - test cost_of_in_u8 ... ok (???, 1493 gas) - test cost_of_in_u16 ... ok (???, 1554 gas) - test cost_of_in_u32 ... ok (???, 1689 gas) - test cost_of_in_u64 ... ok (???, 1512 gas) - test cost_of_in_u256 ... ok (???, 1577 gas) - test cost_of_in_b256 ... ok (???, 1570 gas) - test cost_of_in_str_0 ... ok (???, 1564 gas) - test cost_of_in_str_1 ... ok (???, 1675 gas) - test cost_of_in_str_8 ... ok (???, 1683 gas) - test cost_of_in_str_16 ... ok (???, 1681 gas) - test cost_of_in_str_32 ... ok (???, 1686 gas) - test cost_of_in_array_0 ... FAILED (???, 1403 gas) - test cost_of_in_array_1 ... ok (???, 1703 gas) - test cost_of_in_array_8 ... ok (???, 3783 gas) - test cost_of_in_array_16 ... ok (???, 4645 gas) - test cost_of_in_array_32 ... ok (???, 7809 gas) - test cost_of_in_array_64 ... ok (???, 14122 gas) - test cost_of_in_tuple_0 ... ok (???, 1225 gas) - test cost_of_in_tuple_1 ... ok (???, 1604 gas) - test cost_of_in_tuple_2 ... ok (???, 1782 gas) - test cost_of_in_tuple_3 ... ok (???, 1932 gas) - test cost_of_in_tuple_4 ... ok (???, 2103 gas) - test in_struct_u64 ... ok (???, 1619 gas) - test in_struct_u64_u64 ... ok (???, 1778 gas) - test in_struct_u64_u64_u64 ... ok (???, 1932 gas) - test in_enum_u64 ... ok (???, 1819 gas) - test in_enum_u64_u64 ... ok (???, 1829 gas) - test in_enum_u64_u64_u64 ... ok (???, 1838 gas) ->>>>>>> 62f7022c1 (improve method selection on contracts) + test cost_of_in_bool ... ok (???, 12523 gas) + test cost_of_in_u8 ... ok (???, 12488 gas) + test cost_of_in_u16 ... ok (???, 12606 gas) + test cost_of_in_u32 ... ok (???, 12863 gas) + test cost_of_in_u64 ... ok (???, 12530 gas) + test cost_of_in_u256 ... ok (???, 12639 gas) + test cost_of_in_b256 ... ok (???, 12623 gas) + test cost_of_in_str_0 ... ok (???, 12606 gas) + test cost_of_in_str_1 ... ok (???, 12787 gas) + test cost_of_in_str_8 ... ok (???, 12806 gas) + test cost_of_in_str_16 ... ok (???, 12803 gas) + test cost_of_in_str_32 ... ok (???, 12817 gas) + test cost_of_in_array_0 ... FAILED (???, 12305 gas) + test cost_of_in_array_1 ... ok (???, 12870 gas) + test cost_of_in_array_8 ... ok (???, 17012 gas) + test cost_of_in_array_16 ... ok (???, 18186 gas) + test cost_of_in_array_32 ... ok (???, 23872 gas) + test cost_of_in_array_64 ... ok (???, 35287 gas) + test cost_of_in_tuple_0 ... ok (???, 12057 gas) + test cost_of_in_tuple_1 ... ok (???, 12707 gas) + test cost_of_in_tuple_2 ... ok (???, 13022 gas) + test cost_of_in_tuple_3 ... ok (???, 13286 gas) + test cost_of_in_tuple_4 ... ok (???, 13584 gas) + test in_struct_u64 ... ok (???, 12726 gas) + test in_struct_u64_u64 ... ok (???, 13009 gas) + test in_struct_u64_u64_u64 ... ok (???, 13280 gas) + test in_enum_u64 ... ok (???, 13079 gas) + test in_enum_u64_u64 ... ok (???, 13090 gas) + test in_enum_u64_u64_u64 ... ok (???, 13106 gas) failures: test cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":347 @@ -28653,12 +62,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.16 KB] in ??? + Finished release [optimized + fuel] target(s) [1.48 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_0 ... FAILED (???, 1090 gas) + test isolated_cost_of_in_array_0 ... FAILED (???, 10602 gas) failures: test isolated_cost_of_in_array_0, "test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call/src/main.sw":175 @@ -28680,12 +89,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.336 KB] in ??? + Finished release [optimized + fuel] target(s) [1.656 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_1 ... ok (???, 1342 gas) + test isolated_cost_of_in_array_1 ... ok (???, 11046 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28700,12 +109,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.368 KB] in ??? + Finished release [optimized + fuel] target(s) [1.688 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_16 ... ok (???, 3783 gas) + test isolated_cost_of_in_array_16 ... ok (???, 14865 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28720,12 +129,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.368 KB] in ??? + Finished release [optimized + fuel] target(s) [1.688 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_32 ... ok (???, 6371 gas) + test isolated_cost_of_in_array_32 ... ok (???, 18911 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28740,15 +149,12 @@ output: Building test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call Compiling library std (test/src/e2e_vm_tests/reduced_std_libs/sway-lib-std-core) Compiling contract const_of_contract_call (test/src/e2e_vm_tests/test_programs/should_pass/test_contracts/const_of_contract_call) - Finished release [optimized + fuel] target(s) [2.568 KB] in ??? + Finished release [optimized + fuel] target(s) [1.728 KB] in ??? Running 1 test, filtered 0 tests tested -- const_of_contract_call - test isolated_cost_of_in_array_64 ... ok (???, 11611 gas) -======= - test isolated_cost_of_in_array_64 ... ok (???, 9569 gas) ->>>>>>> 5f2f098c4 (update test snapshot) + test isolated_cost_of_in_array_64 ... ok (???, 27050 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28768,7 +174,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_array_8 ... ok (???, 2397 gas) + test isolated_cost_of_in_array_8 ... ok (???, 14248 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28788,7 +194,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_b256 ... ok (???, 787 gas) + test isolated_cost_of_in_b256 ... ok (???, 10910 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28808,7 +214,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_bool ... ok (???, 714 gas) + test isolated_cost_of_in_bool ... ok (???, 10791 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28828,7 +234,7 @@ output: tested -- const_of_contract_call - test in_enum_u64 ... ok (???, 1001 gas) + test in_enum_u64 ... ok (???, 11308 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28848,7 +254,7 @@ output: tested -- const_of_contract_call - test in_enum_u64_u64 ... ok (???, 1015 gas) + test in_enum_u64_u64 ... ok (???, 11344 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28868,7 +274,7 @@ output: tested -- const_of_contract_call - test in_enum_u64_u64_u64 ... ok (???, 1018 gas) + test in_enum_u64_u64_u64 ... ok (???, 11366 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28888,7 +294,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_str_0 ... ok (???, 733 gas) + test isolated_cost_of_in_str_0 ... ok (???, 10812 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28908,7 +314,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_str_1 ... ok (???, 851 gas) + test isolated_cost_of_in_str_1 ... ok (???, 11006 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28928,7 +334,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_str_16 ... ok (???, 858 gas) + test isolated_cost_of_in_str_16 ... ok (???, 11025 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28948,7 +354,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_str_32 ... ok (???, 858 gas) + test isolated_cost_of_in_str_32 ... ok (???, 11030 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28968,7 +374,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_str_8 ... ok (???, 857 gas) + test isolated_cost_of_in_str_8 ... ok (???, 11022 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -28988,7 +394,7 @@ output: tested -- const_of_contract_call - test in_struct_u64 ... ok (???, 781 gas) + test in_struct_u64 ... ok (???, 10901 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29008,7 +414,7 @@ output: tested -- const_of_contract_call - test in_struct_u64_u64 ... ok (???, 972 gas) + test in_struct_u64_u64 ... ok (???, 11252 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29028,7 +434,7 @@ output: tested -- const_of_contract_call - test in_struct_u64_u64_u64 ... ok (???, 1122 gas) + test in_struct_u64_u64_u64 ... ok (???, 11520 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29048,7 +454,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_tuple_0 ... ok (???, 454 gas) + test isolated_cost_of_in_tuple_0 ... ok (???, 10321 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29068,7 +474,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_tuple_1 ... ok (???, 758 gas) + test isolated_cost_of_in_tuple_1 ... ok (???, 10862 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29088,7 +494,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_tuple_2 ... ok (???, 972 gas) + test isolated_cost_of_in_tuple_2 ... ok (???, 11251 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29108,7 +514,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_tuple_3 ... ok (???, 1122 gas) + test isolated_cost_of_in_tuple_3 ... ok (???, 11520 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29128,7 +534,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_tuple_4 ... ok (???, 1271 gas) + test isolated_cost_of_in_tuple_4 ... ok (???, 11787 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29148,7 +554,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_u16 ... ok (???, 784 gas) + test isolated_cost_of_in_u16 ... ok (???, 10923 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29168,7 +574,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_u256 ... ok (???, 787 gas) + test isolated_cost_of_in_u256 ... ok (???, 10910 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29188,7 +594,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_u32 ... ok (???, 909 gas) + test isolated_cost_of_in_u32 ... ok (???, 11166 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29208,7 +614,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_u64 ... ok (???, 692 gas) + test isolated_cost_of_in_u64 ... ok (???, 10749 gas) test result: OK. 1 passed; 0 failed; finished in ??? @@ -29228,7 +634,7 @@ output: tested -- const_of_contract_call - test isolated_cost_of_in_u8 ... ok (???, 707 gas) + test isolated_cost_of_in_u8 ... ok (???, 10776 gas) test result: OK. 1 passed; 0 failed; finished in ??? From 9265277521689ed79fd4299a677e36041141cdac Mon Sep 17 00:00:00 2001 From: xunilrj Date: Sun, 2 Nov 2025 18:59:43 -0300 Subject: [PATCH 18/18] update tests --- forc-plugins/forc-client/tests/deploy.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/forc-plugins/forc-client/tests/deploy.rs b/forc-plugins/forc-client/tests/deploy.rs index 5d63f507ad5..04f852ec57e 100644 --- a/forc-plugins/forc-client/tests/deploy.rs +++ b/forc-plugins/forc-client/tests/deploy.rs @@ -377,7 +377,7 @@ async fn test_simple_deploy() { node.kill().unwrap(); let expected = vec![DeployedPackage::Contract(DeployedContract { id: ContractId::from_str( - "b9443b8e389d42e551b80bb7e94adb4dd37c6985088401940035e36489c90af8", + "d54d140236c92deb6b10fb5926d0362f86654111cd8e24bb9b416a84c5eba9a5", ) .unwrap(), proxy: None, @@ -421,7 +421,7 @@ async fn test_deploy_submit_only() { node.kill().unwrap(); let expected = vec![DeployedPackage::Contract(DeployedContract { id: ContractId::from_str( - "b9443b8e389d42e551b80bb7e94adb4dd37c6985088401940035e36489c90af8", + "d54d140236c92deb6b10fb5926d0362f86654111cd8e24bb9b416a84c5eba9a5", ) .unwrap(), proxy: None, @@ -468,12 +468,12 @@ async fn test_deploy_fresh_proxy() { node.kill().unwrap(); let impl_contract = DeployedPackage::Contract(DeployedContract { id: ContractId::from_str( - "b9443b8e389d42e551b80bb7e94adb4dd37c6985088401940035e36489c90af8", + "d54d140236c92deb6b10fb5926d0362f86654111cd8e24bb9b416a84c5eba9a5", ) .unwrap(), proxy: Some( ContractId::from_str( - "e597d0ef3dc3375402f32bcaa7fc66940f92c31a916e87e7eebb32fcd147d752", + "3806de177541f8e9e970640c1455bc9740a2b0248ee959a634ffe4ab6df558e2", ) .unwrap(), ),