[INFO] cloning repository https://github.com/sota-zk-labs/ORN
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/sota-zk-labs/ORN" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fsota-zk-labs%2FORN", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fsota-zk-labs%2FORN'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] ed5aaf4ad6a3ca0ff7f3c8fb81cae9e8a43bdcd4
[INFO] testing sota-zk-labs/ORN against try#0abe69e6c16114311cc2700e972492e64d69c28f for pr-154065-1
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fsota-zk-labs%2FORN" "/workspace/builds/worker-2-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-2-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/sota-zk-labs/ORN
[INFO] finished tweaking git repo https://github.com/sota-zk-labs/ORN
[INFO] tweaked toml for git repo https://github.com/sota-zk-labs/ORN written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/sota-zk-labs/ORN on toolchain 0abe69e6c16114311cc2700e972492e64d69c28f
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+0abe69e6c16114311cc2700e972492e64d69c28f" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/sota-zk-labs/ORN already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+0abe69e6c16114311cc2700e972492e64d69c28f" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+0abe69e6c16114311cc2700e972492e64d69c28f" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 97df998a76e0c0a2c77019841e469b77896bb13edb5710757e2c063f3375cbeb
[INFO] running `Command { std: "docker" "start" "-a" "97df998a76e0c0a2c77019841e469b77896bb13edb5710757e2c063f3375cbeb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "97df998a76e0c0a2c77019841e469b77896bb13edb5710757e2c063f3375cbeb", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "97df998a76e0c0a2c77019841e469b77896bb13edb5710757e2c063f3375cbeb", kill_on_drop: false }`
[INFO] [stdout] 97df998a76e0c0a2c77019841e469b77896bb13edb5710757e2c063f3375cbeb
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+0abe69e6c16114311cc2700e972492e64d69c28f" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] ae996ae9d17bb9d891e64e4a8b0c96757ce4893a3ee2947a815a677c2743e55c
[INFO] running `Command { std: "docker" "start" "-a" "ae996ae9d17bb9d891e64e4a8b0c96757ce4893a3ee2947a815a677c2743e55c", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.86
[INFO] [stderr]    Compiling pkg-config v0.3.30
[INFO] [stderr]    Compiling cc v1.1.7
[INFO] [stderr]    Compiling vcpkg v0.2.15
[INFO] [stderr]    Compiling serde v1.0.210
[INFO] [stderr]    Compiling utf8parse v0.2.2
[INFO] [stderr]    Compiling anstyle-query v1.1.1
[INFO] [stderr]    Compiling is_terminal_polyfill v1.70.1
[INFO] [stderr]    Compiling anstyle v1.0.8
[INFO] [stderr]    Compiling colorchoice v1.0.2
[INFO] [stderr]    Compiling serde_json v1.0.128
[INFO] [stderr]    Compiling curl v0.4.46
[INFO] [stderr]    Compiling indexmap v2.3.0
[INFO] [stderr]    Compiling bit-vec v0.6.3
[INFO] [stderr]    Compiling strsim v0.11.1
[INFO] [stderr]    Compiling clap_lex v0.7.2
[INFO] [stderr]    Compiling unicode-xid v0.2.4
[INFO] [stderr]    Compiling anstyle-parse v0.2.5
[INFO] [stderr]    Compiling regex-syntax v0.8.4
[INFO] [stderr]    Compiling socket2 v0.5.7
[INFO] [stderr]    Compiling openssl-probe v0.1.5
[INFO] [stderr]    Compiling orn-cli v0.1.0 (/opt/rustwide/workdir)
[INFO] [stderr]    Compiling glob v0.3.1
[INFO] [stderr]    Compiling math-parse v1.0.2
[INFO] [stderr]    Compiling anstream v0.6.15
[INFO] [stderr]    Compiling bit-set v0.5.3
[INFO] [stderr]    Compiling openssl-sys v0.9.103
[INFO] [stderr]    Compiling libz-sys v1.1.20
[INFO] [stderr]    Compiling curl-sys v0.4.75+curl-8.10.0
[INFO] [stderr]    Compiling clap_builder v4.5.13
[INFO] [stderr]    Compiling quote v1.0.36
[INFO] [stderr]    Compiling syn v2.0.72
[INFO] [stderr]    Compiling const_format_proc_macros v0.2.32
[INFO] [stderr]    Compiling regex-automata v0.4.7
[INFO] [stderr]    Compiling const_format v0.2.32
[INFO] [stderr]    Compiling serde_derive v1.0.210
[INFO] [stderr]    Compiling thiserror-impl v1.0.63
[INFO] [stderr]    Compiling tokio-macros v2.4.0
[INFO] [stderr]    Compiling clap_derive v4.5.13
[INFO] [stderr]    Compiling thiserror v1.0.63
[INFO] [stderr]    Compiling tokio v1.39.2
[INFO] [stderr]    Compiling fancy-regex v0.13.0
[INFO] [stderr]    Compiling clap v4.5.13
[INFO] [stderr]    Compiling serde_spanned v0.6.7
[INFO] [stderr]    Compiling toml_datetime v0.6.8
[INFO] [stderr]    Compiling toml_edit v0.22.20
[INFO] [stderr]    Compiling toml v0.8.19
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 32.11s
[INFO] running `Command { std: "docker" "inspect" "ae996ae9d17bb9d891e64e4a8b0c96757ce4893a3ee2947a815a677c2743e55c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "ae996ae9d17bb9d891e64e4a8b0c96757ce4893a3ee2947a815a677c2743e55c", kill_on_drop: false }`
[INFO] [stdout] ae996ae9d17bb9d891e64e4a8b0c96757ce4893a3ee2947a815a677c2743e55c
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+0abe69e6c16114311cc2700e972492e64d69c28f" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 668267825e234128ff7b86c41ee00cd30f67e5c33eb1b6a1278e458839208ac6
[INFO] running `Command { std: "docker" "start" "-a" "668267825e234128ff7b86c41ee00cd30f67e5c33eb1b6a1278e458839208ac6", kill_on_drop: false }`
[INFO] [stderr]    Compiling bytes v1.7.1
[INFO] [stderr]    Compiling smallvec v1.13.2
[INFO] [stderr]    Compiling futures-task v0.3.30
[INFO] [stderr]    Compiling byteorder v1.5.0
[INFO] [stderr]    Compiling regex-automata v0.4.7
[INFO] [stderr]    Compiling tracing v0.1.40
[INFO] [stderr]    Compiling zerocopy-derive v0.7.35
[INFO] [stderr]    Compiling percent-encoding v2.3.1
[INFO] [stderr]    Compiling curl v0.4.46
[INFO] [stderr]    Compiling colored v2.1.0
[INFO] [stderr]    Compiling assert-json-diff v2.0.2
[INFO] [stderr]    Compiling similar v2.6.0
[INFO] [stderr]    Compiling futures-util v0.3.30
[INFO] [stderr]    Compiling form_urlencoded v1.2.1
[INFO] [stderr]    Compiling parking_lot_core v0.9.10
[INFO] [stderr]    Compiling http v1.1.0
[INFO] [stderr]    Compiling parking_lot v0.12.3
[INFO] [stderr]    Compiling serde_urlencoded v0.7.1
[INFO] [stderr]    Compiling zerocopy v0.7.35
[INFO] [stderr]    Compiling tokio v1.39.2
[INFO] [stderr]    Compiling ppv-lite86 v0.2.20
[INFO] [stderr]    Compiling http-body v1.0.1
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling rand v0.8.5
[INFO] [stderr]    Compiling http-body-util v0.1.2
[INFO] [stderr]    Compiling fancy-regex v0.13.0
[INFO] [stderr]    Compiling regex v1.10.6
[INFO] [stderr]    Compiling tokio-util v0.7.12
[INFO] [stderr]    Compiling orn-cli v0.1.0 (/opt/rustwide/workdir)
[INFO] [stderr]    Compiling h2 v0.4.6
[INFO] [stderr]    Compiling hyper v1.4.1
[INFO] [stderr]    Compiling hyper-util v0.1.8
[INFO] [stderr]    Compiling mockito v1.5.0
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 26.38s
[INFO] running `Command { std: "docker" "inspect" "668267825e234128ff7b86c41ee00cd30f67e5c33eb1b6a1278e458839208ac6", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "668267825e234128ff7b86c41ee00cd30f67e5c33eb1b6a1278e458839208ac6", kill_on_drop: false }`
[INFO] [stdout] 668267825e234128ff7b86c41ee00cd30f67e5c33eb1b6a1278e458839208ac6
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+0abe69e6c16114311cc2700e972492e64d69c28f" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] a33d70748cefc0681f52f0ab22f8870b172ae839d1c0e72b0a46e30c8e3eb7fe
[INFO] running `Command { std: "docker" "start" "-a" "a33d70748cefc0681f52f0ab22f8870b172ae839d1c0e72b0a46e30c8e3eb7fe", kill_on_drop: false }`
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 0.24s
[INFO] [stderr]      Running unittests src/lib.rs (/opt/rustwide/target/debug/deps/orn_cli-bf19e325bec3c816)
[INFO] [stdout] 
[INFO] [stdout] running 10 tests
[INFO] [stdout] test update_notifier::tests::test_same_version ... ok
[INFO] [stdout] test update_notifier::tests::test_not_update_available ... ok
[INFO] [stdout] test update_notifier::tests::test_interval_not_exceeded ... ok
[INFO] [stdout] test update_notifier::tests::test_latest_version ... ok
[INFO] [stdout] test update_notifier::tests::test_no_crates_io_entry ... ok
[INFO] [stdout] test update_notifier::tests::test_interval_exceeded ... ok
[INFO] [stdout] test update_notifier::tests::test_output ... ok
[INFO] [stdout] test gen_const::test::test_gen_consts_sample3 ... ok
[INFO] [stdout] test gen_const::test::test_gen_consts_sample1 ... ok
[INFO] [stdout] test gen_const::test::test_gen_consts_sample2 ... FAILED
[INFO] [stdout] 
[INFO] [stdout] failures:
[INFO] [stdout] 
[INFO] [stdout] ---- gen_const::test::test_gen_consts_sample2 stdout ----
[INFO] [stdout] Unused: BLOCK_HASH_OFFSET
[INFO] [stdout] Unused: K_MONTGOMERY_R_INV
[INFO] [stdout] Unused: MM_INITIAL_BITWISE_ADDR
[INFO] [stdout] Unused: N_ROWS_IN_MASK
[INFO] [stdout] Unused: MAX_UINT128
[INFO] [stdout] Unused: EINVALID_PAGE_INFO_PTR_LENGTH
[INFO] [stdout] Unused: POSEIDON_BUILTIN_BIT
[INFO] [stdout] Unused: FRI_CTX_TO_FRI_HALF_INV_GROUP_OFFSET
[INFO] [stdout] Unused: MESSAGE_TO_L1_PREFIX_SIZE
[INFO] [stdout] Unused: COMMITMENT_SIZE_IN_BYTES
[INFO] [stdout] Unused: FIRST_CONTINUOUS_PAGE_INDEX
[INFO] [stdout] Unused: EPUBLIC_INPUT_LENGTH_MISMATCH
[INFO] [stdout] Unused: MAX_COSET_SIZE
[INFO] [stdout] Unused: CHECKPOINT1_VPAR
[INFO] [stdout] Unused: BATCH_INVERSE_CHUNK
[INFO] [stdout] Unused: METADATA_TASKS_OFFSET
[INFO] [stdout] Unused: EPUBLIC_INPUT_IS_TOO_SHORT
[INFO] [stdout] Unused: METADATA_OFFSET_TREE_PAIR_N_PAGES
[INFO] [stdout] Unused: EBAD_LAST_LAYER_VALUE
[INFO] [stdout] Unused: EADDRESS_OF_PAGE_0_IS_NOT_PART_OF_THE_PUBLIC_INPUT
[INFO] [stdout] Unused: K_MODULUS_TIMES_16
[INFO] [stdout] Unused: CHECKPOINT1_VP
[INFO] [stdout] Unused: KECCAK_BUILTIN_BIT
[INFO] [stdout] Unused: CHECKPOINT2_VPAR
[INFO] [stdout] Unused: DILUTED_SPACING
[INFO] [stdout] Unused: POSEIDON__ROUNDS_FULL
[INFO] [stdout] Unused: EINVALID_MESSAGE_TO_CONSUME
[INFO] [stdout] Unused: EINVALID_NEW_LENGTH
[INFO] [stdout] Unused: CHECKPOINT3_CFFL
[INFO] [stdout] Unused: ENO_STATE_TRANSITION_PROOF
[INFO] [stdout] Unused: ENUMBER_OF_STEPS_IS_TOO_LARGE
[INFO] [stdout] Unused: PAGE_INFO_SIZE
[INFO] [stdout] Unused: MESSAGE_TO_L2_FROM_ADDRESS_OFFSET
[INFO] [stdout] Unused: MM_FRI_QUERIES_DELIMITER
[INFO] [stdout] Unused: VERIFIER_ADDRESS_TAG
[INFO] [stdout] Unused: PROGRAM_SIZE
[INFO] [stdout] Unused: FRI_GROUP_SIZE
[INFO] [stdout] Unused: MESSAGE_TO_L2_TO_ADDRESS_OFFSET
[INFO] [stdout] Unused: ESTARKNET_OUTPUT_TOO_SHORT
[INFO] [stdout] Unused: EMIN_SUPPORTED_FRI_STEP_SIZE_IS_2
[INFO] [stdout] Unused: ENAMED_STORAGE_ALREADY_SET
[INFO] [stdout] Unused: EPRODUCT_INVERSE_ZERO
[INFO] [stdout] Unused: FIELD_ELEMENTS_PER_BLOB
[INFO] [stdout] Unused: ECAIRO_VERIFIER_ID_OUT_OF_RANGE
[INFO] [stdout] Unused: MM_FRI_STEP_SIZES_PTR
[INFO] [stdout] Unused: MAX_N_MERKLE_VERIFIER_QUERIES
[INFO] [stdout] Unused: EOVERFLOW_PROTECTION_FAILED
[INFO] [stdout] Unused: MM_PEDERSEN__SHIFT_POINT_X
[INFO] [stdout] Unused: METADATA_TASK_HEADER_SIZE
[INFO] [stdout] Unused: EINVALID_FRI_INVERSE_POINT
[INFO] [stdout] Unused: OFFSET_PUBLIC_MEMORY_PADDING_VALUE
[INFO] [stdout] Unused: EOUTPUT_BEGIN_ADDR_MUST_BE_LESS_THAN_OR_EQUAL_TO_STOP_PTR
[INFO] [stdout] Unused: MESSAGE_TO_L2_SELECTOR_OFFSET
[INFO] [stdout] Unused: EDENOMINATOR_MUST_NOT_BE_ZERO
[INFO] [stdout] Unused: BITWISE__ROW_RATIO
[INFO] [stdout] Unused: EWRONG_CAIRO_VERIFIER_ID
[INFO] [stdout] Unused: MAX_CYCLES_MERKLE
[INFO] [stdout] Unused: ECLAIMED_COMPOSITION_DOES_NOT_MATCH_TRACE
[INFO] [stdout] Unused: MM_DILUTED_CHECK__PERMUTATION__INTERACTION_ELM
[INFO] [stdout] Unused: CHECKPOINT2_CFFL
[INFO] [stdout] Unused: POSEIDON__ROW_RATIO
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__PEDERSEN__POINTS__X
[INFO] [stdout] Unused: ONE_VAL
[INFO] [stdout] Unused: PAGE_INFO_SIZE_IN_BYTES
[INFO] [stdout] Unused: EINVALID_KZG_PROOF_SIZE
[INFO] [stdout] Unused: EINVALID_INITIAL_PC
[INFO] [stdout] Unused: MASK_SIZE
[INFO] [stdout] Unused: EINVALID_KZG_COMMITMENT
[INFO] [stdout] Unused: N_BUILTINS
[INFO] [stdout] Unused: CHECKPOINT2_VP
[INFO] [stdout] Unused: EINVALID_NUMBER_OF_MEMORY_PAGES
[INFO] [stdout] Unused: EINVALID_FIELD_ELEMENT
[INFO] [stdout] Unused: EBATCH_INVERSE_PRODUCT_IS_ZERO
[INFO] [stdout] Unused: EPOINT_EVALUATION_PRECOMPILE_CALL_FAILED
[INFO] [stdout] Unused: CHECKPOINT2_OCC
[INFO] [stdout] Unused: GENERATOR_VAL
[INFO] [stdout] Unused: ETOO_MANY_MEMORY_VALUES
[INFO] [stdout] Unused: ESUM_OF_THE_PAGE_SIZES_DOES_NOT_MATCH_OUTPUT_SIZE
[INFO] [stdout] Unused: OFFSET_POSEIDON_STOP_PTR
[INFO] [stdout] Unused: BYTES_PER_FIELD_ELEMENT
[INFO] [stdout] Unused: ETOO_MANY_MERKLE_QUERIES
[INFO] [stdout] Unused: EINVALID_GCD
[INFO] [stdout] Unused: MM_INITIAL_POSEIDON_ADDR
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__PEDERSEN__POINTS__Y
[INFO] [stdout] Unused: PAGE_INFO_HASH_OFFSET
[INFO] [stdout] Unused: ELOG_FRI_LAST_LAYER_DEG_BOUND_MUST_BE_AT_MOST_10
[INFO] [stdout] Unused: RANGE_CHECK_BUILTIN_RATIO
[INFO] [stdout] Unused: KZG_SEGMENT_SIZE
[INFO] [stdout] Unused: MESSAGE_TO_L1_TO_ADDRESS_OFFSET
[INFO] [stdout] Unused: ELAYOUT_CODE_MISMATCH
[INFO] [stdout] Unused: BLOCK_NUMBER_OFFSET
[INFO] [stdout] Unused: ERC_MAX_OUT_OF_RANGE
[INFO] [stdout] Unused: METADATA_OFFSET_TASK_OUTPUT_SIZE
[INFO] [stdout] Unused: EUNEXPECTED_POINT_EVALUATION_PRECOMPILE_OUTPUT
[INFO] [stdout] Unused: BITWISE_BUILTIN_BIT
[INFO] [stdout] Unused: METADATA_OFFSET_TASK_PROGRAM_HASH
[INFO] [stdout] Unused: PAGE_INFO_ADDRESS_OFFSET
[INFO] [stdout] Unused: K_MONTGOMERY_R
[INFO] [stdout] Unused: ETOO_MANY_PUBLIC_MEMORY_ENTRIES_IN_ONE_PAGE
[INFO] [stdout] Unused: EPROOF_OF_WORK_BITS_MUST_BE_AT_MOST_50
[INFO] [stdout] Unused: FRI_GROUP_GEN
[INFO] [stdout] Unused: EINCONSISTENT_PROGRAM_OUTPUT_LENGTH
[INFO] [stdout] Unused: ESIZE_OF_MEMORYPAIRS_MUST_BE_EVEN
[INFO] [stdout] Unused: OFFSET_RANGE_CHECK_BEGIN_ADDR
[INFO] [stdout] Unused: EOUT_OF_NOOB
[INFO] [stdout] Unused: EINVALID_MERKLE_PROOF
[INFO] [stdout] Unused: EPROOF_PARAMS_DO_NOT_SATISFY_SECURITY
[INFO] [stdout] Unused: EINVALIDATED_MERKLE_STATEMENT
[INFO] [stdout] Unused: EFRI_QUEUE_MUST_BE_COMPOSED_OF_TRIPLETS_PLUS_ONE_DELIMITER_CELL
[INFO] [stdout] Unused: G2S_SETUP
[INFO] [stdout] Unused: EINVALID_PREVIOUS_ROOT
[INFO] [stdout] Unused: MESSAGE_TO_L2_PREFIX_SIZE
[INFO] [stdout] Unused: ENUMERATOR_NOT_DIVISIBLE_BY_DENOMINATOR
[INFO] [stdout] Unused: EINVALID_HASH_FOR_MEMORY_PAGE_0
[INFO] [stdout] Unused: MM_DILUTED_CHECK__FIRST_ELM
[INFO] [stdout] Unused: EC_OP_BUILTIN_BIT
[INFO] [stdout] Unused: PEDERSEN_BUILTIN_REPETITIONS
[INFO] [stdout] Unused: EFRI_STEP_SIZE_TOO_LARGE
[INFO] [stdout] Unused: PROOF_BYTES_LENGTH
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__POSEIDON__POSEIDON__FULL_ROUND_KEY0
[INFO] [stdout] Unused: DILUTED_N_BITS
[INFO] [stdout] Unused: ELOG_BLOWUP_FACTOR_MUST_BE_AT_LEAST_1
[INFO] [stdout] Unused: NODE_STACK_OFFSET_HASH
[INFO] [stdout] Unused: EINVALID_NUMBER_OF_PAIRS_IN_MERKLE_TREE_STRUCTURE
[INFO] [stdout] Unused: MM_INITIAL_PEDERSEN_ADDR
[INFO] [stdout] Unused: CHECKPOINT1_CFFL
[INFO] [stdout] Unused: USE_KZG_DA_OFFSET
[INFO] [stdout] Unused: EINVALID_EVAL_POINT
[INFO] [stdout] Unused: POSEIDON__RATIO
[INFO] [stdout] Unused: MM_DILUTED_CHECK__FINAL_CUM_VAL
[INFO] [stdout] Unused: TWO_COMMITMENTS_SIZE
[INFO] [stdout] Unused: RANGE_CHECK_N_PARTS
[INFO] [stdout] Unused: RANGE_CHECK_BUILTIN_BIT
[INFO] [stdout] Unused: MM_CONSTRAINT_POLY_ARGS_END
[INFO] [stdout] Unused: EINVALID_LENGTH_OF_TASK_METADATA
[INFO] [stdout] Unused: EINVALID_QUERIES_RANGE
[INFO] [stdout] Unused: MERKLE_SLOT_SIZE
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__POSEIDON__POSEIDON__PARTIAL_ROUND_KEY1
[INFO] [stdout] Unused: EFRI_PARAMS_DO_NOT_MATCH_TRACE_LENGTH
[INFO] [stdout] Unused: ETOO_MANY_COLUMNS
[INFO] [stdout] Unused: RANGE_CHECK_BUILTIN_ROW_RATIO
[INFO] [stdout] Unused: MAX_UINT192
[INFO] [stdout] Unused: ENO_MORE_THAN_4096_COEFFICIENTS_ARE_SUPPORTED
[INFO] [stdout] Unused: PROGRAM_HASH_TAG
[INFO] [stdout] Unused: EUNEXPECTED_VERSION_HASH
[INFO] [stdout] Unused: ENODE_STACK_MUST_CONTAIN_EXACTLY_ONE_ITEM
[INFO] [stdout] Unused: EINVALID_FRI_VALUE
[INFO] [stdout] Unused: OFFSET_OUTPUT_BEGIN_ADDR
[INFO] [stdout] Unused: CHECKPOINT3_VPAR
[INFO] [stdout] Unused: ESTARKNET_OUTPUT_TOO_LONG
[INFO] [stdout] Unused: ENOT_ENOUGH_FRI_STEPS
[INFO] [stdout] Unused: EINVALID_KZG_COMMITMENT_SIZE
[INFO] [stdout] Unused: EINVALID_PAYLOAD_LENGTH
[INFO] [stdout] Unused: EINVALID_PAGE_SIZE
[INFO] [stdout] Unused: MM_PEDERSEN__SHIFT_POINT_Y
[INFO] [stdout] Unused: EINVALID_PAGE_ADDRESS
[INFO] [stdout] Unused: CPU_OODS_CP2_ITERATION_LENGTH
[INFO] [stdout] Unused: ENOT_ALL_MEMORY_PAGES_WERE_PROCESSED
[INFO] [stdout] Unused: EINVALID_SIZE_FOR_MEMORY_PAGE_0
[INFO] [stdout] Unused: EINVALID_NPAGES
[INFO] [stdout] Unused: BYTES_PER_COMMITMENT
[INFO] [stdout] Unused: G2_GENERATOR
[INFO] [stdout] Unused: MM_INITIAL_RANGE_CHECK_ADDR
[INFO] [stdout] Unused: EWRONG_BYTES_LENGTH
[INFO] [stdout] Unused: INDEX_SIZE
[INFO] [stdout] Unused: EOUT_OF_RANGE_OUTPUT_STOP_PTR
[INFO] [stdout] Unused: MM_FRI_CTX
[INFO] [stdout] Unused: K_MODULUS_0
[INFO] [stdout] Unused: EINVALID_Y_VALUE
[INFO] [stdout] Unused: EPRIME_IS_TOO_BIG
[INFO] [stdout] Unused: EMAX_SUPPORTED_FRI_STEP_SIZE_IS_4
[INFO] [stdout] Unused: FRI_CTX_TO_FRI_GROUP_OFFSET
[INFO] [stdout] Unused: ENUMBER_OF_VALUES_OF_PUBLIC_MEMORY_IS_TOO_LARGE
[INFO] [stdout] Unused: OUTPUT_BUILTIN_BIT
[INFO] [stdout] Unused: HEADER_SIZE
[INFO] [stdout] Unused: MM_RANGE_CHECK16__PERM__PUBLIC_MEMORY_PROD
[INFO] [stdout] Unused: TWO_COMMITMENTS_SIZE_IN_BYTES
[INFO] [stdout] Unused: NODE_STACK_OFFSET_END
[INFO] [stdout] Unused: EINVALID_CUMULATIVE_PRODUCT
[INFO] [stdout] Unused: EINVALID_PROOF_PARAMS
[INFO] [stdout] Unused: EMESSAGE_TOO_SHORT
[INFO] [stdout] Unused: MESSAGE_TO_L1_FROM_ADDRESS_OFFSET
[INFO] [stdout] Unused: EINVALID_EXECUTION_BEGIN_ADDRESS
[INFO] [stdout] Unused: CHECKPOINT1_FB
[INFO] [stdout] Unused: OFFSET_BITWISE_BEGIN_ADDR
[INFO] [stdout] Unused: OFFSET_BITWISE_STOP_PTR
[INFO] [stdout] Unused: ESELECTED_BUILTINS_VECTOR_IS_TOO_LONG
[INFO] [stdout] Unused: EINVALID_MESSAGE_SEGMENT_SIZE
[INFO] [stdout] Unused: EUNEXPECTED_KZG_DA_FLAG
[INFO] [stdout] Unused: N_MAIN_RETURN_VALUES
[INFO] [stdout] Unused: ETRUNCATED_MESSAGE_PAYLOAD
[INFO] [stdout] Unused: MM_DILUTED_CHECK__PERMUTATION__PUBLIC_MEMORY_PROD
[INFO] [stdout] Unused: EMAX_STEP_SIZE_IS_INCONSISTENT
[INFO] [stdout] Unused: MM_DILUTED_CHECK__INTERACTION_ALPHA
[INFO] [stdout] Unused: EONLY_ETA0_IS_CURRENTLY_SUPPORTED
[INFO] [stdout] Unused: ENUMBER_OF_QUERIES_MUST_BE_AT_LEAST_ONE
[INFO] [stdout] Unused: VERSIONED_HASH_VERSION_KZG
[INFO] [stdout] Unused: CTX_LEN
[INFO] [stdout] Unused: EINVALID_VALUE_OF_N_NODES_IN_TREE_STRUCTURE
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__POSEIDON__POSEIDON__FULL_ROUND_KEY1
[INFO] [stdout] Unused: MEMORY_PAIR_SIZE
[INFO] [stdout] Unused: EINVALID_MERKLE_INDICES
[INFO] [stdout] Unused: EOUT_OF_RANGE_BEGIN_ADDR
[INFO] [stdout] Unused: MERKLE_SLOT_SIZE_IN_BYTES
[INFO] [stdout] Unused: EPROOFS_MAY_NOT_BE_PURELY_BASED_ON_POW
[INFO] [stdout] Unused: ECDSA_BUILTIN_BIT
[INFO] [stdout] Unused: ETOO_MANY_FRI_STEPS
[INFO] [stdout] Unused: FRI_QUEUE_SLOT_SIZE_IN_BYTES
[INFO] [stdout] Unused: BITWISE__RATIO
[INFO] [stdout] Unused: BYTES_PER_PROOF
[INFO] [stdout] Unused: MESSAGE_TO_L1_PAYLOAD_SIZE_OFFSET
[INFO] [stdout] Unused: PAGE_INFO_SIZE_OFFSET
[INFO] [stdout] Unused: MAX_U64
[INFO] [stdout] Unused: MESSAGE_TO_L2_PAYLOAD_SIZE_OFFSET
[INFO] [stdout] Unused: EINVALID_KZG_SEGMENT_SIZE
[INFO] [stdout] Unused: EINVALID_NUMBER_OF_TASKS
[INFO] [stdout] Unused: EINVALID_VALUE_OF_START_ADDRESS
[INFO] [stdout] Unused: ERC_MIN_MUST_BE_LESS_THAN_OR_EQUAL_TO_RC_MAX
[INFO] [stdout] Unused: OFFSET_PEDERSEN_BEGIN_ADDR
[INFO] [stdout] Unused: PEDERSEN_BUILTIN_BIT
[INFO] [stdout] Unused: EINVALID_VALUE_OF_N_PAGES_IN_TREE_STRUCTURE
[INFO] [stdout] Unused: K_MODULUS
[INFO] [stdout] Unused: POINT_EVALUATION_PRECOMPILE_OUTPUT
[INFO] [stdout] Unused: EODD_MERKLE_QUEUE_SIZE
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__POSEIDON__POSEIDON__FULL_ROUND_KEY2
[INFO] [stdout] Unused: CHECKPOINT2_FB
[INFO] [stdout] Unused: POSEIDON__M
[INFO] [stdout] Unused: EINVALID_QUERY_VALUE
[INFO] [stdout] Unused: BLS_MODULUS
[INFO] [stdout] Unused: OFFSET_N_VERIFIER_FRIENDLY_LAYERS
[INFO] [stdout] Unused: EINVALIDATED_FRI_STATEMENT
[INFO] [stdout] Unused: NODE_STACK_ITEM_SIZE
[INFO] [stdout] Unused: EINVALID_STOP_PTR
[INFO] [stdout] Unused: EMASK_MUST_BE_LESS_THAN_2_TO_THE_POWER_OF_64
[INFO] [stdout] Unused: ENUMBER_OF_POLYNOMIAL_COEFFICIENTS_MUST_BE_DIVISIBLE_BY_8
[INFO] [stdout] Unused: EINVALID_BLOCK_NUMBER
[INFO] [stdout] Unused: CONFIG_HASH_TAG
[INFO] [stdout] Unused: FRI_CTX_TO_COSET_EVALUATIONS_OFFSET
[INFO] [stdout] Unused: EMINIMUM_PROOF_OF_WORK_BITS_NOT_SATISFIED
[INFO] [stdout] Unused: CHECKPOINT3_VP
[INFO] [stdout] Unused: EPROOF_OF_WORK_CHECK_FAILED
[INFO] [stdout] Unused: STATE_STRUCT_TAG
[INFO] [stdout] Unused: MAX_U128
[INFO] [stdout] Unused: PEDERSEN_BUILTIN_ROW_RATIO
[INFO] [stdout] Unused: OFFSET_RANGE_CHECK_STOP_PTR
[INFO] [stdout] Unused: INDEX_SIZE_IN_BYTES
[INFO] [stdout] Unused: OFFSET_POSEIDON_BEGIN_ADDR
[INFO] [stdout] Unused: MERKLE_UPDATE_OFFSET
[INFO] [stdout] Unused: EINVALID_PUBLIC_MEMORY_PAGES_LENGTH
[INFO] [stdout] Unused: COMMITMENT_SIZE
[INFO] [stdout] Unused: EINVALID_VALUE_OF_ALPHA
[INFO] [stdout] Unused: ETOO_MANY_QUERIES
[INFO] [stdout] Unused: POSEIDON__ROUNDS_PARTIAL
[INFO] [stdout] Unused: EINVALID_TASK_OUTPUT_SIZE
[INFO] [stdout] Unused: EINVALID_FINAL_BLOCK_NUMBER
[INFO] [stdout] Unused: OFFSET_PEDERSEN_STOP_PTR
[INFO] [stdout] Unused: EINVALID_CAIROAUXINPUT_LENGTH
[INFO] [stdout] Unused: ELOG_BLOWUP_FACTOR_MUST_BE_AT_MOST_16
[INFO] [stdout] Unused: OFFSET_OUTPUT_STOP_PTR
[INFO] [stdout] Unused: METADATA_OFFSET_TASK_N_TREE_PAIRS
[INFO] [stdout] Unused: FRI_QUEUE_SIZE
[INFO] [stdout] Unused: EINVALID_FINAL_PC
[INFO] [stdout] Unused: MM_PERIODIC_COLUMN__POSEIDON__POSEIDON__PARTIAL_ROUND_KEY0
[INFO] [stdout] Unused: METADATA_OFFSET_TREE_PAIR_N_NODES
[INFO] [stdout] Unused: EHEIGHT_MUST_BE_LESS_THAN_200
[INFO] [stdout] Unused: N_MAIN_ARGS
[INFO] [stdout] Unused: FRI_CTX_SIZE
[INFO] [stdout] Unused: MESSAGE_TO_L2_NONCE_OFFSET
[INFO] [stdout] Unused: ENO_QUERY_TO_PROCESS
[INFO] [stdout] Unused: G1_GENERATOR
[INFO] [stdout] Unused: CHECKPOINT4_VP
[INFO] [stdout] Unused: EINVALID_VALUE_OF_Z
[INFO] [stdout] Unused: EINVALID_PRE_COMPILE_INPUT_SIZE
[INFO] [stdout] Unused: PEDERSEN_BUILTIN_RATIO
[INFO] [stdout] Unused: EINVALID_CONFIG_HASH
[INFO] [stdout] Unused: EBIT_REVERSE
[INFO] [stdout] Unused: EINVALID_Z_VALUE
[INFO] [stdout] Unused: ENOT_ALL_CAIRO_PUBLIC_INPUTS_WERE_WRITTEN
[INFO] [stdout] Unused: EMEMORY_PAGE_FACT_NOT_REGISTERED
[INFO] [stdout] Unused: EUNEXPECTED_BLOB_HASH_VERSION
[INFO] [stdout] Unused: CHECKPOINT1_OCC
[INFO] [stdout] Unused: CONFIG_HASH_OFFSET
[INFO] [stdout] Unused: MM_DILUTED_CHECK__INTERACTION_Z
[INFO] [stdout] 
[INFO] [stdout] thread 'gen_const::test::test_gen_consts_sample2' (19) panicked at src/gen_const.rs:239:9:
[INFO] [stdout] assertion `left == right` failed: failed
[INFO] [stdout]   left: "module verifier_addr::stark_verifier_7 {\n    use std::vector::{length, borrow, slice, append};\n    use aptos_std::aptos_hash::keccak256;\n    use verifier_addr::cpu_oods_7;\n    use verifier_addr::merkle_statement_verifier;\n    use verifier_addr::fri_statement_verifier_7;\n    use verifier_addr::memory_access_utils_7::{get_fri_step_sizes};\n    use lib_addr::math_mod::{mod_mul, mod_exp};\n    use verifier_addr::fact_registry::is_valid;\n\n    // This line is used for generating constants DO NOT REMOVE!\n    // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000\n    const COMMITMENT_MASK: u256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000;\n    // 2\n    const CONSTRAINTS_DEGREE_BOUND: u64 = 0x2;\n    // 1\n    const CONTINUOUS_PAGE: u256 = 0x1;\n    // INITIAL_PC + 4\n    const FINAL_PC: u64 = 0x5;\n    // 4\n    const FRI_MAX_STEP_SIZE: u256 = 0x4;\n    // 2\n    const FRI_MIN_STEP_SIZE: u256 = 0x2;\n    // 3\n    const FRI_QUEUE_SLOT_SIZE: u64 = 0x3;\n    // 1\n    const INITIAL_PC: u64 = 0x1;\n    // 42800643258479064999893963318903811951182475189843316\n    const LAYOUT_CODE: u256 = 42800643258479064999893963318903811951182475189843316;\n    // 4\n    const LOG_CPU_COMPONENT_HEIGHT: u256 = 0x4;\n    // 10\n    const MAX_FRI_STEPS: u64 = 0xa;\n    // 48\n    const MAX_N_QUERIES: u64 = 0x30;\n    // 4\n    const MAX_SUPPORTED_FRI_STEP_SIZE: u64 = 0x4;\n    // 1\n    const MM_BLOW_UP_FACTOR: u64 = 0x1;\n    // 10\n    const MM_CHANNEL: u64 = 0xa;\n    // 358\n    const MM_COMPOSITION_ALPHA: u64 = 0x166;\n    // 551\n    const MM_COMPOSITION_OODS_VALUES: u64 = 0x227;\n    // 1178\n    const MM_COMPOSITION_QUERY_RESPONSES: u64 = 0x49a;\n    // 317\n    const MM_CONSTRAINT_POLY_ARGS_START: u64 = 0x13d;\n    // 1277\n    const MM_CONTEXT_SIZE: u64 = 0x4fd;\n    // 4\n    const MM_EVAL_DOMAIN_GENERATOR: u64 = 0x4;\n    // 0\n    const MM_EVAL_DOMAIN_SIZE: u64 = 0x0;\n    // 329\n    const MM_FINAL_AP: u64 = 0x149;\n    // 330\n    const MM_FINAL_PC: u64 = 0x14a;\n    // 305\n    const MM_FRI_COMMITMENTS: u64 = 0x131;\n    // 295\n    const MM_FRI_EVAL_POINTS: u64 = 0x127;\n    // 315\n    const MM_FRI_LAST_LAYER_DEG_BOUND: u64 = 0x13b;\n    // 316\n    const MM_FRI_LAST_LAYER_PTR: u64 = 0x13c;\n    // 109\n    const MM_FRI_QUEUE: u64 = 0x6d;\n    // 326\n    const MM_HALF_OFFSET_SIZE: u64 = 0x146;\n    // 327\n    const MM_INITIAL_AP: u64 = 0x147;\n    // 328\n    const MM_INITIAL_PC: u64 = 0x148;\n    // 352\n    const MM_INTERACTION_ELEMENTS: u64 = 0x160;\n    // 2\n    const MM_LOG_EVAL_DOMAIN_SIZE: u64 = 0x2;\n    // 1274\n    const MM_LOG_N_STEPS: u64 = 0x4fa;\n    // 332\n    const MM_MEMORY__MULTI_COLUMN_PERM__HASH_INTERACTION_ELM0: u64 = 0x14c;\n    // 331\n    const MM_MEMORY__MULTI_COLUMN_PERM__PERM__INTERACTION_ELM: u64 = 0x14b;\n    // 333\n    const MM_MEMORY__MULTI_COLUMN_PERM__PERM__PUBLIC_MEMORY_PROD: u64 = 0x14d;\n    // 13\n    const MM_MERKLE_QUEUE: u64 = 0xd;\n    // 1275\n    const MM_N_PUBLIC_MEM_ENTRIES: u64 = 0x4fb;\n    // 1276\n    const MM_N_PUBLIC_MEM_PAGES: u64 = 0x4fc;\n    // 9\n    const MM_N_UNIQUE_QUERIES: u64 = 0x9;\n    // 325\n    const MM_OFFSET_SIZE: u64 = 0x145;\n    // 601\n    const MM_OODS_ALPHA: u64 = 0x259;\n    // 8\n    const MM_OODS_COMMITMENT: u64 = 0x8;\n    // 553\n    const MM_OODS_EVAL_POINTS: u64 = 0x229;\n    // 351\n    const MM_OODS_POINT: u64 = 0x15f;\n    // 359\n    const MM_OODS_VALUES: u64 = 0x167;\n    // 3\n    const MM_PROOF_OF_WORK_BITS: u64 = 0x3;\n    // 5\n    const MM_PUBLIC_INPUT_PTR: u64 = 0x5;\n    // 334\n    const MM_RANGE_CHECK16__PERM__INTERACTION_ELM: u64 = 0x14e;\n    // 337\n    const MM_RANGE_CHECK_MAX: u64 = 0x151;\n    // 336\n    const MM_RANGE_CHECK_MIN: u64 = 0x150;\n    // 6\n    const MM_TRACE_COMMITMENT: u64 = 0x6;\n    // 350\n    const MM_TRACE_GENERATOR: u64 = 0x15e;\n    // 324\n    const MM_TRACE_LENGTH: u64 = 0x144;\n    // 602\n    const MM_TRACE_QUERY_RESPONSES: u64 = 0x25a;\n    // 124\n    const N_COEFFICIENTS: u256 = 0x7c;\n    // 12\n    const N_COLUMNS_IN_MASK: u64 = 0xc;\n    // 9\n    const N_COLUMNS_IN_TRACE0: u64 = 0x9;\n    // 3\n    const N_COLUMNS_IN_TRACE1: u64 = 0x3;\n    // 6\n    const N_INTERACTION_ELEMENTS: u64 = 0x6;\n    // N_OODS_VALUES\n    const N_OODS_COEFFICIENTS: u64 = 0xc2;\n    // MASK_SIZE + CONSTRAINTS_DEGREE_BOUND\n    const N_OODS_VALUES: u64 = 0xc2;\n    // 7\n    const OFFSET_EXECUTION_BEGIN_ADDR: u64 = 0x7;\n    // 8\n    const OFFSET_EXECUTION_STOP_PTR: u64 = 0x8;\n    // 4\n    const OFFSET_LAYOUT_CODE: u64 = 0x4;\n    // 1\n    const OFFSET_LOG_N_STEPS: u64 = 0x1;\n    // 21\n    const OFFSET_N_PUBLIC_MEMORY_PAGES: u64 = 0x15;\n    // 5\n    const OFFSET_PROGRAM_BEGIN_ADDR: u64 = 0x5;\n    // 6\n    const OFFSET_PROGRAM_STOP_PTR: u64 = 0x6;\n    // 22\n    const OFFSET_PUBLIC_MEMORY: u64 = 0x16;\n    // 19\n    const OFFSET_PUBLIC_MEMORY_PADDING_ADDR: u64 = 0x13;\n    // 3\n    const OFFSET_RC_MAX: u64 = 0x3;\n    // 2\n    const OFFSET_RC_MIN: u64 = 0x2;\n    // 3\n    const PROOF_PARAMS_FRI_LAST_LAYER_LOG_DEG_BOUND_OFFSET: u64 = 0x3;\n    // 5\n    const PROOF_PARAMS_FRI_STEPS_OFFSET: u64 = 0x5;\n    // 1\n    const PROOF_PARAMS_LOG_BLOWUP_FACTOR_OFFSET: u64 = 0x1;\n    // 4\n    const PROOF_PARAMS_N_FRI_STEPS_OFFSET: u64 = 0x4;\n    // 0\n    const PROOF_PARAMS_N_QUERIES_OFFSET: u64 = 0x0;\n    // 2\n    const PROOF_PARAMS_PROOF_OF_WORK_BITS_OFFSET: u64 = 0x2;\n    // 16\n    const PUBLIC_MEMORY_STEP: u256 = 0x10;\n    // 0\n    const REGULAR_PAGE: u256 = 0x0;\n    // End of generating constants!\n\n\n    use verifier_addr::verifier_channel::{init_channel, read_hash, send_field_elements, read_field_element,\n        verify_proof_of_work, send_random_queries\n    };\n    use lib_addr::bytes::{u256_from_bytes_be, vec_to_bytes_be, num_to_bytes_be};\n    use verifier_addr::layout_specific_7::{layout_specific_init, safe_div, prepare_for_oods_check};\n    use verifier_addr::public_memory_offsets_7::{get_offset_page_size, get_public_input_length, get_offset_page_prod,\n        get_offset_page_hash, get_offset_page_addr\n    };\n    use verifier_addr::prime_field_element_0::{fpow, generator_val, k_modulus, fadd, fmul, fsub, inverse};\n    use verifier_addr::vector::{assign, set_el, append_vector};\n\n    // constants\n    const PROOF_PARAMS_N_QUERIES_OFFSET: u64 = 0;\n    const PROOF_PARAMS_LOG_BLOWUP_FACTOR_OFFSET: u64 = 1;\n    const PROOF_PARAMS_PROOF_OF_WORK_BITS_OFFSET: u64 = 2;\n    const PROOF_PARAMS_FRI_LAST_LAYER_LOG_DEG_BOUND_OFFSET: u64 = 3;\n\n    struct ConstructorConfig has key, copy {\n        /*\n          The work required to generate an invalid proof is 2^numSecurityBits.\n          Typical values: 80-128.\n        */\n        num_security_bits: u256,\n        /*\n          The secuirty of a proof is a composition of bits obtained by PoW and bits obtained by FRI\n          queries. The verifier requires at least minProofOfWorkBits to be obtained by PoW.\n          Typical values: 20-30.\n        */\n        min_proof_of_work_bits: u256\n    }\n\n    public entry fun init_stark_verifier(signer: &signer, num_security_bits: u256, min_proof_of_work_bits: u256) {\n        move_to(signer, ConstructorConfig {\n            num_security_bits,\n            min_proof_of_work_bits\n        });\n    }\n\n    /*\n      Adjusts the query indices and generates evaluation points for each query index.\n      The operations above are independent but we can save gas by combining them as both\n      operations require us to iterate the queries array.\n\n      Indices adjustment:\n          The query indices adjustment is needed because both the Merkle verification and FRI\n          expect queries \"full binary tree in array\" indices.\n          The adjustment is simply adding evalDomainSize to each query.\n          Note that evalDomainSize == 2^(#FRI layers) == 2^(Merkle tree hight).\n\n      evalPoints generation:\n          for each query index \"idx\" we compute the corresponding evaluation point:\n              g^(bitReverse(idx, log_evalDomainSize).\n    */\n    fun adjust_query_indices_and_prepare_eval_points(ctx: &mut vector<u256>) {\n        // queuePtr + i * MERKLE_SLOT_SIZE_IN_BYTES gives the i'th index in the queue.\n        let fri_queue_slot_size = FRI_QUEUE_SLOT_SIZE;\n        let n_unique_queries = (*borrow(ctx, MM_N_UNIQUE_QUERIES) as u64);\n        let fri_queue = MM_FRI_QUEUE;\n        let fri_queue_end = fri_queue + n_unique_queries * fri_queue_slot_size;\n        let eval_points_ptr = MM_OODS_EVAL_POINTS;\n        let log_eval_domain_size = (*borrow(ctx, MM_LOG_EVAL_DOMAIN_SIZE) as u8);\n        let eval_domain_size = *borrow(ctx, MM_EVAL_DOMAIN_SIZE);\n        let eval_domain_generator = *borrow(ctx, MM_EVAL_DOMAIN_GENERATOR);\n\n        while (fri_queue < fri_queue_end) {\n            let query_idx = *borrow(ctx, fri_queue);\n            // Adjust queryIdx, see comment in function description.\n            let adjusted_query_idx = query_idx + eval_domain_size;\n            set_el(ctx, fri_queue, adjusted_query_idx);\n\n            // Compute the evaluation point corresponding to the current queryIdx.\n            set_el(\n                ctx,\n                eval_points_ptr,\n                mod_exp(eval_domain_generator, bit_reverse(query_idx, log_eval_domain_size), k_modulus())\n            );\n            eval_points_ptr = eval_points_ptr + 1;\n            fri_queue = fri_queue + fri_queue_slot_size;\n        }\n    }\n\n    // Note: After the function verifier_channel::verify_proof_of_work, proof_ptr is incremented by 8 bytes.\n    // Therefore, in this function, we must add 8 to proof_ptr.\n    /*\n      Reads query responses for n_columns from the channel with the corresponding authentication\n      paths. Verifies the consistency of the authentication paths with respect to the given\n      merkleRoot, and stores the query values in proofDataPtr.\n\n      n_total_columns is the total number of columns represented in proofDataPtr (which should be\n      an array of nUniqueQueries rows of size n_total_columns). n_columns is the number of columns\n      for which data will be read by this function.\n      The change to the proofDataPtr array will be as follows:\n      * The first n_columns cells will be set,\n      * The next n_total_columns - n_columns will be skipped,\n      * The next n_columns cells will be set,\n      * The next n_total_columns - n_columns will be skipped,\n      * ...\n\n      To set the last columns for each query simply add an offset to proofDataPtr before calling the\n      function.\n    */\n    fun read_query_responses_and_decommit(\n        ctx: &mut vector<u256>,\n        proof: &vector<u256>,\n        n_total_columns: u64,\n        n_columns: u64,\n        proof_data_ptr: u64,\n        merkle_root: u256\n    ) {\n        assert!(n_columns <= get_n_columns_in_trace() + get_n_columns_in_composition(), TOO_MANY_COLUMNS);\n        let fri_queue_slot_size = FRI_QUEUE_SLOT_SIZE;\n        let n_unique_queries = (*borrow(ctx, MM_N_UNIQUE_QUERIES) as u64);\n        let channel_ptr = MM_CHANNEL;\n        let fri_queue = MM_FRI_QUEUE;\n        let fri_queue_end = fri_queue + n_unique_queries * fri_queue_slot_size;\n        let merkle_queue_ptr = MM_MERKLE_QUEUE;\n        let row_size = n_columns;\n        let proof_data_skip_bytes = (n_total_columns - n_columns);\n\n\n        let proof_ptr = (*borrow(ctx, channel_ptr) as u64);\n        let merkle_ptr = merkle_queue_ptr;\n\n        while (fri_queue < fri_queue_end) {\n            // adding 8 bytes\n            let bytes = slice(&num_to_bytes_be<u256>(borrow(proof, proof_ptr)), 8, 32);\n            let proof_ptr_offset_val = u256_from_bytes_be(\n                &append_vector(bytes, slice(&num_to_bytes_be<u256>(borrow(proof, proof_ptr + 1)), 0, 8))\n            );\n            append(&mut bytes, vec_to_bytes_be(&slice(proof, proof_ptr + 1, proof_ptr + row_size)));\n            append(&mut bytes, slice(&num_to_bytes_be<u256>(borrow(proof, proof_ptr + row_size)), 0, 8));\n            assert!(length(&bytes) == row_size * 32, WRONG_BYTES_LENGTH);\n            let merkle_leaf = u256_from_bytes_be(\n                &keccak256(bytes)\n            ) & COMMITMENT_MASK;\n            if (row_size == 1) {\n                // If a leaf contains only 1 field element we don't hash it.\n                merkle_leaf = proof_ptr_offset_val;\n            };\n\n            // push(queryIdx, hash(row)) to merkleQueue.\n            let tmp = *borrow(ctx, fri_queue);\n            set_el(ctx, merkle_ptr, tmp);\n            set_el(ctx, merkle_ptr + 1, merkle_leaf);\n            merkle_ptr = merkle_ptr + 2;\n\n            // Copy query responses to proofData array.\n            // This array will be sent to the OODS contract.\n            let proof_data_chunk_end = proof_ptr + row_size;\n            while (proof_ptr < proof_data_chunk_end) {\n                set_el(ctx, proof_data_ptr, proof_ptr_offset_val);\n                proof_data_ptr = proof_data_ptr + 1;\n                proof_ptr = proof_ptr + 1;\n            };\n            proof_data_ptr = proof_data_ptr + proof_data_skip_bytes;\n            fri_queue = fri_queue + fri_queue_slot_size;\n        };\n\n        set_el(ctx, channel_ptr, (proof_ptr as u256));\n\n        merkle_statement_verifier::verify_merkle(ctx, channel_ptr, merkle_queue_ptr, merkle_root, n_unique_queries);\n    }\n\n    /*\n      Computes the first FRI layer by reading the query responses and calling\n      the OODS contract.\n\n      The OODS contract will build and sum boundary constraints that check that\n      the prover provided the proper evaluations for the Out of Domain Sampling.\n\n      I.e. if the prover said that f(z) = c, the first FRI layer will include\n      the term (f(x) - c)/(x-z).\n    */\n    fun compute_first_fri_layer(ctx: &mut vector<u256>, proof: &vector<u256>) {\n        adjust_query_indices_and_prepare_eval_points(ctx);\n        // emit LogGas(\"Prepare evaluation points\", gasleft());\n        let tmp = *borrow(ctx, MM_TRACE_COMMITMENT);\n        read_query_responses_and_decommit(\n            ctx,\n            proof,\n            get_n_columns_in_trace(),\n            get_n_columns_in_trace_0(),\n            MM_TRACE_QUERY_RESPONSES,\n            tmp\n        );\n        // emit LogGas(\"Read and decommit trace\", gasleft());\n\n        tmp = *borrow(ctx, MM_TRACE_COMMITMENT + 1);\n        if (has_interaction()) {\n            read_query_responses_and_decommit(\n                ctx,\n                proof,\n                get_n_columns_in_trace(),\n                get_n_columns_in_trace_1(),\n                MM_TRACE_QUERY_RESPONSES + get_n_columns_in_trace_0(),\n                tmp\n            );\n            // emit LogGas(\"Read and decommit second trace\", gasleft());\n        };\n\n        tmp = *borrow(ctx, MM_OODS_COMMITMENT);\n        read_query_responses_and_decommit(\n            ctx,\n            proof,\n            get_n_columns_in_composition(),\n            get_n_columns_in_composition(),\n            MM_COMPOSITION_QUERY_RESPONSES,\n            tmp\n        );\n\n        // emit LogGas(\"Read and decommit composition\", gasleft());\n\n        cpu_oods_7::fallback(ctx);\n        // emit LogGas(\"OODS virtual oracle\", gasleft());\n    }\n\n    /*\n      Reads the last FRI layer (i.e. the polynomial's coefficients) from the channel.\n      This differs from standard reading of channel field elements in several ways:\n      -- The digest is updated by hashing it once with all coefficients simultaneously, rather than\n         iteratively one by one.\n      -- The coefficients are kept in Montgomery form, as is the case throughout the FRI\n         computation.\n      -- The coefficients are not actually read and copied elsewhere, but rather only a pointer to\n         their location in the channel is stored.\n    */\n    fun read_last_fri_layer(ctx: &mut vector<u256>, proof: &mut vector<u256>) {\n        let lmm_channel = MM_CHANNEL;\n        let fri_last_layer_deg_bound = *borrow(ctx, MM_FRI_LAST_LAYER_DEG_BOUND);\n\n        let prime_minus_one = 0x800000000000011000000000000000000000000000000000000000000000000u256;\n        let channel_ptr = lmm_channel;\n        let last_layer_ptr = (*borrow(ctx, channel_ptr) as u64);\n\n        // Make sure all the values are valid field elements.\n        let length = (fri_last_layer_deg_bound as u64);\n        let last_layer_end = last_layer_ptr + length;\n        for (coefs_ptr in last_layer_ptr..last_layer_end) {\n            assert!(*borrow(proof, coefs_ptr) <= prime_minus_one, INVALID_FIELD_ELEMENT);\n        };\n\n        // Update prng.digest with the hash of digest + 1 and the last layer coefficient.\n        // (digest + 1) is written to the proof area because keccak256 needs all data to be\n        // consecutive.\n        let new_digest_ptr = last_layer_ptr - 1;\n        let digest_ptr = channel_ptr + 1;\n        // Overwriting the proof to minimize copying of data.\n        set_el(proof, new_digest_ptr, *borrow(ctx, digest_ptr) + 1);\n\n        // prng.digest = keccak256((digest+1)||lastLayerCoefs).\n        set_el(\n            ctx,\n            digest_ptr,\n            u256_from_bytes_be(&keccak256(vec_to_bytes_be(&slice(proof, new_digest_ptr, new_digest_ptr + length + 1))))\n        );\n        // prng.counter = 0.\n        set_el(ctx, channel_ptr + 2, 0);\n\n        // Note: proof pointer is not incremented until this point.\n        set_el(ctx, channel_ptr, (last_layer_end as u256));\n\n        set_el(ctx, MM_FRI_LAST_LAYER_PTR, (last_layer_ptr as u256));\n    }\n\n    public fun verify_proof(\n        proof_params: vector<u256>,\n        proof: vector<u256>,\n        public_input: vector<u256>\n    ) acquires ConstructorConfig {\n        let ctx = init_verifier_params(&public_input, &proof_params);\n        let channel_ptr = MM_CHANNEL;\n\n        init_channel(&mut ctx, channel_ptr, get_public_input_hash(&public_input));\n        // // emit LogGas(Initializations, gasleft());\n\n        // // Read trace commitment.\n        let hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n        set_el(&mut ctx, MM_TRACE_COMMITMENT, hash);\n\n        if (has_interaction()) {\n            // Send interaction elements.\n            send_field_elements(\n                &mut ctx,\n                channel_ptr,\n                get_n_interaction_elements(),\n                get_mm_interaction_elements()\n            );\n\n            // Read second trace commitment.\n            let tmp = read_hash(&mut ctx, &proof, channel_ptr, true);\n            set_el(&mut ctx, MM_TRACE_COMMITMENT + 1, tmp);\n        };\n\n\n        // Send constraint polynomial random element.\n        send_field_elements(&mut ctx, channel_ptr, 1, MM_COMPOSITION_ALPHA);\n        // emit LogGas(\"Generate coefficients\", gasleft());\n\n        hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n        set_el(&mut ctx, MM_OODS_COMMITMENT, hash);\n\n        // Send Out of Domain Sampling point.\n        send_field_elements(&mut ctx, channel_ptr, 1, MM_OODS_POINT);\n\n        // Read the answers to the Out of Domain Sampling.\n        let lmm_oods_values = MM_OODS_VALUES;\n        for (i in lmm_oods_values..(lmm_oods_values + N_OODS_VALUES)) {\n            let tmp = read_field_element(&mut ctx, &proof, channel_ptr, true);\n            set_el(&mut ctx, i, tmp);\n        };\n        // emit LogGas(\"Read OODS commitments\", gasleft());\n        oods_consistency_check(&mut ctx, &public_input);\n        // emit LogGas(\"OODS consistency check\", gasleft());\n        send_field_elements(&mut ctx, channel_ptr, 1, MM_OODS_ALPHA);\n        // emit LogGas(\"Generate OODS coefficients\", gasleft());\n        hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n        set_el(&mut ctx, MM_FRI_COMMITMENTS, hash);\n\n        let n_fri_steps = length(&get_fri_step_sizes(&proof_params));\n        let fri_eval_point_ptr = MM_FRI_EVAL_POINTS;\n        for (i in 1..(n_fri_steps - 1)) {\n            send_field_elements(&mut ctx, channel_ptr, 1, fri_eval_point_ptr + i);\n            hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n            set_el(&mut ctx, MM_FRI_COMMITMENTS + i, hash);\n        };\n\n        // Send last random FRI evaluation point.\n        send_field_elements(\n            &mut ctx,\n            channel_ptr,\n            1,\n            MM_FRI_EVAL_POINTS + n_fri_steps - 1\n        );\n\n        // Read FRI last layer commitment.\n        read_last_fri_layer(&mut ctx, &mut proof);\n\n        // Generate queries.\n        // emit LogGas(\"Read FRI commitments\", gasleft());\n        let tmp = (*borrow(&ctx, MM_PROOF_OF_WORK_BITS) as u8);\n        verify_proof_of_work(&mut ctx, &proof, channel_ptr, tmp);\n\n        let tmp1 = *borrow(&ctx, MM_N_UNIQUE_QUERIES);\n        let tmp2 = *borrow(&ctx, MM_EVAL_DOMAIN_SIZE);\n        let tmp = send_random_queries(\n            &mut ctx,\n            channel_ptr,\n            tmp1,\n            tmp2 - 1,\n            MM_FRI_QUEUE,\n            FRI_QUEUE_SLOT_SIZE,\n        );\n        set_el(&mut ctx, MM_N_UNIQUE_QUERIES, tmp);\n        // emit LogGas(\"Send queries\", gasleft());\n\n        compute_first_fri_layer(&mut ctx, &proof);\n\n        fri_statement_verifier_7::fri_verify_layers(&mut ctx, &proof, &proof_params);\n    }\n\n    public fun init_verifier_params(\n        public_input: &vector<u256>,\n        proof_params: &vector<u256>\n    ): vector<u256> acquires ConstructorConfig {\n        let ConstructorConfig {\n            min_proof_of_work_bits,\n            num_security_bits\n        } = *borrow_global<ConstructorConfig>(@verifier_addr);\n        assert!(length(proof_params) > PROOF_PARAMS_FRI_STEPS_OFFSET, INVALID_PROOF_PARAMS);\n        assert!(\n            length(proof_params) == PROOF_PARAMS_FRI_STEPS_OFFSET + (*borrow(\n                proof_params,\n                PROOF_PARAMS_N_FRI_STEPS_OFFSET\n            ) as u64),\n            INVALID_PROOF_PARAMS\n        );\n        let log_blowup_factor = *borrow(proof_params, PROOF_PARAMS_LOG_BLOWUP_FACTOR_OFFSET);\n        // Ensure 'logBlowupFactor' is bounded as a sanity check (the bound is somewhat arbitrary).\n        assert!(log_blowup_factor <= 16, LOG_BLOWUP_FACTOR_MUST_BE_AT_MOST_16);\n        assert!(log_blowup_factor >= 1, LOG_BLOWUP_FACTOR_MUST_BE_AT_LEAST_1);\n\n        let proof_of_work_bits = *borrow(proof_params, PROOF_PARAMS_PROOF_OF_WORK_BITS_OFFSET);\n        // Ensure 'proofOfWorkBits' is bounded as a sanity check (the bound is somewhat arbitrary).\n        assert!(proof_of_work_bits <= 50, PROOF_OF_WORK_BITS_MUST_BE_AT_MOST_50);\n        assert!(proof_of_work_bits >= min_proof_of_work_bits, MINIMUM_PROOF_OF_WORK_BITS_NOT_SATISFIED);\n        assert!(proof_of_work_bits < num_security_bits, PROOFS_MAY_NOT_BE_PURELY_BASED_ON_POW);\n\n        let log_fri_last_layer_deg_bound = *borrow(proof_params, PROOF_PARAMS_FRI_LAST_LAYER_LOG_DEG_BOUND_OFFSET);\n        assert!(log_fri_last_layer_deg_bound <= 10, LOG_FRI_LAST_LAYER_DEG_BOUND_MUST_BE_AT_MOST_10);\n\n        let n_fri_steps = *borrow(proof_params, PROOF_PARAMS_N_FRI_STEPS_OFFSET);\n        assert!(n_fri_steps <= (MAX_FRI_STEPS as u256), TOO_MANY_FRI_STEPS);\n        assert!(n_fri_steps > 1, NOT_ENOUGH_FRI_STEPS);\n\n        let fri_step_sizes = get_fri_step_sizes(proof_params);\n\n        let (ctx, log_trace_length) = air_specific_init(public_input);\n\n        validate_fri_params(&fri_step_sizes, log_trace_length, log_fri_last_layer_deg_bound);\n\n        // This assignment is required for the function `getFriStepSizes` in original contract, but we don't need it here\n        // set_el(&mut ctx, MM_FRI_STEP_SIZES_PTR(), (length(&fri_step_sizes) as u256));\n\n        set_el(&mut ctx, MM_FRI_LAST_LAYER_DEG_BOUND, (1u256 << (log_fri_last_layer_deg_bound as u8)));\n        set_el(&mut ctx, MM_TRACE_LENGTH, (1u256 << (log_trace_length as u8)));\n\n        set_el(&mut ctx, MM_BLOW_UP_FACTOR, (1u256 << (log_blowup_factor as u8)));\n        set_el(&mut ctx, MM_PROOF_OF_WORK_BITS, proof_of_work_bits);\n\n        let n_queries = *borrow(proof_params, PROOF_PARAMS_N_QUERIES_OFFSET);\n        assert!(n_queries > 0, NUMBER_OF_QUERIES_MUST_BE_AT_LEAST_ONE);\n        assert!(n_queries <= (MAX_N_QUERIES as u256), TOO_MANY_QUERIES);\n        assert!(\n            n_queries * log_blowup_factor + proof_of_work_bits >= num_security_bits,\n            PROOF_PARAMS_DO_NOT_SATISFY_SECURITY\n        );\n\n        set_el(&mut ctx, MM_N_UNIQUE_QUERIES, n_queries);\n\n        // We start with logEvalDomainSize = logTraceSize and update it here.\n        set_el(&mut ctx, MM_LOG_EVAL_DOMAIN_SIZE, log_trace_length + log_blowup_factor);\n        let tmp = (1u256 << (*borrow(&ctx, MM_LOG_EVAL_DOMAIN_SIZE) as u8));\n        set_el(\n            &mut ctx,\n            MM_EVAL_DOMAIN_SIZE,\n            tmp\n        );\n\n        // Compute the generators for the evaluation and trace domains.\n        let gen_eval_domain = fpow(generator_val(), (k_modulus() - 1) / *borrow(&ctx, MM_EVAL_DOMAIN_SIZE));\n        set_el(&mut ctx, MM_EVAL_DOMAIN_GENERATOR, gen_eval_domain);\n        tmp = *borrow(&ctx,\n            MM_BLOW_UP_FACTOR\n        );\n        set_el(&mut ctx, MM_TRACE_GENERATOR, fpow(gen_eval_domain, tmp));\n\n        ctx\n    }\n\n    fun validate_fri_params(\n        fri_step_sizes: &vector<u256>,\n        log_trace_length: u256,\n        log_fri_last_layer_deg_bound: u256\n    ) {\n        assert!(*borrow(fri_step_sizes, 0) == 0, ONLY_ETA0_IS_CURRENTLY_SUPPORTED);\n        let expected_log_deg_bound = log_fri_last_layer_deg_bound;\n        let n_fri_steps = length(fri_step_sizes);\n        for (i in 1..n_fri_steps) {\n            let fri_step_size = *borrow(fri_step_sizes, i);\n            assert!(fri_step_size >= FRI_MIN_STEP_SIZE, MIN_SUPPORTED_FRI_STEP_SIZE_IS_2);\n            assert!(fri_step_size <= FRI_MAX_STEP_SIZE, MAX_SUPPORTED_FRI_STEP_SIZE_IS_4);\n            expected_log_deg_bound = expected_log_deg_bound + fri_step_size;\n        };\n\n        // FRI starts with a polynomial of degree 'traceLength'.\n        // After applying all the FRI steps we expect to get a polynomial of degree less\n        // than friLastLayerDegBound.\n        assert!(expected_log_deg_bound == log_trace_length, FRI_PARAMS_DO_NOT_MATCH_TRACE_LENGTH);\n    }\n\n    // In Starknet's contracts, this function is implemented in `CpuVerifier.sol`\n    // * The `ctx` returned is not the same as the `ctx` in the original contract.\n    fun air_specific_init(public_input: &vector<u256>): (vector<u256>, u256) {\n        assert!(length(public_input) >= OFFSET_PUBLIC_MEMORY, PUBLIC_INPUT_IS_TOO_SHORT);\n        let ctx = assign(0u256, MM_CONTEXT_SIZE);\n\n        // Context for generated code.\n        set_el(&mut ctx, MM_OFFSET_SIZE, 1 << 16);\n        set_el(&mut ctx, MM_HALF_OFFSET_SIZE, 1 << 15);\n\n        // Number of steps.\n        let log_n_steps = *borrow(public_input, OFFSET_LOG_N_STEPS);\n        assert!(log_n_steps < 50, NUMBER_OF_STEPS_IS_TOO_LARGE);\n        set_el(&mut ctx, MM_LOG_N_STEPS, log_n_steps);\n        let log_trace_length = log_n_steps + LOG_CPU_COMPONENT_HEIGHT;\n\n        // Range check limits.\n        set_el(&mut ctx, MM_RANGE_CHECK_MIN, *borrow(public_input, OFFSET_RC_MIN));\n        set_el(&mut ctx, MM_RANGE_CHECK_MAX, *borrow(public_input, OFFSET_RC_MAX));\n        assert!(\n            *borrow(&ctx, MM_RANGE_CHECK_MIN) <= *borrow(&ctx, MM_RANGE_CHECK_MAX),\n            RC_MIN_MUST_BE_LESS_THAN_OR_EQUAL_TO_RC_MAX\n        );\n        assert!(*borrow(&ctx, MM_RANGE_CHECK_MAX) < *borrow(&ctx, MM_OFFSET_SIZE), RC_MAX_OUT_OF_RANGE);\n\n        // Layout.\n        assert!(*borrow(public_input, OFFSET_LAYOUT_CODE) == LAYOUT_CODE, LAYOUT_CODE_MISMATCH);\n\n        // Initial and final pc (\"program\" memory segment).\n        set_el(&mut ctx, MM_INITIAL_PC, *borrow(public_input, OFFSET_PROGRAM_BEGIN_ADDR));\n        set_el(&mut ctx, MM_FINAL_PC, *borrow(public_input, OFFSET_PROGRAM_STOP_PTR));\n        // Invalid final pc may indicate that the program end was moved, or the program didn't\n        // complete.\n        assert!(*borrow(&ctx, MM_INITIAL_PC) == (INITIAL_PC as u256), INVALID_INITIAL_PC);\n        assert!(*borrow(&ctx, MM_FINAL_PC) == (FINAL_PC as u256), INVALID_FINAL_PC);\n\n        // Initial and final ap (\"execution\" memory segment).\n        set_el(&mut ctx, MM_INITIAL_AP, *borrow(public_input, OFFSET_EXECUTION_BEGIN_ADDR));\n        set_el(&mut ctx, MM_FINAL_AP, *borrow(public_input, OFFSET_EXECUTION_STOP_PTR));\n\n        // Public memory.\n        assert!(\n            *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES) >= 1 &&\n                *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES) < 100000, INVALID_NUMBER_OF_MEMORY_PAGES\n        );\n        set_el(&mut ctx, MM_N_PUBLIC_MEM_PAGES, *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES));\n\n        {\n            // Compute the total number of public memory entries.\n            let n_public_memory_entries = 0;\n            let n_pages = *borrow(&ctx, MM_N_PUBLIC_MEM_PAGES);\n            for (page in 0..n_pages) {\n                let n_page_entries = *borrow(public_input, (get_offset_page_size(page) as u64));\n                assert!(n_page_entries < (1 << 30), TOO_MANY_PUBLIC_MEMORY_ENTRIES_IN_ONE_PAGE);\n                n_public_memory_entries = n_public_memory_entries + n_page_entries;\n            };\n            set_el(&mut ctx, MM_N_PUBLIC_MEM_ENTRIES, n_public_memory_entries);\n        };\n\n        let expected_public_input_length = get_public_input_length(*borrow(&ctx, MM_N_PUBLIC_MEM_PAGES));\n        assert!(expected_public_input_length == (length(public_input) as u256), PUBLIC_INPUT_LENGTH_MISMATCH);\n\n        let lmm_public_input_ptr = MM_PUBLIC_INPUT_PTR;\n        // store 0 instead of the address of public_input[0] as in original contract\n        set_el(&mut ctx, lmm_public_input_ptr, 0);\n\n        layout_specific_init(&mut ctx, public_input);\n\n        (ctx, log_trace_length)\n    }\n\n    /*\n      Verifies that all the information on each public memory page (size, hash, prod, and possibly\n      address) is consistent with z and alpha, by checking that the corresponding facts were\n      registered on memoryPageFactRegistry.\n    */\n    fun verify_memory_page_facts(ctx: &mut vector<u256>, public_input: &vector<u256>) {\n        let n_public_memory_pages = *borrow(ctx, MM_N_PUBLIC_MEM_PAGES);\n\n        for (page in 0..1) {\n            let mm_public_input_ptr = *borrow(ctx, MM_PUBLIC_INPUT_PTR);\n            // Fetch page values from the public input (hash, product and size).\n            let memory_hash = *borrow(public_input, (mm_public_input_ptr + get_offset_page_hash(page) as u64));\n            let prod = *borrow(public_input,\n                (mm_public_input_ptr + get_offset_page_prod(page, n_public_memory_pages) as u64)\n            );\n            let page_size = *borrow(public_input, (mm_public_input_ptr + get_offset_page_size(page) as u64));\n\n            let page_addr = 0;\n            if (page > 0) {\n                page_addr = *borrow(public_input, (mm_public_input_ptr + get_offset_page_addr(page) as u64));\n            };\n\n            // Verify that a corresponding fact is registered attesting to the consistency of the page\n            // information with z and alpha.\n            let fact_hash = u256_from_bytes_be(&keccak256(vec_to_bytes_be<u256>(&vector[\n                if (page == 0) { REGULAR_PAGE } else { CONTINUOUS_PAGE },\n                k_modulus(),\n                page_size,\n                /*z=*/\n                *borrow(ctx, MM_INTERACTION_ELEMENTS),\n                /*alpha=*/\n                *borrow(ctx, MM_INTERACTION_ELEMENTS + 1),\n                prod,\n                memory_hash,\n                page_addr\n            ])));\n\n            assert!(is_valid(fact_hash), MEMORY_PAGE_FACT_NOT_REGISTERED);\n        }\n    }\n\n    // In Starknet's contracts, this function is implemented in `CpuVerifier.sol`\n    fun get_public_input_hash(public_input: &vector<u256>): u256 {\n        // The initial seed consists of the first part of publicInput. Specifically, it does not\n        // include the page products (which are only known later in the process, as they depend on\n        // the values of z and alpha).\n        let n_pages = *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES);\n        let public_input_size_for_hash = get_offset_page_prod(0, n_pages);\n\n        u256_from_bytes_be(&keccak256(vec_to_bytes_be(&slice(public_input, 0, (public_input_size_for_hash as u64)))))\n    }\n\n    /*\n          Computes the value of the public memory quotient:\n            numerator / (denominator * padding)\n          where:\n            numerator = (z - (0 + alpha * 0))^S,\n            denominator = \\prod_i( z - (addr_i + alpha * value_i) ),\n            padding = (z - (padding_addr + alpha * padding_value))^(S - N),\n            N is the actual number of public memory cells,\n            and S is the number of cells allocated for the public memory (which includes the padding).\n    */\n    fun compute_public_memory_quotient(ctx: &mut vector<u256>, public_input: &vector<u256>): u256 {\n        let n_values = *borrow(ctx, MM_N_PUBLIC_MEM_ENTRIES);\n        let z = *borrow(ctx, MM_MEMORY__MULTI_COLUMN_PERM__PERM__INTERACTION_ELM);\n        let alpha = *borrow(ctx, MM_MEMORY__MULTI_COLUMN_PERM__HASH_INTERACTION_ELM0);\n        // The size that is allocated to the public memory.\n        let public_memory_size = safe_div(*borrow(ctx, MM_TRACE_LENGTH), PUBLIC_MEMORY_STEP);\n\n        // Ensure 'nValues' is bounded as a sanity check\n        // (the bound is somewhat arbitrary).\n        assert!(n_values < 0x1000000, OVERFLOW_PROTECTION_FAILED);\n        assert!(n_values <= public_memory_size, NUMBER_OF_VALUES_OF_PUBLIC_MEMORY_IS_TOO_LARGE);\n\n        let n_public_memory_pages = *borrow(ctx, MM_N_PUBLIC_MEM_PAGES);\n        let cumulative_prods_ptr = *borrow(ctx, MM_PUBLIC_INPUT_PTR) + get_offset_page_prod(0, n_public_memory_pages);\n        let denominator = compute_public_memory_prod(\n            public_input,\n            cumulative_prods_ptr,\n            n_public_memory_pages,\n            k_modulus()\n        );\n\n        // Compute address + alpha * value for the first address-value pair for padding.\n        let public_input_ptr = (*borrow(ctx, MM_PUBLIC_INPUT_PTR) as u64);\n        let padding_addr_ptr = public_input_ptr + OFFSET_PUBLIC_MEMORY_PADDING_ADDR;\n        let padding_addr = *borrow(public_input, padding_addr_ptr);\n        let padding_value = *borrow(public_input, padding_addr_ptr + 1);\n        let hash_first_address_value = fadd(padding_addr, fmul(padding_value, alpha));\n\n        // Pad the denominator with the shifted value of hash_first_address_value.\n        let denom_pad = fpow(fsub(z, hash_first_address_value), public_memory_size - n_values);\n        denominator = fmul(denominator, denom_pad);\n\n        // Calculate the numerator.\n        let numerator = fpow(z, public_memory_size);\n\n        // Compute the final result: numerator * denominator^(-1).\n        fmul(numerator, inverse(denominator))\n    }\n\n    /*\n          Computes the cumulative product of the public memory cells:\n            \\prod_i( z - (addr_i + alpha * value_i) ).\n\n          publicMemoryPtr is an array of nValues pairs (address, value).\n          z and alpha are the perm and hash interaction elements assert!d to calculate the product.\n    */\n    fun compute_public_memory_prod(\n        public_input: &vector<u256>,\n        cumulative_prods_ptr: u256,\n        n_public_memory_pages: u256,\n        prime: u256\n    ): u256 {\n        let res = 1u256;\n        for (i in cumulative_prods_ptr..(cumulative_prods_ptr + n_public_memory_pages)) {\n            res = mod_mul(res, *borrow(public_input, (i as u64)), prime);\n        };\n        res\n    }\n\n    // In Starknet's contracts, this function is implemented in `CpuVerifier.sol`\n    fun oods_consistency_check(ctx: &mut vector<u256>, public_input: &vector<u256>) {\n        verify_memory_page_facts(ctx, public_input);\n        let temp = *borrow(ctx, MM_INTERACTION_ELEMENTS);\n        set_el(ctx, MM_MEMORY__MULTI_COLUMN_PERM__PERM__INTERACTION_ELM, temp);\n        let temp = *borrow(ctx, MM_INTERACTION_ELEMENTS + 1);\n        set_el(ctx, MM_MEMORY__MULTI_COLUMN_PERM__HASH_INTERACTION_ELM0, temp);\n        let temp = *borrow(ctx, MM_INTERACTION_ELEMENTS + 2);\n        set_el(ctx, MM_RANGE_CHECK16__PERM__INTERACTION_ELM, temp);\n        {\n            let public_memory_prod = compute_public_memory_quotient(ctx, public_input);\n            set_el(ctx, MM_MEMORY__MULTI_COLUMN_PERM__PERM__PUBLIC_MEMORY_PROD, public_memory_prod);\n        };\n        prepare_for_oods_check(ctx);\n\n        // Todo\n        // let composition_from_trace_value;\n        // address\n        // lconstraintPoly = address(constraintPoly);\n        // let offset = 1 + MM_CONSTRAINT_POLY_ARGS_START();\n        // let size = MM_CONSTRAINT_POLY_ARGS_END() - MM_CONSTRAINT_POLY_ARGS_START;\n        // assembly {\n        //     // Call CpuConstraintPoly contract.\n        //     let p = mload(0x40)\n        //     if iszero(staticcall(not(0), lconstraintPoly, add(ctx, offset), size, p, 0x20)) {\n        //     returndatacopy(0, 0, returndatasize())\n        //     revert(0, returndatasize())\n        //     }\n        //     compositionFromTraceValue = mload(p)\n        // }\n\n        // let claimed_composition = fadd(\n        //     *borrow(ctx, MM_COMPOSITION_OODS_VALUES()),\n        //     fmul(*borrow(ctx, MM_OODS_POINT()), *borrow(ctx, MM_COMPOSITION_OODS_VALUES + 1))\n        // );\n        //\n        // assert!(\n        //     composition_from_trace_value == claimed_composition,\n        //     CLAIMED_COMPOSITION_DOES_NOT_MATCH_TRACE\n        // );\n    }\n\n    fun get_n_columns_in_trace(): u64 {\n        N_COLUMNS_IN_MASK\n    }\n\n    fun get_n_columns_in_trace_0(): u64 {\n        N_COLUMNS_IN_TRACE0\n    }\n\n    fun get_n_columns_in_trace_1(): u64 {\n        N_COLUMNS_IN_TRACE1\n    }\n\n    fun get_n_columns_in_composition(): u64 {\n        CONSTRAINTS_DEGREE_BOUND\n    }\n\n    fun get_mm_interaction_elements(): u64 {\n        MM_INTERACTION_ELEMENTS\n    }\n\n    fun get_mm_oods_values(): u256 {\n        (MM_OODS_VALUES as u256)\n    }\n\n    fun get_n_interaction_elements(): u64 {\n        N_INTERACTION_ELEMENTS\n    }\n\n    fun get_n_coefficients(): u256 {\n        N_COEFFICIENTS\n    }\n\n    fun get_n_oods_values(): u64 {\n        N_OODS_VALUES\n    }\n\n    fun get_n_oods_coefficients(): u64 {\n        N_OODS_COEFFICIENTS\n    }\n\n    fun get_public_memory_offset(): u64 {\n        OFFSET_PUBLIC_MEMORY\n    }\n\n    fun has_interaction(): bool {\n        get_n_columns_in_trace_1() > 0\n    }\n\n    fun bit_reverse(value: u256, number_of_bits: u8): u256 {\n        // Bit reverse value by swapping 1 bit chunks then 2 bit chunks and so forth.\n        // A swap can be done by masking the relevant chunks and shifting them to the\n        // correct location.\n        // However, to save some shift operations we shift only one of the chunks by twice\n        // the chunk size, and perform a single right shift at the end.\n        let res = value;\n        // Swap 1 bit chunks.\n        res = ((res & 0x5555555555555555) << 2) | (res & 0xaaaaaaaaaaaaaaaa);\n        // Swap 2 bit chunks.\n        res = ((res & 0x6666666666666666) << 4) | (res & 0x19999999999999998);\n        // Swap 4 bit chunks.\n        res = ((res & 0x7878787878787878) << 8) | (res & 0x78787878787878780);\n        // Swap 8 bit chunks.\n        res = ((res & 0x7f807f807f807f80) << 16) | (res & 0x7f807f807f807f8000);\n        // Swap 16 bit chunks.\n        res = ((res & 0x7fff80007fff8000) << 32) | (res & 0x7fff80007fff80000000);\n        // Swap 32 bit chunks.\n        res = ((res & 0x7fffffff80000000) << 64) | (res & 0x7fffffff8000000000000000);\n        // Shift right the result.\n        // Note that we combine two right shifts here:\n        // 1. On each swap above we skip a right shift and get a left shifted result.\n        //    Consequently, we need to right shift the final result by\n        //    1 + 2 + 4 + 8 + 16 + 32 = 63.\n        // 2. The step above computes the bit-reverse of a 64-bit input. If the goal is to\n        //    bit-reverse only numberOfBits then the result needs to be right shifted by\n        //    64 - numberOfBits.\n        res = res >> (127 - number_of_bits);\n        res\n    }\n\n    // assertion code\n    const INVALID_PROOF_PARAMS: u64 = 1;\n    const LOG_BLOWUP_FACTOR_MUST_BE_AT_MOST_16: u64 = 2;\n    const LOG_BLOWUP_FACTOR_MUST_BE_AT_LEAST_1: u64 = 3;\n    const PROOF_OF_WORK_BITS_MUST_BE_AT_MOST_50: u64 = 4;\n    const MINIMUM_PROOF_OF_WORK_BITS_NOT_SATISFIED: u64 = 5;\n    const PROOFS_MAY_NOT_BE_PURELY_BASED_ON_POW: u64 = 6;\n    const LOG_FRI_LAST_LAYER_DEG_BOUND_MUST_BE_AT_MOST_10: u64 = 7;\n    const TOO_MANY_FRI_STEPS: u64 = 8;\n    const NOT_ENOUGH_FRI_STEPS: u64 = 9;\n    const NUMBER_OF_QUERIES_MUST_BE_AT_LEAST_ONE: u64 = 10;\n    const TOO_MANY_QUERIES: u64 = 11;\n    const PROOF_PARAMS_DO_NOT_SATISFY_SECURITY: u64 = 12;\n    const ONLY_ETA0_IS_CURRENTLY_SUPPORTED: u64 = 13;\n    const FRI_PARAMS_DO_NOT_MATCH_TRACE_LENGTH: u64 = 14;\n    const MIN_SUPPORTED_FRI_STEP_SIZE_IS_2: u64 = 15;\n    const MAX_SUPPORTED_FRI_STEP_SIZE_IS_4: u64 = 16;\n    const PUBLIC_INPUT_IS_TOO_SHORT: u64 = 17;\n    const NUMBER_OF_STEPS_IS_TOO_LARGE: u64 = 18;\n    const RC_MIN_MUST_BE_LESS_THAN_OR_EQUAL_TO_RC_MAX: u64 = 19;\n    const RC_MAX_OUT_OF_RANGE: u64 = 20;\n    const LAYOUT_CODE_MISMATCH: u64 = 21;\n    const INVALID_INITIAL_PC: u64 = 22;\n    const INVALID_FINAL_PC: u64 = 23;\n    const INVALID_NUMBER_OF_MEMORY_PAGES: u64 = 24;\n    const TOO_MANY_PUBLIC_MEMORY_ENTRIES_IN_ONE_PAGE: u64 = 25;\n    const PUBLIC_INPUT_LENGTH_MISMATCH: u64 = 26;\n    const MEMORY_PAGE_FACT_NOT_REGISTERED: u64 = 27;\n    const OVERFLOW_PROTECTION_FAILED: u64 = 28;\n    const NUMBER_OF_VALUES_OF_PUBLIC_MEMORY_IS_TOO_LARGE: u64 = 29;\n    const CLAIMED_COMPOSITION_DOES_NOT_MATCH_TRACE: u64 = 30;\n    const TOO_MANY_COLUMNS: u64 = 31;\n    const INVALID_FIELD_ELEMENT: u64 = 32;\n    const WRONG_BYTES_LENGTH: u64 = 33;\n}"
[INFO] [stdout]  right: "module verifier_addr::stark_verifier_7 {\n    use std::vector::{length, borrow, slice, append};\n    use aptos_std::aptos_hash::keccak256;\n    use verifier_addr::cpu_oods_7;\n    use verifier_addr::merkle_statement_verifier;\n    use verifier_addr::fri_statement_verifier_7;\n    use verifier_addr::memory_access_utils_7::{get_fri_step_sizes};\n    use lib_addr::math_mod::{mod_mul, mod_exp};\n    use verifier_addr::fact_registry::is_valid;\n\n    // This line is used for generating constants DO NOT REMOVE!\n    // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000\n    const COMMITMENT_MASK: u256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000;\n    // 2\n    const CONSTRAINTS_DEGREE_BOUND: u64 = 0x2;\n    // 1\n    const CONTINUOUS_PAGE: u256 = 0x1;\n    // INITIAL_PC + 4\n    const FINAL_PC: u64 = 0x5;\n    // 4\n    const FRI_MAX_STEP_SIZE: u256 = 0x4;\n    // 2\n    const FRI_MIN_STEP_SIZE: u256 = 0x2;\n    // 3\n    const FRI_QUEUE_SLOT_SIZE: u64 = 0x3;\n    // 1\n    const INITIAL_PC: u64 = 0x1;\n    // 42800643258479064999893963318903811951182475189843316\n    const LAYOUT_CODE: u256 = 42800643258479064999893963318903811951182475189843316;\n    // 4\n    const LOG_CPU_COMPONENT_HEIGHT: u256 = 0x4;\n    // 10\n    const MAX_FRI_STEPS: u64 = 0xa;\n    // 48\n    const MAX_N_QUERIES: u64 = 0x30;\n    // 4\n    const MAX_SUPPORTED_FRI_STEP_SIZE: u64 = 0x4;\n    // 1\n    const MM_BLOW_UP_FACTOR: u64 = 0x1;\n    // 10\n    const MM_CHANNEL: u64 = 0xa;\n    // 358\n    const MM_COMPOSITION_ALPHA: u64 = 0x166;\n    // 551\n    const MM_COMPOSITION_OODS_VALUES: u64 = 0x227;\n    // 1178\n    const MM_COMPOSITION_QUERY_RESPONSES: u64 = 0x49a;\n    // 317\n    const MM_CONSTRAINT_POLY_ARGS_START: u64 = 0x13d;\n    // 1277\n    const MM_CONTEXT_SIZE: u64 = 0x4fd;\n    // 4\n    const MM_EVAL_DOMAIN_GENERATOR: u64 = 0x4;\n    // 0\n    const MM_EVAL_DOMAIN_SIZE: u64 = 0x0;\n    // 329\n    const MM_FINAL_AP: u64 = 0x149;\n    // 330\n    const MM_FINAL_PC: u64 = 0x14a;\n    // 305\n    const MM_FRI_COMMITMENTS: u64 = 0x131;\n    // 295\n    const MM_FRI_EVAL_POINTS: u64 = 0x127;\n    // 315\n    const MM_FRI_LAST_LAYER_DEG_BOUND: u64 = 0x13b;\n    // 316\n    const MM_FRI_LAST_LAYER_PTR: u64 = 0x13c;\n    // 109\n    const MM_FRI_QUEUE: u64 = 0x6d;\n    // 326\n    const MM_HALF_OFFSET_SIZE: u64 = 0x146;\n    // 327\n    const MM_INITIAL_AP: u64 = 0x147;\n    // 328\n    const MM_INITIAL_PC: u64 = 0x148;\n    // 352\n    const MM_INTERACTION_ELEMENTS: u64 = 0x160;\n    // 2\n    const MM_LOG_EVAL_DOMAIN_SIZE: u64 = 0x2;\n    // 1274\n    const MM_LOG_N_STEPS: u64 = 0x4fa;\n    // 332\n    const MM_MEMORY__MULTI_COLUMN_PERM__HASH_INTERACTION_ELM0: u64 = 0x14c;\n    // 331\n    const MM_MEMORY__MULTI_COLUMN_PERM__PERM__INTERACTION_ELM: u64 = 0x14b;\n    // 333\n    const MM_MEMORY__MULTI_COLUMN_PERM__PERM__PUBLIC_MEMORY_PROD: u64 = 0x14d;\n    // 13\n    const MM_MERKLE_QUEUE: u64 = 0xd;\n    // 1275\n    const MM_N_PUBLIC_MEM_ENTRIES: u64 = 0x4fb;\n    // 1276\n    const MM_N_PUBLIC_MEM_PAGES: u64 = 0x4fc;\n    // 9\n    const MM_N_UNIQUE_QUERIES: u64 = 0x9;\n    // 325\n    const MM_OFFSET_SIZE: u64 = 0x145;\n    // 601\n    const MM_OODS_ALPHA: u64 = 0x259;\n    // 8\n    const MM_OODS_COMMITMENT: u64 = 0x8;\n    // 553\n    const MM_OODS_EVAL_POINTS: u64 = 0x229;\n    // 351\n    const MM_OODS_POINT: u64 = 0x15f;\n    // 359\n    const MM_OODS_VALUES: u64 = 0x167;\n    // 3\n    const MM_PROOF_OF_WORK_BITS: u64 = 0x3;\n    // 5\n    const MM_PUBLIC_INPUT_PTR: u64 = 0x5;\n    // 334\n    const MM_RANGE_CHECK16__PERM__INTERACTION_ELM: u64 = 0x14e;\n    // 337\n    const MM_RANGE_CHECK_MAX: u64 = 0x151;\n    // 336\n    const MM_RANGE_CHECK_MIN: u64 = 0x150;\n    // 6\n    const MM_TRACE_COMMITMENT: u64 = 0x6;\n    // 350\n    const MM_TRACE_GENERATOR: u64 = 0x15e;\n    // 324\n    const MM_TRACE_LENGTH: u64 = 0x144;\n    // 602\n    const MM_TRACE_QUERY_RESPONSES: u64 = 0x25a;\n    // 124\n    const N_COEFFICIENTS: u256 = 0x7c;\n    // 12\n    const N_COLUMNS_IN_MASK: u64 = 0xc;\n    // 9\n    const N_COLUMNS_IN_TRACE0: u64 = 0x9;\n    // 3\n    const N_COLUMNS_IN_TRACE1: u64 = 0x3;\n    // 6\n    const N_INTERACTION_ELEMENTS: u64 = 0x6;\n    // N_OODS_VALUES\n    const N_OODS_COEFFICIENTS: u64 = 0xc2;\n    // MASK_SIZE + CONSTRAINTS_DEGREE_BOUND\n    const N_OODS_VALUES: u64 = 0xc2;\n    // 6\n    const OFFSET_EXECUTION_BEGIN_ADDR: u64 = 0x6;\n    // 7\n    const OFFSET_EXECUTION_STOP_PTR: u64 = 0x7;\n    // 3\n    const OFFSET_LAYOUT_CODE: u64 = 0x3;\n    // 0\n    const OFFSET_LOG_N_STEPS: u64 = 0x0;\n    // 20\n    const OFFSET_N_PUBLIC_MEMORY_PAGES: u64 = 0x14;\n    // 4\n    const OFFSET_PROGRAM_BEGIN_ADDR: u64 = 0x4;\n    // 5\n    const OFFSET_PROGRAM_STOP_PTR: u64 = 0x5;\n    // 21\n    const OFFSET_PUBLIC_MEMORY: u64 = 0x15;\n    // 18\n    const OFFSET_PUBLIC_MEMORY_PADDING_ADDR: u64 = 0x12;\n    // 2\n    const OFFSET_RC_MAX: u64 = 0x2;\n    // 1\n    const OFFSET_RC_MIN: u64 = 0x1;\n    // 5\n    const PROOF_PARAMS_FRI_STEPS_OFFSET: u64 = 0x5;\n    // 4\n    const PROOF_PARAMS_N_FRI_STEPS_OFFSET: u64 = 0x4;\n    // 16\n    const PUBLIC_MEMORY_STEP: u256 = 0x10;\n    // 0\n    const REGULAR_PAGE: u256 = 0x0;\n    // End of generating constants!\n\n\n    use verifier_addr::verifier_channel::{init_channel, read_hash, send_field_elements, read_field_element,\n        verify_proof_of_work, send_random_queries\n    };\n    use lib_addr::bytes::{u256_from_bytes_be, vec_to_bytes_be, num_to_bytes_be};\n    use verifier_addr::layout_specific_7::{layout_specific_init, safe_div, prepare_for_oods_check};\n    use verifier_addr::public_memory_offsets_7::{get_offset_page_size, get_public_input_length, get_offset_page_prod,\n        get_offset_page_hash, get_offset_page_addr\n    };\n    use verifier_addr::prime_field_element_0::{fpow, generator_val, k_modulus, fadd, fmul, fsub, inverse};\n    use verifier_addr::vector::{assign, set_el, append_vector};\n\n    // constants\n    const PROOF_PARAMS_N_QUERIES_OFFSET: u64 = 0;\n    const PROOF_PARAMS_LOG_BLOWUP_FACTOR_OFFSET: u64 = 1;\n    const PROOF_PARAMS_PROOF_OF_WORK_BITS_OFFSET: u64 = 2;\n    const PROOF_PARAMS_FRI_LAST_LAYER_LOG_DEG_BOUND_OFFSET: u64 = 3;\n\n    struct ConstructorConfig has key, copy {\n        /*\n          The work required to generate an invalid proof is 2^numSecurityBits.\n          Typical values: 80-128.\n        */\n        num_security_bits: u256,\n        /*\n          The secuirty of a proof is a composition of bits obtained by PoW and bits obtained by FRI\n          queries. The verifier requires at least minProofOfWorkBits to be obtained by PoW.\n          Typical values: 20-30.\n        */\n        min_proof_of_work_bits: u256\n    }\n\n    public entry fun init_stark_verifier(signer: &signer, num_security_bits: u256, min_proof_of_work_bits: u256) {\n        move_to(signer, ConstructorConfig {\n            num_security_bits,\n            min_proof_of_work_bits\n        });\n    }\n\n    /*\n      Adjusts the query indices and generates evaluation points for each query index.\n      The operations above are independent but we can save gas by combining them as both\n      operations require us to iterate the queries array.\n\n      Indices adjustment:\n          The query indices adjustment is needed because both the Merkle verification and FRI\n          expect queries \"full binary tree in array\" indices.\n          The adjustment is simply adding evalDomainSize to each query.\n          Note that evalDomainSize == 2^(#FRI layers) == 2^(Merkle tree hight).\n\n      evalPoints generation:\n          for each query index \"idx\" we compute the corresponding evaluation point:\n              g^(bitReverse(idx, log_evalDomainSize).\n    */\n    fun adjust_query_indices_and_prepare_eval_points(ctx: &mut vector<u256>) {\n        // queuePtr + i * MERKLE_SLOT_SIZE_IN_BYTES gives the i'th index in the queue.\n        let fri_queue_slot_size = FRI_QUEUE_SLOT_SIZE;\n        let n_unique_queries = (*borrow(ctx, MM_N_UNIQUE_QUERIES) as u64);\n        let fri_queue = MM_FRI_QUEUE;\n        let fri_queue_end = fri_queue + n_unique_queries * fri_queue_slot_size;\n        let eval_points_ptr = MM_OODS_EVAL_POINTS;\n        let log_eval_domain_size = (*borrow(ctx, MM_LOG_EVAL_DOMAIN_SIZE) as u8);\n        let eval_domain_size = *borrow(ctx, MM_EVAL_DOMAIN_SIZE);\n        let eval_domain_generator = *borrow(ctx, MM_EVAL_DOMAIN_GENERATOR);\n\n        while (fri_queue < fri_queue_end) {\n            let query_idx = *borrow(ctx, fri_queue);\n            // Adjust queryIdx, see comment in function description.\n            let adjusted_query_idx = query_idx + eval_domain_size;\n            set_el(ctx, fri_queue, adjusted_query_idx);\n\n            // Compute the evaluation point corresponding to the current queryIdx.\n            set_el(\n                ctx,\n                eval_points_ptr,\n                mod_exp(eval_domain_generator, bit_reverse(query_idx, log_eval_domain_size), k_modulus())\n            );\n            eval_points_ptr = eval_points_ptr + 1;\n            fri_queue = fri_queue + fri_queue_slot_size;\n        }\n    }\n\n    // Note: After the function verifier_channel::verify_proof_of_work, proof_ptr is incremented by 8 bytes.\n    // Therefore, in this function, we must add 8 to proof_ptr.\n    /*\n      Reads query responses for n_columns from the channel with the corresponding authentication\n      paths. Verifies the consistency of the authentication paths with respect to the given\n      merkleRoot, and stores the query values in proofDataPtr.\n\n      n_total_columns is the total number of columns represented in proofDataPtr (which should be\n      an array of nUniqueQueries rows of size n_total_columns). n_columns is the number of columns\n      for which data will be read by this function.\n      The change to the proofDataPtr array will be as follows:\n      * The first n_columns cells will be set,\n      * The next n_total_columns - n_columns will be skipped,\n      * The next n_columns cells will be set,\n      * The next n_total_columns - n_columns will be skipped,\n      * ...\n\n      To set the last columns for each query simply add an offset to proofDataPtr before calling the\n      function.\n    */\n    fun read_query_responses_and_decommit(\n        ctx: &mut vector<u256>,\n        proof: &vector<u256>,\n        n_total_columns: u64,\n        n_columns: u64,\n        proof_data_ptr: u64,\n        merkle_root: u256\n    ) {\n        assert!(n_columns <= get_n_columns_in_trace() + get_n_columns_in_composition(), TOO_MANY_COLUMNS);\n        let fri_queue_slot_size = FRI_QUEUE_SLOT_SIZE;\n        let n_unique_queries = (*borrow(ctx, MM_N_UNIQUE_QUERIES) as u64);\n        let channel_ptr = MM_CHANNEL;\n        let fri_queue = MM_FRI_QUEUE;\n        let fri_queue_end = fri_queue + n_unique_queries * fri_queue_slot_size;\n        let merkle_queue_ptr = MM_MERKLE_QUEUE;\n        let row_size = n_columns;\n        let proof_data_skip_bytes = (n_total_columns - n_columns);\n\n\n        let proof_ptr = (*borrow(ctx, channel_ptr) as u64);\n        let merkle_ptr = merkle_queue_ptr;\n\n        while (fri_queue < fri_queue_end) {\n            // adding 8 bytes\n            let bytes = slice(&num_to_bytes_be<u256>(borrow(proof, proof_ptr)), 8, 32);\n            let proof_ptr_offset_val = u256_from_bytes_be(\n                &append_vector(bytes, slice(&num_to_bytes_be<u256>(borrow(proof, proof_ptr + 1)), 0, 8))\n            );\n            append(&mut bytes, vec_to_bytes_be(&slice(proof, proof_ptr + 1, proof_ptr + row_size)));\n            append(&mut bytes, slice(&num_to_bytes_be<u256>(borrow(proof, proof_ptr + row_size)), 0, 8));\n            assert!(length(&bytes) == row_size * 32, WRONG_BYTES_LENGTH);\n            let merkle_leaf = u256_from_bytes_be(\n                &keccak256(bytes)\n            ) & COMMITMENT_MASK;\n            if (row_size == 1) {\n                // If a leaf contains only 1 field element we don't hash it.\n                merkle_leaf = proof_ptr_offset_val;\n            };\n\n            // push(queryIdx, hash(row)) to merkleQueue.\n            let tmp = *borrow(ctx, fri_queue);\n            set_el(ctx, merkle_ptr, tmp);\n            set_el(ctx, merkle_ptr + 1, merkle_leaf);\n            merkle_ptr = merkle_ptr + 2;\n\n            // Copy query responses to proofData array.\n            // This array will be sent to the OODS contract.\n            let proof_data_chunk_end = proof_ptr + row_size;\n            while (proof_ptr < proof_data_chunk_end) {\n                set_el(ctx, proof_data_ptr, proof_ptr_offset_val);\n                proof_data_ptr = proof_data_ptr + 1;\n                proof_ptr = proof_ptr + 1;\n            };\n            proof_data_ptr = proof_data_ptr + proof_data_skip_bytes;\n            fri_queue = fri_queue + fri_queue_slot_size;\n        };\n\n        set_el(ctx, channel_ptr, (proof_ptr as u256));\n\n        merkle_statement_verifier::verify_merkle(ctx, channel_ptr, merkle_queue_ptr, merkle_root, n_unique_queries);\n    }\n\n    /*\n      Computes the first FRI layer by reading the query responses and calling\n      the OODS contract.\n\n      The OODS contract will build and sum boundary constraints that check that\n      the prover provided the proper evaluations for the Out of Domain Sampling.\n\n      I.e. if the prover said that f(z) = c, the first FRI layer will include\n      the term (f(x) - c)/(x-z).\n    */\n    fun compute_first_fri_layer(ctx: &mut vector<u256>, proof: &vector<u256>) {\n        adjust_query_indices_and_prepare_eval_points(ctx);\n        // emit LogGas(\"Prepare evaluation points\", gasleft());\n        let tmp = *borrow(ctx, MM_TRACE_COMMITMENT);\n        read_query_responses_and_decommit(\n            ctx,\n            proof,\n            get_n_columns_in_trace(),\n            get_n_columns_in_trace_0(),\n            MM_TRACE_QUERY_RESPONSES,\n            tmp\n        );\n        // emit LogGas(\"Read and decommit trace\", gasleft());\n\n        tmp = *borrow(ctx, MM_TRACE_COMMITMENT + 1);\n        if (has_interaction()) {\n            read_query_responses_and_decommit(\n                ctx,\n                proof,\n                get_n_columns_in_trace(),\n                get_n_columns_in_trace_1(),\n                MM_TRACE_QUERY_RESPONSES + get_n_columns_in_trace_0(),\n                tmp\n            );\n            // emit LogGas(\"Read and decommit second trace\", gasleft());\n        };\n\n        tmp = *borrow(ctx, MM_OODS_COMMITMENT);\n        read_query_responses_and_decommit(\n            ctx,\n            proof,\n            get_n_columns_in_composition(),\n            get_n_columns_in_composition(),\n            MM_COMPOSITION_QUERY_RESPONSES,\n            tmp\n        );\n\n        // emit LogGas(\"Read and decommit composition\", gasleft());\n\n        cpu_oods_7::fallback(ctx);\n        // emit LogGas(\"OODS virtual oracle\", gasleft());\n    }\n\n    /*\n      Reads the last FRI layer (i.e. the polynomial's coefficients) from the channel.\n      This differs from standard reading of channel field elements in several ways:\n      -- The digest is updated by hashing it once with all coefficients simultaneously, rather than\n         iteratively one by one.\n      -- The coefficients are kept in Montgomery form, as is the case throughout the FRI\n         computation.\n      -- The coefficients are not actually read and copied elsewhere, but rather only a pointer to\n         their location in the channel is stored.\n    */\n    fun read_last_fri_layer(ctx: &mut vector<u256>, proof: &mut vector<u256>) {\n        let lmm_channel = MM_CHANNEL;\n        let fri_last_layer_deg_bound = *borrow(ctx, MM_FRI_LAST_LAYER_DEG_BOUND);\n\n        let prime_minus_one = 0x800000000000011000000000000000000000000000000000000000000000000u256;\n        let channel_ptr = lmm_channel;\n        let last_layer_ptr = (*borrow(ctx, channel_ptr) as u64);\n\n        // Make sure all the values are valid field elements.\n        let length = (fri_last_layer_deg_bound as u64);\n        let last_layer_end = last_layer_ptr + length;\n        for (coefs_ptr in last_layer_ptr..last_layer_end) {\n            assert!(*borrow(proof, coefs_ptr) <= prime_minus_one, INVALID_FIELD_ELEMENT);\n        };\n\n        // Update prng.digest with the hash of digest + 1 and the last layer coefficient.\n        // (digest + 1) is written to the proof area because keccak256 needs all data to be\n        // consecutive.\n        let new_digest_ptr = last_layer_ptr - 1;\n        let digest_ptr = channel_ptr + 1;\n        // Overwriting the proof to minimize copying of data.\n        set_el(proof, new_digest_ptr, *borrow(ctx, digest_ptr) + 1);\n\n        // prng.digest = keccak256((digest+1)||lastLayerCoefs).\n        set_el(\n            ctx,\n            digest_ptr,\n            u256_from_bytes_be(&keccak256(vec_to_bytes_be(&slice(proof, new_digest_ptr, new_digest_ptr + length + 1))))\n        );\n        // prng.counter = 0.\n        set_el(ctx, channel_ptr + 2, 0);\n\n        // Note: proof pointer is not incremented until this point.\n        set_el(ctx, channel_ptr, (last_layer_end as u256));\n\n        set_el(ctx, MM_FRI_LAST_LAYER_PTR, (last_layer_ptr as u256));\n    }\n\n    public fun verify_proof(\n        proof_params: vector<u256>,\n        proof: vector<u256>,\n        public_input: vector<u256>\n    ) acquires ConstructorConfig {\n        let ctx = init_verifier_params(&public_input, &proof_params);\n        let channel_ptr = MM_CHANNEL;\n\n        init_channel(&mut ctx, channel_ptr, get_public_input_hash(&public_input));\n        // // emit LogGas(Initializations, gasleft());\n\n        // // Read trace commitment.\n        let hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n        set_el(&mut ctx, MM_TRACE_COMMITMENT, hash);\n\n        if (has_interaction()) {\n            // Send interaction elements.\n            send_field_elements(\n                &mut ctx,\n                channel_ptr,\n                get_n_interaction_elements(),\n                get_mm_interaction_elements()\n            );\n\n            // Read second trace commitment.\n            let tmp = read_hash(&mut ctx, &proof, channel_ptr, true);\n            set_el(&mut ctx, MM_TRACE_COMMITMENT + 1, tmp);\n        };\n\n\n        // Send constraint polynomial random element.\n        send_field_elements(&mut ctx, channel_ptr, 1, MM_COMPOSITION_ALPHA);\n        // emit LogGas(\"Generate coefficients\", gasleft());\n\n        hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n        set_el(&mut ctx, MM_OODS_COMMITMENT, hash);\n\n        // Send Out of Domain Sampling point.\n        send_field_elements(&mut ctx, channel_ptr, 1, MM_OODS_POINT);\n\n        // Read the answers to the Out of Domain Sampling.\n        let lmm_oods_values = MM_OODS_VALUES;\n        for (i in lmm_oods_values..(lmm_oods_values + N_OODS_VALUES)) {\n            let tmp = read_field_element(&mut ctx, &proof, channel_ptr, true);\n            set_el(&mut ctx, i, tmp);\n        };\n        // emit LogGas(\"Read OODS commitments\", gasleft());\n        oods_consistency_check(&mut ctx, &public_input);\n        // emit LogGas(\"OODS consistency check\", gasleft());\n        send_field_elements(&mut ctx, channel_ptr, 1, MM_OODS_ALPHA);\n        // emit LogGas(\"Generate OODS coefficients\", gasleft());\n        hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n        set_el(&mut ctx, MM_FRI_COMMITMENTS, hash);\n\n        let n_fri_steps = length(&get_fri_step_sizes(&proof_params));\n        let fri_eval_point_ptr = MM_FRI_EVAL_POINTS;\n        for (i in 1..(n_fri_steps - 1)) {\n            send_field_elements(&mut ctx, channel_ptr, 1, fri_eval_point_ptr + i);\n            hash = read_hash(&mut ctx, &proof, channel_ptr, true);\n            set_el(&mut ctx, MM_FRI_COMMITMENTS + i, hash);\n        };\n\n        // Send last random FRI evaluation point.\n        send_field_elements(\n            &mut ctx,\n            channel_ptr,\n            1,\n            MM_FRI_EVAL_POINTS + n_fri_steps - 1\n        );\n\n        // Read FRI last layer commitment.\n        read_last_fri_layer(&mut ctx, &mut proof);\n\n        // Generate queries.\n        // emit LogGas(\"Read FRI commitments\", gasleft());\n        let tmp = (*borrow(&ctx, MM_PROOF_OF_WORK_BITS) as u8);\n        verify_proof_of_work(&mut ctx, &proof, channel_ptr, tmp);\n\n        let tmp1 = *borrow(&ctx, MM_N_UNIQUE_QUERIES);\n        let tmp2 = *borrow(&ctx, MM_EVAL_DOMAIN_SIZE);\n        let tmp = send_random_queries(\n            &mut ctx,\n            channel_ptr,\n            tmp1,\n            tmp2 - 1,\n            MM_FRI_QUEUE,\n            FRI_QUEUE_SLOT_SIZE,\n        );\n        set_el(&mut ctx, MM_N_UNIQUE_QUERIES, tmp);\n        // emit LogGas(\"Send queries\", gasleft());\n\n        compute_first_fri_layer(&mut ctx, &proof);\n\n        fri_statement_verifier_7::fri_verify_layers(&mut ctx, &proof, &proof_params);\n    }\n\n    public fun init_verifier_params(\n        public_input: &vector<u256>,\n        proof_params: &vector<u256>\n    ): vector<u256> acquires ConstructorConfig {\n        let ConstructorConfig {\n            min_proof_of_work_bits,\n            num_security_bits\n        } = *borrow_global<ConstructorConfig>(@verifier_addr);\n        assert!(length(proof_params) > PROOF_PARAMS_FRI_STEPS_OFFSET, INVALID_PROOF_PARAMS);\n        assert!(\n            length(proof_params) == PROOF_PARAMS_FRI_STEPS_OFFSET + (*borrow(\n                proof_params,\n                PROOF_PARAMS_N_FRI_STEPS_OFFSET\n            ) as u64),\n            INVALID_PROOF_PARAMS\n        );\n        let log_blowup_factor = *borrow(proof_params, PROOF_PARAMS_LOG_BLOWUP_FACTOR_OFFSET);\n        // Ensure 'logBlowupFactor' is bounded as a sanity check (the bound is somewhat arbitrary).\n        assert!(log_blowup_factor <= 16, LOG_BLOWUP_FACTOR_MUST_BE_AT_MOST_16);\n        assert!(log_blowup_factor >= 1, LOG_BLOWUP_FACTOR_MUST_BE_AT_LEAST_1);\n\n        let proof_of_work_bits = *borrow(proof_params, PROOF_PARAMS_PROOF_OF_WORK_BITS_OFFSET);\n        // Ensure 'proofOfWorkBits' is bounded as a sanity check (the bound is somewhat arbitrary).\n        assert!(proof_of_work_bits <= 50, PROOF_OF_WORK_BITS_MUST_BE_AT_MOST_50);\n        assert!(proof_of_work_bits >= min_proof_of_work_bits, MINIMUM_PROOF_OF_WORK_BITS_NOT_SATISFIED);\n        assert!(proof_of_work_bits < num_security_bits, PROOFS_MAY_NOT_BE_PURELY_BASED_ON_POW);\n\n        let log_fri_last_layer_deg_bound = *borrow(proof_params, PROOF_PARAMS_FRI_LAST_LAYER_LOG_DEG_BOUND_OFFSET);\n        assert!(log_fri_last_layer_deg_bound <= 10, LOG_FRI_LAST_LAYER_DEG_BOUND_MUST_BE_AT_MOST_10);\n\n        let n_fri_steps = *borrow(proof_params, PROOF_PARAMS_N_FRI_STEPS_OFFSET);\n        assert!(n_fri_steps <= (MAX_FRI_STEPS as u256), TOO_MANY_FRI_STEPS);\n        assert!(n_fri_steps > 1, NOT_ENOUGH_FRI_STEPS);\n\n        let fri_step_sizes = get_fri_step_sizes(proof_params);\n\n        let (ctx, log_trace_length) = air_specific_init(public_input);\n\n        validate_fri_params(&fri_step_sizes, log_trace_length, log_fri_last_layer_deg_bound);\n\n        // This assignment is required for the function `getFriStepSizes` in original contract, but we don't need it here\n        // set_el(&mut ctx, MM_FRI_STEP_SIZES_PTR(), (length(&fri_step_sizes) as u256));\n\n        set_el(&mut ctx, MM_FRI_LAST_LAYER_DEG_BOUND, (1u256 << (log_fri_last_layer_deg_bound as u8)));\n        set_el(&mut ctx, MM_TRACE_LENGTH, (1u256 << (log_trace_length as u8)));\n\n        set_el(&mut ctx, MM_BLOW_UP_FACTOR, (1u256 << (log_blowup_factor as u8)));\n        set_el(&mut ctx, MM_PROOF_OF_WORK_BITS, proof_of_work_bits);\n\n        let n_queries = *borrow(proof_params, PROOF_PARAMS_N_QUERIES_OFFSET);\n        assert!(n_queries > 0, NUMBER_OF_QUERIES_MUST_BE_AT_LEAST_ONE);\n        assert!(n_queries <= (MAX_N_QUERIES as u256), TOO_MANY_QUERIES);\n        assert!(\n            n_queries * log_blowup_factor + proof_of_work_bits >= num_security_bits,\n            PROOF_PARAMS_DO_NOT_SATISFY_SECURITY\n        );\n\n        set_el(&mut ctx, MM_N_UNIQUE_QUERIES, n_queries);\n\n        // We start with logEvalDomainSize = logTraceSize and update it here.\n        set_el(&mut ctx, MM_LOG_EVAL_DOMAIN_SIZE, log_trace_length + log_blowup_factor);\n        let tmp = (1u256 << (*borrow(&ctx, MM_LOG_EVAL_DOMAIN_SIZE) as u8));\n        set_el(\n            &mut ctx,\n            MM_EVAL_DOMAIN_SIZE,\n            tmp\n        );\n\n        // Compute the generators for the evaluation and trace domains.\n        let gen_eval_domain = fpow(generator_val(), (k_modulus() - 1) / *borrow(&ctx, MM_EVAL_DOMAIN_SIZE));\n        set_el(&mut ctx, MM_EVAL_DOMAIN_GENERATOR, gen_eval_domain);\n        tmp = *borrow(&ctx,\n            MM_BLOW_UP_FACTOR\n        );\n        set_el(&mut ctx, MM_TRACE_GENERATOR, fpow(gen_eval_domain, tmp));\n\n        ctx\n    }\n\n    fun validate_fri_params(\n        fri_step_sizes: &vector<u256>,\n        log_trace_length: u256,\n        log_fri_last_layer_deg_bound: u256\n    ) {\n        assert!(*borrow(fri_step_sizes, 0) == 0, ONLY_ETA0_IS_CURRENTLY_SUPPORTED);\n        let expected_log_deg_bound = log_fri_last_layer_deg_bound;\n        let n_fri_steps = length(fri_step_sizes);\n        for (i in 1..n_fri_steps) {\n            let fri_step_size = *borrow(fri_step_sizes, i);\n            assert!(fri_step_size >= FRI_MIN_STEP_SIZE, MIN_SUPPORTED_FRI_STEP_SIZE_IS_2);\n            assert!(fri_step_size <= FRI_MAX_STEP_SIZE, MAX_SUPPORTED_FRI_STEP_SIZE_IS_4);\n            expected_log_deg_bound = expected_log_deg_bound + fri_step_size;\n        };\n\n        // FRI starts with a polynomial of degree 'traceLength'.\n        // After applying all the FRI steps we expect to get a polynomial of degree less\n        // than friLastLayerDegBound.\n        assert!(expected_log_deg_bound == log_trace_length, FRI_PARAMS_DO_NOT_MATCH_TRACE_LENGTH);\n    }\n\n    // In Starknet's contracts, this function is implemented in `CpuVerifier.sol`\n    // * The `ctx` returned is not the same as the `ctx` in the original contract.\n    fun air_specific_init(public_input: &vector<u256>): (vector<u256>, u256) {\n        assert!(length(public_input) >= OFFSET_PUBLIC_MEMORY, PUBLIC_INPUT_IS_TOO_SHORT);\n        let ctx = assign(0u256, MM_CONTEXT_SIZE);\n\n        // Context for generated code.\n        set_el(&mut ctx, MM_OFFSET_SIZE, 1 << 16);\n        set_el(&mut ctx, MM_HALF_OFFSET_SIZE, 1 << 15);\n\n        // Number of steps.\n        let log_n_steps = *borrow(public_input, OFFSET_LOG_N_STEPS);\n        assert!(log_n_steps < 50, NUMBER_OF_STEPS_IS_TOO_LARGE);\n        set_el(&mut ctx, MM_LOG_N_STEPS, log_n_steps);\n        let log_trace_length = log_n_steps + LOG_CPU_COMPONENT_HEIGHT;\n\n        // Range check limits.\n        set_el(&mut ctx, MM_RANGE_CHECK_MIN, *borrow(public_input, OFFSET_RC_MIN));\n        set_el(&mut ctx, MM_RANGE_CHECK_MAX, *borrow(public_input, OFFSET_RC_MAX));\n        assert!(\n            *borrow(&ctx, MM_RANGE_CHECK_MIN) <= *borrow(&ctx, MM_RANGE_CHECK_MAX),\n            RC_MIN_MUST_BE_LESS_THAN_OR_EQUAL_TO_RC_MAX\n        );\n        assert!(*borrow(&ctx, MM_RANGE_CHECK_MAX) < *borrow(&ctx, MM_OFFSET_SIZE), RC_MAX_OUT_OF_RANGE);\n\n        // Layout.\n        assert!(*borrow(public_input, OFFSET_LAYOUT_CODE) == LAYOUT_CODE, LAYOUT_CODE_MISMATCH);\n\n        // Initial and final pc (\"program\" memory segment).\n        set_el(&mut ctx, MM_INITIAL_PC, *borrow(public_input, OFFSET_PROGRAM_BEGIN_ADDR));\n        set_el(&mut ctx, MM_FINAL_PC, *borrow(public_input, OFFSET_PROGRAM_STOP_PTR));\n        // Invalid final pc may indicate that the program end was moved, or the program didn't\n        // complete.\n        assert!(*borrow(&ctx, MM_INITIAL_PC) == (INITIAL_PC as u256), INVALID_INITIAL_PC);\n        assert!(*borrow(&ctx, MM_FINAL_PC) == (FINAL_PC as u256), INVALID_FINAL_PC);\n\n        // Initial and final ap (\"execution\" memory segment).\n        set_el(&mut ctx, MM_INITIAL_AP, *borrow(public_input, OFFSET_EXECUTION_BEGIN_ADDR));\n        set_el(&mut ctx, MM_FINAL_AP, *borrow(public_input, OFFSET_EXECUTION_STOP_PTR));\n\n        // Public memory.\n        assert!(\n            *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES) >= 1 &&\n                *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES) < 100000, INVALID_NUMBER_OF_MEMORY_PAGES\n        );\n        set_el(&mut ctx, MM_N_PUBLIC_MEM_PAGES, *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES));\n\n        {\n            // Compute the total number of public memory entries.\n            let n_public_memory_entries = 0;\n            let n_pages = *borrow(&ctx, MM_N_PUBLIC_MEM_PAGES);\n            for (page in 0..n_pages) {\n                let n_page_entries = *borrow(public_input, (get_offset_page_size(page) as u64));\n                assert!(n_page_entries < (1 << 30), TOO_MANY_PUBLIC_MEMORY_ENTRIES_IN_ONE_PAGE);\n                n_public_memory_entries = n_public_memory_entries + n_page_entries;\n            };\n            set_el(&mut ctx, MM_N_PUBLIC_MEM_ENTRIES, n_public_memory_entries);\n        };\n\n        let expected_public_input_length = get_public_input_length(*borrow(&ctx, MM_N_PUBLIC_MEM_PAGES));\n        assert!(expected_public_input_length == (length(public_input) as u256), PUBLIC_INPUT_LENGTH_MISMATCH);\n\n        let lmm_public_input_ptr = MM_PUBLIC_INPUT_PTR;\n        // store 0 instead of the address of public_input[0] as in original contract\n        set_el(&mut ctx, lmm_public_input_ptr, 0);\n\n        layout_specific_init(&mut ctx, public_input);\n\n        (ctx, log_trace_length)\n    }\n\n    /*\n      Verifies that all the information on each public memory page (size, hash, prod, and possibly\n      address) is consistent with z and alpha, by checking that the corresponding facts were\n      registered on memoryPageFactRegistry.\n    */\n    fun verify_memory_page_facts(ctx: &mut vector<u256>, public_input: &vector<u256>) {\n        let n_public_memory_pages = *borrow(ctx, MM_N_PUBLIC_MEM_PAGES);\n\n        for (page in 0..1) {\n            let mm_public_input_ptr = *borrow(ctx, MM_PUBLIC_INPUT_PTR);\n            // Fetch page values from the public input (hash, product and size).\n            let memory_hash = *borrow(public_input, (mm_public_input_ptr + get_offset_page_hash(page) as u64));\n            let prod = *borrow(public_input,\n                (mm_public_input_ptr + get_offset_page_prod(page, n_public_memory_pages) as u64)\n            );\n            let page_size = *borrow(public_input, (mm_public_input_ptr + get_offset_page_size(page) as u64));\n\n            let page_addr = 0;\n            if (page > 0) {\n                page_addr = *borrow(public_input, (mm_public_input_ptr + get_offset_page_addr(page) as u64));\n            };\n\n            // Verify that a corresponding fact is registered attesting to the consistency of the page\n            // information with z and alpha.\n            let fact_hash = u256_from_bytes_be(&keccak256(vec_to_bytes_be<u256>(&vector[\n                if (page == 0) { REGULAR_PAGE } else { CONTINUOUS_PAGE },\n                k_modulus(),\n                page_size,\n                /*z=*/\n                *borrow(ctx, MM_INTERACTION_ELEMENTS),\n                /*alpha=*/\n                *borrow(ctx, MM_INTERACTION_ELEMENTS + 1),\n                prod,\n                memory_hash,\n                page_addr\n            ])));\n\n            assert!(is_valid(fact_hash), MEMORY_PAGE_FACT_NOT_REGISTERED);\n        }\n    }\n\n    // In Starknet's contracts, this function is implemented in `CpuVerifier.sol`\n    fun get_public_input_hash(public_input: &vector<u256>): u256 {\n        // The initial seed consists of the first part of publicInput. Specifically, it does not\n        // include the page products (which are only known later in the process, as they depend on\n        // the values of z and alpha).\n        let n_pages = *borrow(public_input, OFFSET_N_PUBLIC_MEMORY_PAGES);\n        let public_input_size_for_hash = get_offset_page_prod(0, n_pages);\n\n        u256_from_bytes_be(&keccak256(vec_to_bytes_be(&slice(public_input, 0, (public_input_size_for_hash as u64)))))\n    }\n\n    /*\n          Computes the value of the public memory quotient:\n            numerator / (denominator * padding)\n          where:\n            numerator = (z - (0 + alpha * 0))^S,\n            denominator = \\prod_i( z - (addr_i + alpha * value_i) ),\n            padding = (z - (padding_addr + alpha * padding_value))^(S - N),\n            N is the actual number of public memory cells,\n            and S is the number of cells allocated for the public memory (which includes the padding).\n    */\n    fun compute_public_memory_quotient(ctx: &mut vector<u256>, public_input: &vector<u256>): u256 {\n        let n_values = *borrow(ctx, MM_N_PUBLIC_MEM_ENTRIES);\n        let z = *borrow(ctx, MM_MEMORY__MULTI_COLUMN_PERM__PERM__INTERACTION_ELM);\n        let alpha = *borrow(ctx, MM_MEMORY__MULTI_COLUMN_PERM__HASH_INTERACTION_ELM0);\n        // The size that is allocated to the public memory.\n        let public_memory_size = safe_div(*borrow(ctx, MM_TRACE_LENGTH), PUBLIC_MEMORY_STEP);\n\n        // Ensure 'nValues' is bounded as a sanity check\n        // (the bound is somewhat arbitrary).\n        assert!(n_values < 0x1000000, OVERFLOW_PROTECTION_FAILED);\n        assert!(n_values <= public_memory_size, NUMBER_OF_VALUES_OF_PUBLIC_MEMORY_IS_TOO_LARGE);\n\n        let n_public_memory_pages = *borrow(ctx, MM_N_PUBLIC_MEM_PAGES);\n        let cumulative_prods_ptr = *borrow(ctx, MM_PUBLIC_INPUT_PTR) + get_offset_page_prod(0, n_public_memory_pages);\n        let denominator = compute_public_memory_prod(\n            public_input,\n            cumulative_prods_ptr,\n            n_public_memory_pages,\n            k_modulus()\n        );\n\n        // Compute address + alpha * value for the first address-value pair for padding.\n        let public_input_ptr = (*borrow(ctx, MM_PUBLIC_INPUT_PTR) as u64);\n        let padding_addr_ptr = public_input_ptr + OFFSET_PUBLIC_MEMORY_PADDING_ADDR;\n        let padding_addr = *borrow(public_input, padding_addr_ptr);\n        let padding_value = *borrow(public_input, padding_addr_ptr + 1);\n        let hash_first_address_value = fadd(padding_addr, fmul(padding_value, alpha));\n\n        // Pad the denominator with the shifted value of hash_first_address_value.\n        let denom_pad = fpow(fsub(z, hash_first_address_value), public_memory_size - n_values);\n        denominator = fmul(denominator, denom_pad);\n\n        // Calculate the numerator.\n        let numerator = fpow(z, public_memory_size);\n\n        // Compute the final result: numerator * denominator^(-1).\n        fmul(numerator, inverse(denominator))\n    }\n\n    /*\n          Computes the cumulative product of the public memory cells:\n            \\prod_i( z - (addr_i + alpha * value_i) ).\n\n          publicMemoryPtr is an array of nValues pairs (address, value).\n          z and alpha are the perm and hash interaction elements assert!d to calculate the product.\n    */\n    fun compute_public_memory_prod(\n        public_input: &vector<u256>,\n        cumulative_prods_ptr: u256,\n        n_public_memory_pages: u256,\n        prime: u256\n    ): u256 {\n        let res = 1u256;\n        for (i in cumulative_prods_ptr..(cumulative_prods_ptr + n_public_memory_pages)) {\n            res = mod_mul(res, *borrow(public_input, (i as u64)), prime);\n        };\n        res\n    }\n\n    // In Starknet's contracts, this function is implemented in `CpuVerifier.sol`\n    fun oods_consistency_check(ctx: &mut vector<u256>, public_input: &vector<u256>) {\n        verify_memory_page_facts(ctx, public_input);\n        let temp = *borrow(ctx, MM_INTERACTION_ELEMENTS);\n        set_el(ctx, MM_MEMORY__MULTI_COLUMN_PERM__PERM__INTERACTION_ELM, temp);\n        let temp = *borrow(ctx, MM_INTERACTION_ELEMENTS + 1);\n        set_el(ctx, MM_MEMORY__MULTI_COLUMN_PERM__HASH_INTERACTION_ELM0, temp);\n        let temp = *borrow(ctx, MM_INTERACTION_ELEMENTS + 2);\n        set_el(ctx, MM_RANGE_CHECK16__PERM__INTERACTION_ELM, temp);\n        {\n            let public_memory_prod = compute_public_memory_quotient(ctx, public_input);\n            set_el(ctx, MM_MEMORY__MULTI_COLUMN_PERM__PERM__PUBLIC_MEMORY_PROD, public_memory_prod);\n        };\n        prepare_for_oods_check(ctx);\n\n        // Todo\n        // let composition_from_trace_value;\n        // address\n        // lconstraintPoly = address(constraintPoly);\n        // let offset = 1 + MM_CONSTRAINT_POLY_ARGS_START();\n        // let size = MM_CONSTRAINT_POLY_ARGS_END() - MM_CONSTRAINT_POLY_ARGS_START;\n        // assembly {\n        //     // Call CpuConstraintPoly contract.\n        //     let p = mload(0x40)\n        //     if iszero(staticcall(not(0), lconstraintPoly, add(ctx, offset), size, p, 0x20)) {\n        //     returndatacopy(0, 0, returndatasize())\n        //     revert(0, returndatasize())\n        //     }\n        //     compositionFromTraceValue = mload(p)\n        // }\n\n        // let claimed_composition = fadd(\n        //     *borrow(ctx, MM_COMPOSITION_OODS_VALUES()),\n        //     fmul(*borrow(ctx, MM_OODS_POINT()), *borrow(ctx, MM_COMPOSITION_OODS_VALUES + 1))\n        // );\n        //\n        // assert!(\n        //     composition_from_trace_value == claimed_composition,\n        //     CLAIMED_COMPOSITION_DOES_NOT_MATCH_TRACE\n        // );\n    }\n\n    fun get_n_columns_in_trace(): u64 {\n        N_COLUMNS_IN_MASK\n    }\n\n    fun get_n_columns_in_trace_0(): u64 {\n        N_COLUMNS_IN_TRACE0\n    }\n\n    fun get_n_columns_in_trace_1(): u64 {\n        N_COLUMNS_IN_TRACE1\n    }\n\n    fun get_n_columns_in_composition(): u64 {\n        CONSTRAINTS_DEGREE_BOUND\n    }\n\n    fun get_mm_interaction_elements(): u64 {\n        MM_INTERACTION_ELEMENTS\n    }\n\n    fun get_mm_oods_values(): u256 {\n        (MM_OODS_VALUES as u256)\n    }\n\n    fun get_n_interaction_elements(): u64 {\n        N_INTERACTION_ELEMENTS\n    }\n\n    fun get_n_coefficients(): u256 {\n        N_COEFFICIENTS\n    }\n\n    fun get_n_oods_values(): u64 {\n        N_OODS_VALUES\n    }\n\n    fun get_n_oods_coefficients(): u64 {\n        N_OODS_COEFFICIENTS\n    }\n\n    fun get_public_memory_offset(): u64 {\n        OFFSET_PUBLIC_MEMORY\n    }\n\n    fun has_interaction(): bool {\n        get_n_columns_in_trace_1() > 0\n    }\n\n    fun bit_reverse(value: u256, number_of_bits: u8): u256 {\n        // Bit reverse value by swapping 1 bit chunks then 2 bit chunks and so forth.\n        // A swap can be done by masking the relevant chunks and shifting them to the\n        // correct location.\n        // However, to save some shift operations we shift only one of the chunks by twice\n        // the chunk size, and perform a single right shift at the end.\n        let res = value;\n        // Swap 1 bit chunks.\n        res = ((res & 0x5555555555555555) << 2) | (res & 0xaaaaaaaaaaaaaaaa);\n        // Swap 2 bit chunks.\n        res = ((res & 0x6666666666666666) << 4) | (res & 0x19999999999999998);\n        // Swap 4 bit chunks.\n        res = ((res & 0x7878787878787878) << 8) | (res & 0x78787878787878780);\n        // Swap 8 bit chunks.\n        res = ((res & 0x7f807f807f807f80) << 16) | (res & 0x7f807f807f807f8000);\n        // Swap 16 bit chunks.\n        res = ((res & 0x7fff80007fff8000) << 32) | (res & 0x7fff80007fff80000000);\n        // Swap 32 bit chunks.\n        res = ((res & 0x7fffffff80000000) << 64) | (res & 0x7fffffff8000000000000000);\n        // Shift right the result.\n        // Note that we combine two right shifts here:\n        // 1. On each swap above we skip a right shift and get a left shifted result.\n        //    Consequently, we need to right shift the final result by\n        //    1 + 2 + 4 + 8 + 16 + 32 = 63.\n        // 2. The step above computes the bit-reverse of a 64-bit input. If the goal is to\n        //    bit-reverse only numberOfBits then the result needs to be right shifted by\n        //    64 - numberOfBits.\n        res = res >> (127 - number_of_bits);\n        res\n    }\n\n    // assertion code\n    const INVALID_PROOF_PARAMS: u64 = 1;\n    const LOG_BLOWUP_FACTOR_MUST_BE_AT_MOST_16: u64 = 2;\n    const LOG_BLOWUP_FACTOR_MUST_BE_AT_LEAST_1: u64 = 3;\n    const PROOF_OF_WORK_BITS_MUST_BE_AT_MOST_50: u64 = 4;\n    const MINIMUM_PROOF_OF_WORK_BITS_NOT_SATISFIED: u64 = 5;\n    const PROOFS_MAY_NOT_BE_PURELY_BASED_ON_POW: u64 = 6;\n    const LOG_FRI_LAST_LAYER_DEG_BOUND_MUST_BE_AT_MOST_10: u64 = 7;\n    const TOO_MANY_FRI_STEPS: u64 = 8;\n    const NOT_ENOUGH_FRI_STEPS: u64 = 9;\n    const NUMBER_OF_QUERIES_MUST_BE_AT_LEAST_ONE: u64 = 10;\n    const TOO_MANY_QUERIES: u64 = 11;\n    const PROOF_PARAMS_DO_NOT_SATISFY_SECURITY: u64 = 12;\n    const ONLY_ETA0_IS_CURRENTLY_SUPPORTED: u64 = 13;\n    const FRI_PARAMS_DO_NOT_MATCH_TRACE_LENGTH: u64 = 14;\n    const MIN_SUPPORTED_FRI_STEP_SIZE_IS_2: u64 = 15;\n    const MAX_SUPPORTED_FRI_STEP_SIZE_IS_4: u64 = 16;\n    const PUBLIC_INPUT_IS_TOO_SHORT: u64 = 17;\n    const NUMBER_OF_STEPS_IS_TOO_LARGE: u64 = 18;\n    const RC_MIN_MUST_BE_LESS_THAN_OR_EQUAL_TO_RC_MAX: u64 = 19;\n    const RC_MAX_OUT_OF_RANGE: u64 = 20;\n    const LAYOUT_CODE_MISMATCH: u64 = 21;\n    const INVALID_INITIAL_PC: u64 = 22;\n    const INVALID_FINAL_PC: u64 = 23;\n    const INVALID_NUMBER_OF_MEMORY_PAGES: u64 = 24;\n    const TOO_MANY_PUBLIC_MEMORY_ENTRIES_IN_ONE_PAGE: u64 = 25;\n    const PUBLIC_INPUT_LENGTH_MISMATCH: u64 = 26;\n    const MEMORY_PAGE_FACT_NOT_REGISTERED: u64 = 27;\n    const OVERFLOW_PROTECTION_FAILED: u64 = 28;\n    const NUMBER_OF_VALUES_OF_PUBLIC_MEMORY_IS_TOO_LARGE: u64 = 29;\n    const CLAIMED_COMPOSITION_DOES_NOT_MATCH_TRACE: u64 = 30;\n    const TOO_MANY_COLUMNS: u64 = 31;\n    const INVALID_FIELD_ELEMENT: u64 = 32;\n    const WRONG_BYTES_LENGTH: u64 = 33;\n}"
[INFO] [stdout] stack backtrace:
[INFO] [stdout]    0:     0x5aa79aa0d62a - std[ec4e911328de40a6]::backtrace_rs::backtrace::libunwind::trace
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/../../backtrace/src/backtrace/libunwind.rs:117:9
[INFO] [stdout]    1:     0x5aa79aa0d62a - std[ec4e911328de40a6]::backtrace_rs::backtrace::trace_unsynchronized::<std[ec4e911328de40a6]::sys::backtrace::_print_fmt::{closure#1}>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/../../backtrace/src/backtrace/mod.rs:66:14
[INFO] [stdout]    2:     0x5aa79aa0d62a - std[ec4e911328de40a6]::sys::backtrace::_print_fmt
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/sys/backtrace.rs:74:9
[INFO] [stdout]    3:     0x5aa79aa0d62a - <<std[ec4e911328de40a6]::sys::backtrace::BacktraceLock>::print::DisplayBacktrace as core[a96a4c5c53f902a3]::fmt::Display>::fmt
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/sys/backtrace.rs:44:26
[INFO] [stdout]    4:     0x5aa79aa2441a - <core[a96a4c5c53f902a3]::fmt::rt::Argument>::fmt
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/fmt/rt.rs:152:76
[INFO] [stdout]    5:     0x5aa79aa2441a - core[a96a4c5c53f902a3]::fmt::write
[INFO] [stdout]    6:     0x5aa79aa122a2 - std[ec4e911328de40a6]::io::default_write_fmt::<alloc[c960326de6de28e6]::vec::Vec<u8>>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/io/mod.rs:639:11
[INFO] [stdout]    7:     0x5aa79aa122a2 - <alloc[c960326de6de28e6]::vec::Vec<u8> as std[ec4e911328de40a6]::io::Write>::write_fmt
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/io/mod.rs:1994:13
[INFO] [stdout]    8:     0x5aa79a9ec37f - <std[ec4e911328de40a6]::sys::backtrace::BacktraceLock>::print
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/sys/backtrace.rs:47:9
[INFO] [stdout]    9:     0x5aa79a9ec37f - std[ec4e911328de40a6]::panicking::default_hook::{closure#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:292:27
[INFO] [stdout]   10:     0x5aa79aa05999 - std[ec4e911328de40a6]::panicking::default_hook
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:316:9
[INFO] [stdout]   11:     0x5aa79a638b3c - <alloc[c960326de6de28e6]::boxed::Box<dyn for<'a, 'b> core[a96a4c5c53f902a3]::ops::function::Fn<(&'a std[ec4e911328de40a6]::panic::PanicHookInfo<'b>,), Output = ()> + core[a96a4c5c53f902a3]::marker::Sync + core[a96a4c5c53f902a3]::marker::Send> as core[a96a4c5c53f902a3]::ops::function::Fn<(&std[ec4e911328de40a6]::panic::PanicHookInfo,)>>::call
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/alloc/src/boxed.rs:2254:9
[INFO] [stdout]   12:     0x5aa79a638b3c - test[30c43f9fd66fea90]::test_main_with_exit_callback::<test[30c43f9fd66fea90]::test_main::{closure#0}>::{closure#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/test/src/lib.rs:145:21
[INFO] [stdout]   13:     0x5aa79aa05c12 - <alloc[c960326de6de28e6]::boxed::Box<dyn for<'a, 'b> core[a96a4c5c53f902a3]::ops::function::Fn<(&'a std[ec4e911328de40a6]::panic::PanicHookInfo<'b>,), Output = ()> + core[a96a4c5c53f902a3]::marker::Sync + core[a96a4c5c53f902a3]::marker::Send> as core[a96a4c5c53f902a3]::ops::function::Fn<(&std[ec4e911328de40a6]::panic::PanicHookInfo,)>>::call
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/alloc/src/boxed.rs:2254:9
[INFO] [stdout]   14:     0x5aa79aa05c12 - std[ec4e911328de40a6]::panicking::panic_with_hook
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:833:13
[INFO] [stdout]   15:     0x5aa79a9ec438 - std[ec4e911328de40a6]::panicking::panic_handler::{closure#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:698:13
[INFO] [stdout]   16:     0x5aa79a9e3da9 - std[ec4e911328de40a6]::sys::backtrace::__rust_end_short_backtrace::<std[ec4e911328de40a6]::panicking::panic_handler::{closure#0}, !>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/sys/backtrace.rs:182:18
[INFO] [stdout]   17:     0x5aa79a9ed14d - __rustc[aa69f48705c57ca8]::rust_begin_unwind
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:689:5
[INFO] [stdout]   18:     0x5aa79aa24c5c - core[a96a4c5c53f902a3]::panicking::panic_fmt
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/panicking.rs:80:14
[INFO] [stdout]   19:     0x5aa79aa24b73 - core[a96a4c5c53f902a3]::panicking::assert_failed_inner
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/panicking.rs:434:23
[INFO] [stdout]   20:     0x5aa79a1ec8dd - core[a96a4c5c53f902a3]::panicking::assert_failed::<alloc[c960326de6de28e6]::string::String, &str>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/panicking.rs:394:5
[INFO] [stdout]   21:     0x5aa79a21a9c7 - orn_cli[b9b28deef4e9b44d]::gen_const::test::test_gen_consts_sample2
[INFO] [stdout]                                at /opt/rustwide/workdir/src/gen_const.rs:239:9
[INFO] [stdout]   22:     0x5aa79a21a597 - orn_cli[b9b28deef4e9b44d]::gen_const::test::test_gen_consts_sample2::{closure#0}
[INFO] [stdout]                                at /opt/rustwide/workdir/src/gen_const.rs:235:33
[INFO] [stdout]   23:     0x5aa79a21bc46 - <orn_cli[b9b28deef4e9b44d]::gen_const::test::test_gen_consts_sample2::{closure#0} as core[a96a4c5c53f902a3]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   24:     0x5aa79a62cc1b - <fn() -> core[a96a4c5c53f902a3]::result::Result<(), alloc[c960326de6de28e6]::string::String> as core[a96a4c5c53f902a3]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   25:     0x5aa79a62cc1b - test[30c43f9fd66fea90]::__rust_begin_short_backtrace::<core[a96a4c5c53f902a3]::result::Result<(), alloc[c960326de6de28e6]::string::String>, fn() -> core[a96a4c5c53f902a3]::result::Result<(), alloc[c960326de6de28e6]::string::String>>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/test/src/lib.rs:663:18
[INFO] [stdout]   26:     0x5aa79a63960b - test[30c43f9fd66fea90]::run_test_in_process::{closure#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/test/src/lib.rs:686:74
[INFO] [stdout]   27:     0x5aa79a63960b - <core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<test[30c43f9fd66fea90]::run_test_in_process::{closure#0}> as core[a96a4c5c53f902a3]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/panic/unwind_safe.rs:275:9
[INFO] [stdout]   28:     0x5aa79a63960b - std[ec4e911328de40a6]::panicking::catch_unwind::do_call::<core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<test[30c43f9fd66fea90]::run_test_in_process::{closure#0}>, core[a96a4c5c53f902a3]::result::Result<(), alloc[c960326de6de28e6]::string::String>>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:581:40
[INFO] [stdout]   29:     0x5aa79a63960b - std[ec4e911328de40a6]::panicking::catch_unwind::<core[a96a4c5c53f902a3]::result::Result<(), alloc[c960326de6de28e6]::string::String>, core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<test[30c43f9fd66fea90]::run_test_in_process::{closure#0}>>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:544:19
[INFO] [stdout]   30:     0x5aa79a63960b - std[ec4e911328de40a6]::panic::catch_unwind::<core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<test[30c43f9fd66fea90]::run_test_in_process::{closure#0}>, core[a96a4c5c53f902a3]::result::Result<(), alloc[c960326de6de28e6]::string::String>>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panic.rs:359:14
[INFO] [stdout]   31:     0x5aa79a63960b - test[30c43f9fd66fea90]::run_test_in_process
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/test/src/lib.rs:686:27
[INFO] [stdout]   32:     0x5aa79a63960b - test[30c43f9fd66fea90]::run_test::{closure#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/test/src/lib.rs:607:43
[INFO] [stdout]   33:     0x5aa79a634d24 - test[30c43f9fd66fea90]::run_test::{closure#1}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/test/src/lib.rs:637:41
[INFO] [stdout]   34:     0x5aa79a634d24 - std[ec4e911328de40a6]::sys::backtrace::__rust_begin_short_backtrace::<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/sys/backtrace.rs:166:18
[INFO] [stdout]   35:     0x5aa79a63c212 - std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked::<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/thread/lifecycle.rs:91:13
[INFO] [stdout]   36:     0x5aa79a63c212 - <core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}> as core[a96a4c5c53f902a3]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/panic/unwind_safe.rs:275:9
[INFO] [stdout]   37:     0x5aa79a63c212 - std[ec4e911328de40a6]::panicking::catch_unwind::do_call::<core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}>, ()>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:581:40
[INFO] [stdout]   38:     0x5aa79a63c212 - std[ec4e911328de40a6]::panicking::catch_unwind::<(), core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}>>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panicking.rs:544:19
[INFO] [stdout]   39:     0x5aa79a63c212 - std[ec4e911328de40a6]::panic::catch_unwind::<core[a96a4c5c53f902a3]::panic::unwind_safe::AssertUnwindSafe<std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}>, ()>
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/panic.rs:359:14
[INFO] [stdout]   40:     0x5aa79a63c212 - std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked::<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/thread/lifecycle.rs:89:26
[INFO] [stdout]   41:     0x5aa79a63c212 - <std[ec4e911328de40a6]::thread::lifecycle::spawn_unchecked<test[30c43f9fd66fea90]::run_test::{closure#1}, ()>::{closure#1} as core[a96a4c5c53f902a3]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   42:     0x5aa79aa0ceff - <alloc[c960326de6de28e6]::boxed::Box<dyn core[a96a4c5c53f902a3]::ops::function::FnOnce<(), Output = ()> + core[a96a4c5c53f902a3]::marker::Send> as core[a96a4c5c53f902a3]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/alloc/src/boxed.rs:2240:9
[INFO] [stdout]   43:     0x5aa79aa0ceff - <std[ec4e911328de40a6]::sys::thread::unix::Thread>::new::thread_start
[INFO] [stdout]                                at /rustc/0abe69e6c16114311cc2700e972492e64d69c28f/library/std/src/sys/thread/unix.rs:118:17
[INFO] [stdout]   44:     0x7625d65a6aa4 - <unknown>
[INFO] [stdout]   45:     0x7625d6633a64 - clone
[INFO] [stdout]   46:                0x0 - <unknown>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] failures:
[INFO] [stdout]     gen_const::test::test_gen_consts_sample2
[INFO] [stdout] 
[INFO] [stdout] test result: FAILED. 9 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.29s
[INFO] [stdout] 
[INFO] [stderr] error: test failed, to rerun pass `--lib`
[INFO] running `Command { std: "docker" "inspect" "a33d70748cefc0681f52f0ab22f8870b172ae839d1c0e72b0a46e30c8e3eb7fe", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "a33d70748cefc0681f52f0ab22f8870b172ae839d1c0e72b0a46e30c8e3eb7fe", kill_on_drop: false }`
[INFO] [stdout] a33d70748cefc0681f52f0ab22f8870b172ae839d1c0e72b0a46e30c8e3eb7fe
