[INFO] cloning repository https://github.com/CaoKiet251/Cuproof
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/CaoKiet251/Cuproof" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaoKiet251%2FCuproof", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaoKiet251%2FCuproof'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] ebd48576782c64f44e272aab0992527db35b8beb
[INFO] testing CaoKiet251/Cuproof against master#2fd6efc32704647e64d3d646d21c4c68eae100e4 for pr-149852-1
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaoKiet251%2FCuproof" "/workspace/builds/worker-6-tc1/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-6-tc1/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/CaoKiet251/Cuproof
[INFO] finished tweaking git repo https://github.com/CaoKiet251/Cuproof
[INFO] tweaked toml for git repo https://github.com/CaoKiet251/Cuproof written to /workspace/builds/worker-6-tc1/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/CaoKiet251/Cuproof on toolchain 2fd6efc32704647e64d3d646d21c4c68eae100e4
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+2fd6efc32704647e64d3d646d21c4c68eae100e4" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/CaoKiet251/Cuproof 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" "+2fd6efc32704647e64d3d646d21c4c68eae100e4" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded clap v4.5.42
[INFO] [stderr]   Downloaded clap_builder v4.5.42
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/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:aa71247004a7fa38d13ec170f48f06cdedf5bc50b2a8645e56ed7e992e6fa513" "/opt/rustwide/cargo-home/bin/cargo" "+2fd6efc32704647e64d3d646d21c4c68eae100e4" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] ce101c730e3844269dcb982637c2898df019af6196604cc9c06340ea58a8e22c
[INFO] running `Command { std: "docker" "start" "-a" "ce101c730e3844269dcb982637c2898df019af6196604cc9c06340ea58a8e22c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "ce101c730e3844269dcb982637c2898df019af6196604cc9c06340ea58a8e22c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "ce101c730e3844269dcb982637c2898df019af6196604cc9c06340ea58a8e22c", kill_on_drop: false }`
[INFO] [stdout] ce101c730e3844269dcb982637c2898df019af6196604cc9c06340ea58a8e22c
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/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:aa71247004a7fa38d13ec170f48f06cdedf5bc50b2a8645e56ed7e992e6fa513" "/opt/rustwide/cargo-home/bin/cargo" "+2fd6efc32704647e64d3d646d21c4c68eae100e4" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 34857f61d5f25f3e3dd9edcefa1295fabe04cda895fc930ce95c5ba42446e96b
[INFO] running `Command { std: "docker" "start" "-a" "34857f61d5f25f3e3dd9edcefa1295fabe04cda895fc930ce95c5ba42446e96b", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.174
[INFO] [stderr]    Compiling num-integer v0.1.46
[INFO] [stderr]    Compiling sha2 v0.10.9
[INFO] [stderr]    Compiling sha3 v0.10.8
[INFO] [stderr]    Compiling getrandom v0.2.16
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling rand v0.8.5
[INFO] [stderr]    Compiling num-bigint v0.4.6
[INFO] [stderr]    Compiling cuproof v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `Signed`
[INFO] [stdout]  --> src/setup.rs:2:18
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stdout]   |                  ^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_traits::Zero`
[INFO] [stdout]  --> src/range_proof.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use num_traits::Zero;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `util::*`
[INFO] [stdout]  --> src/verify.rs:1:13
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stdout]   |             ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `bits`
[INFO] [stdout]   --> src/setup.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C`
[INFO] [stdout]    --> src/range_proof.rs:155:7
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v1`
[INFO] [stdout]    --> src/range_proof.rs:156:7
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v2`
[INFO] [stdout]    --> src/range_proof.rs:157:7
[INFO] [stdout]     |
[INFO] [stdout] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `l0`
[INFO] [stdout]    --> src/range_proof.rs:182:6
[INFO] [stdout]     |
[INFO] [stdout] 182 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r0`
[INFO] [stdout]    --> src/range_proof.rs:183:6
[INFO] [stdout]     |
[INFO] [stdout] 183 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `final_proof`
[INFO] [stdout]    --> src/range_proof.rs:218:6
[INFO] [stdout]     |
[INFO] [stdout] 218 |     let final_proof = Cuproof {
[INFO] [stdout]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `g`
[INFO] [stdout]    --> src/range_proof.rs:277:146
[INFO] [stdout]     |
[INFO] [stdout] 277 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `h`
[INFO] [stdout]    --> src/range_proof.rs:277:158
[INFO] [stdout]     |
[INFO] [stdout] 277 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `n`
[INFO] [stdout]    --> src/range_proof.rs:277:170
[INFO] [stdout]     |
[INFO] [stdout] 277 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r`
[INFO] [stdout]    --> src/range_proof.rs:315:49
[INFO] [stdout]     |
[INFO] [stdout] 315 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stdout]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `L` should have a snake case name
[INFO] [stdout]  --> src/range_proof.rs:7:6
[INFO] [stdout]   |
[INFO] [stdout] 7 |     pub L: Vec<BigInt>,  // Left commitments at each level
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `R` should have a snake case name
[INFO] [stdout]  --> src/range_proof.rs:8:6
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub R: Vec<BigInt>,  // Right commitments at each level
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:15:6
[INFO] [stdout]    |
[INFO] [stdout] 15 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:16:6
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:17:6
[INFO] [stdout]    |
[INFO] [stdout] 17 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:18:6
[INFO] [stdout]    |
[INFO] [stdout] 18 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:22:6
[INFO] [stdout]    |
[INFO] [stdout] 22 |     pub C: BigInt,  // Commitment to value v
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:23:6
[INFO] [stdout]    |
[INFO] [stdout] 23 |     pub C_v1: BigInt,  // Commitment to v1 = 4v - 4a + 1
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:24:6
[INFO] [stdout]    |
[INFO] [stdout] 24 |     pub C_v2: BigInt,  // Commitment to v2 = 4b - 4v + 1
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sL` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:42:6
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub sL: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sR` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:43:6
[INFO] [stdout]    |
[INFO] [stdout] 43 |     pub sR: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:61:6
[INFO] [stdout]    |
[INFO] [stdout] 61 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:62:6
[INFO] [stdout]    |
[INFO] [stdout] 62 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:63:6
[INFO] [stdout]    |
[INFO] [stdout] 63 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:64:6
[INFO] [stdout]    |
[INFO] [stdout] 64 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:97:6
[INFO] [stdout]    |
[INFO] [stdout] 97 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:98:6
[INFO] [stdout]    |
[INFO] [stdout] 98 |     let c_R = inner_product(l_right, r_left);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:101:6
[INFO] [stdout]     |
[INFO] [stdout] 101 |     let r_L = random_bigint(256);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:102:6
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let r_R = random_bigint(256);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:103:6
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:104:6
[INFO] [stdout]     |
[INFO] [stdout] 104 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:115:28
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:145:6
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:149:6
[INFO] [stdout]     |
[INFO] [stdout] 149 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:150:6
[INFO] [stdout]     |
[INFO] [stdout] 150 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:152:6
[INFO] [stdout]     |
[INFO] [stdout] 152 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:155:7
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:156:7
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:157:7
[INFO] [stdout]     |
[INFO] [stdout] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:165:41
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:166:35
[INFO] [stdout]     |
[INFO] [stdout] 166 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:186:6
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:187:6
[INFO] [stdout]     |
[INFO] [stdout] 187 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:195:15
[INFO] [stdout]     |
[INFO] [stdout] 195 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:197:15
[INFO] [stdout]     |
[INFO] [stdout] 197 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:204:25
[INFO] [stdout]     |
[INFO] [stdout] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:204:32
[INFO] [stdout]     |
[INFO] [stdout] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:214:6
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:215:6
[INFO] [stdout]     |
[INFO] [stdout] 215 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:216:6
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:257:69
[INFO] [stdout]     |
[INFO] [stdout] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:257:81
[INFO] [stdout]     |
[INFO] [stdout] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:263:69
[INFO] [stdout]     |
[INFO] [stdout] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:263:82
[INFO] [stdout]     |
[INFO] [stdout] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:330:7
[INFO] [stdout]     |
[INFO] [stdout] 330 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:331:7
[INFO] [stdout]     |
[INFO] [stdout] 331 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:332:7
[INFO] [stdout]     |
[INFO] [stdout] 332 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:336:6
[INFO] [stdout]     |
[INFO] [stdout] 336 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:337:6
[INFO] [stdout]     |
[INFO] [stdout] 337 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:341:6
[INFO] [stdout]     |
[INFO] [stdout] 341 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:343:6
[INFO] [stdout]     |
[INFO] [stdout] 343 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:355:41
[INFO] [stdout]     |
[INFO] [stdout] 355 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:356:35
[INFO] [stdout]     |
[INFO] [stdout] 356 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:362:6
[INFO] [stdout]     |
[INFO] [stdout] 362 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:363:6
[INFO] [stdout]     |
[INFO] [stdout] 363 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:376:44
[INFO] [stdout]     |
[INFO] [stdout] 376 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:377:44
[INFO] [stdout]     |
[INFO] [stdout] 377 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:379:25
[INFO] [stdout]     |
[INFO] [stdout] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:379:32
[INFO] [stdout]     |
[INFO] [stdout] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:469:6
[INFO] [stdout]     |
[INFO] [stdout] 469 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:470:6
[INFO] [stdout]     |
[INFO] [stdout] 470 |     let c_R = inner_product(l_right, l_left);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/util.rs:144:9
[INFO] [stdout]     |
[INFO] [stdout] 144 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/util.rs:145:9
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/util.rs:146:9
[INFO] [stdout]     |
[INFO] [stdout] 146 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/util.rs:147:9
[INFO] [stdout]     |
[INFO] [stdout] 147 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/util.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/util.rs:152:9
[INFO] [stdout]     |
[INFO] [stdout] 152 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/util.rs:153:9
[INFO] [stdout]     |
[INFO] [stdout] 153 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/util.rs:163:13
[INFO] [stdout]     |
[INFO] [stdout] 163 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/util.rs:168:13
[INFO] [stdout]     |
[INFO] [stdout] 168 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_bigint::BigInt`
[INFO] [stdout]  --> src/main.rs:2:5
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_bigint::BigInt;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `cuproof_verify`
[INFO] [stdout]  --> src/main.rs:5:23
[INFO] [stdout]   |
[INFO] [stdout] 5 | use cuproof::verify::{cuproof_verify, cuproof_verify_with_range};
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_bigint::BigInt`
[INFO] [stdout]  --> src_256/main.rs:2:5
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_bigint::BigInt;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `Signed`
[INFO] [stdout]  --> src_256/setup.rs:2:18
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stdout]   |                  ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_traits::Zero`
[INFO] [stdout]  --> src_256/range_proof.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use num_traits::Zero;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `util::*`
[INFO] [stdout]  --> src_256/verify.rs:1:13
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stdout]   |             ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::util::bigint_to_hex`
[INFO] [stdout]  --> src_256/evm.rs:2:5
[INFO] [stdout]   |
[INFO] [stdout] 2 | use crate::util::bigint_to_hex;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `bits`
[INFO] [stdout]   --> src_256/setup.rs:60:22
[INFO] [stdout]    |
[INFO] [stdout] 60 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C`
[INFO] [stdout]    --> src_256/range_proof.rs:141:7
[INFO] [stdout]     |
[INFO] [stdout] 141 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v1`
[INFO] [stdout]    --> src_256/range_proof.rs:142:7
[INFO] [stdout]     |
[INFO] [stdout] 142 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v2`
[INFO] [stdout]    --> src_256/range_proof.rs:143:7
[INFO] [stdout]     |
[INFO] [stdout] 143 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `l0`
[INFO] [stdout]    --> src_256/range_proof.rs:165:6
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r0`
[INFO] [stdout]    --> src_256/range_proof.rs:166:6
[INFO] [stdout]     |
[INFO] [stdout] 166 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `final_proof`
[INFO] [stdout]    --> src_256/range_proof.rs:197:6
[INFO] [stdout]     |
[INFO] [stdout] 197 |     let final_proof = Cuproof {
[INFO] [stdout]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `g`
[INFO] [stdout]    --> src_256/range_proof.rs:251:146
[INFO] [stdout]     |
[INFO] [stdout] 251 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `h`
[INFO] [stdout]    --> src_256/range_proof.rs:251:158
[INFO] [stdout]     |
[INFO] [stdout] 251 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `n`
[INFO] [stdout]    --> src_256/range_proof.rs:251:170
[INFO] [stdout]     |
[INFO] [stdout] 251 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r`
[INFO] [stdout]    --> src_256/range_proof.rs:265:49
[INFO] [stdout]     |
[INFO] [stdout] 265 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stdout]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `trusted_setup` is never used
[INFO] [stdout]   --> src_256/setup.rs:60:8
[INFO] [stdout]    |
[INFO] [stdout] 60 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |        ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `find_4_squares` is never used
[INFO] [stdout]  --> src_256/lagrange.rs:4:8
[INFO] [stdout]   |
[INFO] [stdout] 4 | pub fn find_4_squares(n: &BigInt) -> Vec<BigInt> {
[INFO] [stdout]   |        ^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct `ProverState` is never constructed
[INFO] [stdout]   --> src_256/range_proof.rs:34:12
[INFO] [stdout]    |
[INFO] [stdout] 34 | pub struct ProverState {
[INFO] [stdout]    |            ^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct `VerifierState` is never constructed
[INFO] [stdout]   --> src_256/range_proof.rs:56:12
[INFO] [stdout]    |
[INFO] [stdout] 56 | pub struct VerifierState {
[INFO] [stdout]    |            ^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_prove_step1` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:118:8
[INFO] [stdout]     |
[INFO] [stdout] 118 | pub fn interactive_prove_step1(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (ProverState,...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_prove_step2` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:164:8
[INFO] [stdout]     |
[INFO] [stdout] 164 | pub fn interactive_prove_step2(prover_state: &ProverState, y: &BigInt, z: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, ...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_prove_step3` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:174:8
[INFO] [stdout]     |
[INFO] [stdout] 174 | pub fn interactive_prove_step3(prover_state: &ProverState, x: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, BigInt, BigI...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step1` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:219:8
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub fn interactive_verify_step1(g: &BigInt, h: &BigInt, n: &BigInt) -> (VerifierState, BigInt, BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step2` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:234:8
[INFO] [stdout]     |
[INFO] [stdout] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step3` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:239:8
[INFO] [stdout]     |
[INFO] [stdout] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step4` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:244:8
[INFO] [stdout]     |
[INFO] [stdout] 244 | pub fn interactive_verify_step4(verifier_state: &mut VerifierState, g: &BigInt, n: &BigInt) -> BigInt {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_final` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:251:8
[INFO] [stdout]     |
[INFO] [stdout] 251 | pub fn interactive_verify_final(verifier_state: &VerifierState, t_hat: &BigInt, mu: &BigInt, tau_x: &BigInt, a_final: &BigInt, b_fi...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `inner_product_argument` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:388:8
[INFO] [stdout]     |
[INFO] [stdout] 388 | pub fn inner_product_argument(l_vec: &[BigInt], r_vec: &[BigInt], g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `L` should have a snake case name
[INFO] [stdout]  --> src_256/range_proof.rs:7:6
[INFO] [stdout]   |
[INFO] [stdout] 7 |     pub L: Vec<BigInt>,
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `R` should have a snake case name
[INFO] [stdout]  --> src_256/range_proof.rs:8:6
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub R: Vec<BigInt>,
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:15:6
[INFO] [stdout]    |
[INFO] [stdout] 15 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:16:6
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:17:6
[INFO] [stdout]    |
[INFO] [stdout] 17 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:18:6
[INFO] [stdout]    |
[INFO] [stdout] 18 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:22:6
[INFO] [stdout]    |
[INFO] [stdout] 22 |     pub C: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v1` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:23:6
[INFO] [stdout]    |
[INFO] [stdout] 23 |     pub C_v1: BigInt,
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v2` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:24:6
[INFO] [stdout]    |
[INFO] [stdout] 24 |     pub C_v2: BigInt,
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sL` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:41:6
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub sL: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sR` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:42:6
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub sR: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:60:6
[INFO] [stdout]    |
[INFO] [stdout] 60 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:61:6
[INFO] [stdout]    |
[INFO] [stdout] 61 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:62:6
[INFO] [stdout]    |
[INFO] [stdout] 62 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:63:6
[INFO] [stdout]    |
[INFO] [stdout] 63 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:93:6
[INFO] [stdout]    |
[INFO] [stdout] 93 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:94:6
[INFO] [stdout]    |
[INFO] [stdout] 94 |     let c_R = inner_product(l_right, r_left);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_L` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:96:6
[INFO] [stdout]    |
[INFO] [stdout] 96 |     let r_L = random_bigint(256);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_R` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:97:6
[INFO] [stdout]    |
[INFO] [stdout] 97 |     let r_R = random_bigint(256);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:98:6
[INFO] [stdout]    |
[INFO] [stdout] 98 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:99:6
[INFO] [stdout]    |
[INFO] [stdout] 99 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:110:17
[INFO] [stdout]     |
[INFO] [stdout] 110 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:110:28
[INFO] [stdout]     |
[INFO] [stdout] 110 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:133:6
[INFO] [stdout]     |
[INFO] [stdout] 133 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:136:6
[INFO] [stdout]     |
[INFO] [stdout] 136 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:137:6
[INFO] [stdout]     |
[INFO] [stdout] 137 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:139:6
[INFO] [stdout]     |
[INFO] [stdout] 139 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:141:7
[INFO] [stdout]     |
[INFO] [stdout] 141 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:142:7
[INFO] [stdout]     |
[INFO] [stdout] 142 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:143:7
[INFO] [stdout]     |
[INFO] [stdout] 143 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:149:41
[INFO] [stdout]     |
[INFO] [stdout] 149 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:150:35
[INFO] [stdout]     |
[INFO] [stdout] 150 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:168:6
[INFO] [stdout]     |
[INFO] [stdout] 168 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:169:6
[INFO] [stdout]     |
[INFO] [stdout] 169 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:176:15
[INFO] [stdout]     |
[INFO] [stdout] 176 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:178:15
[INFO] [stdout]     |
[INFO] [stdout] 178 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:184:25
[INFO] [stdout]     |
[INFO] [stdout] 184 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:184:32
[INFO] [stdout]     |
[INFO] [stdout] 184 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:193:6
[INFO] [stdout]     |
[INFO] [stdout] 193 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:194:6
[INFO] [stdout]     |
[INFO] [stdout] 194 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:195:6
[INFO] [stdout]     |
[INFO] [stdout] 195 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:234:69
[INFO] [stdout]     |
[INFO] [stdout] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:234:81
[INFO] [stdout]     |
[INFO] [stdout] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:239:69
[INFO] [stdout]     |
[INFO] [stdout] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:239:82
[INFO] [stdout]     |
[INFO] [stdout] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:277:7
[INFO] [stdout]     |
[INFO] [stdout] 277 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:278:7
[INFO] [stdout]     |
[INFO] [stdout] 278 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:279:7
[INFO] [stdout]     |
[INFO] [stdout] 279 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:283:6
[INFO] [stdout]     |
[INFO] [stdout] 283 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:284:6
[INFO] [stdout]     |
[INFO] [stdout] 284 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:287:6
[INFO] [stdout]     |
[INFO] [stdout] 287 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:289:6
[INFO] [stdout]     |
[INFO] [stdout] 289 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:298:41
[INFO] [stdout]     |
[INFO] [stdout] 298 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:299:35
[INFO] [stdout]     |
[INFO] [stdout] 299 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:304:6
[INFO] [stdout]     |
[INFO] [stdout] 304 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:305:6
[INFO] [stdout]     |
[INFO] [stdout] 305 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:314:44
[INFO] [stdout]     |
[INFO] [stdout] 314 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:315:44
[INFO] [stdout]     |
[INFO] [stdout] 315 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:317:25
[INFO] [stdout]     |
[INFO] [stdout] 317 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:317:32
[INFO] [stdout]     |
[INFO] [stdout] 317 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:399:6
[INFO] [stdout]     |
[INFO] [stdout] 399 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:400:6
[INFO] [stdout]     |
[INFO] [stdout] 400 |     let c_R = inner_product(l_right, l_left);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:110:9
[INFO] [stdout]     |
[INFO] [stdout] 110 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:111:9
[INFO] [stdout]     |
[INFO] [stdout] 111 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:112:9
[INFO] [stdout]     |
[INFO] [stdout] 112 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:113:9
[INFO] [stdout]     |
[INFO] [stdout] 113 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:117:9
[INFO] [stdout]     |
[INFO] [stdout] 117 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:119:9
[INFO] [stdout]     |
[INFO] [stdout] 119 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:133:13
[INFO] [stdout]     |
[INFO] [stdout] 133 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1_recalc` should have a snake case name
[INFO] [stdout]   --> src_256/evm.rs:38:9
[INFO] [stdout]    |
[INFO] [stdout] 38 |     let T1_recalc = pedersen_commit(g, h, &t1_mod, &tau1_mod, n);
[INFO] [stdout]    |         ^^^^^^^^^ help: convert the identifier to snake case: `t1_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2_recalc` should have a snake case name
[INFO] [stdout]   --> src_256/evm.rs:39:9
[INFO] [stdout]    |
[INFO] [stdout] 39 |     let T2_recalc = pedersen_commit(g, h, &t2_mod, &tau2_mod, n);
[INFO] [stdout]    |         ^^^^^^^^^ help: convert the identifier to snake case: `t2_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1_recalc` should have a snake case name
[INFO] [stdout]    --> src_256/evm.rs:137:9
[INFO] [stdout]     |
[INFO] [stdout] 137 |     let T1_recalc = pedersen_commit(g, h, &t1_mod, &tau1_mod, n);
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `t1_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2_recalc` should have a snake case name
[INFO] [stdout]    --> src_256/evm.rs:138:9
[INFO] [stdout]     |
[INFO] [stdout] 138 |     let T2_recalc = pedersen_commit(g, h, &t2_mod, &tau2_mod, n);
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `t2_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 8.53s
[INFO] running `Command { std: "docker" "inspect" "34857f61d5f25f3e3dd9edcefa1295fabe04cda895fc930ce95c5ba42446e96b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "34857f61d5f25f3e3dd9edcefa1295fabe04cda895fc930ce95c5ba42446e96b", kill_on_drop: false }`
[INFO] [stdout] 34857f61d5f25f3e3dd9edcefa1295fabe04cda895fc930ce95c5ba42446e96b
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/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:aa71247004a7fa38d13ec170f48f06cdedf5bc50b2a8645e56ed7e992e6fa513" "/opt/rustwide/cargo-home/bin/cargo" "+2fd6efc32704647e64d3d646d21c4c68eae100e4" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] eff7b14bec38404f93e5700ea8f4206e3bcc5ba9e4abf36709329df3d316e097
[INFO] running `Command { std: "docker" "start" "-a" "eff7b14bec38404f93e5700ea8f4206e3bcc5ba9e4abf36709329df3d316e097", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.174
[INFO] [stderr]    Compiling clap_builder v4.5.42
[INFO] [stderr]    Compiling itertools v0.10.5
[INFO] [stderr]    Compiling getrandom v0.2.16
[INFO] [stderr]    Compiling is-terminal v0.4.16
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling rand v0.8.5
[INFO] [stderr]    Compiling num-bigint v0.4.6
[INFO] [stderr]    Compiling criterion-plot v0.5.0
[INFO] [stderr]    Compiling clap v4.5.42
[INFO] [stderr]    Compiling criterion v0.5.1
[INFO] [stderr]    Compiling cuproof v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `Signed`
[INFO] [stdout]  --> src/setup.rs:2:18
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stdout]   |                  ^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_traits::Zero`
[INFO] [stdout]  --> src/range_proof.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use num_traits::Zero;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `util::*`
[INFO] [stdout]  --> src/verify.rs:1:13
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stdout]   |             ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `bits`
[INFO] [stdout]   --> src/setup.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C`
[INFO] [stdout]    --> src/range_proof.rs:155:7
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v1`
[INFO] [stdout]    --> src/range_proof.rs:156:7
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v2`
[INFO] [stdout]    --> src/range_proof.rs:157:7
[INFO] [stdout]     |
[INFO] [stdout] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `l0`
[INFO] [stdout]    --> src/range_proof.rs:182:6
[INFO] [stdout]     |
[INFO] [stdout] 182 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r0`
[INFO] [stdout]    --> src/range_proof.rs:183:6
[INFO] [stdout]     |
[INFO] [stdout] 183 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `final_proof`
[INFO] [stdout]    --> src/range_proof.rs:218:6
[INFO] [stdout]     |
[INFO] [stdout] 218 |     let final_proof = Cuproof {
[INFO] [stdout]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `g`
[INFO] [stdout]    --> src/range_proof.rs:277:146
[INFO] [stdout]     |
[INFO] [stdout] 277 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `h`
[INFO] [stdout]    --> src/range_proof.rs:277:158
[INFO] [stdout]     |
[INFO] [stdout] 277 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `n`
[INFO] [stdout]    --> src/range_proof.rs:277:170
[INFO] [stdout]     |
[INFO] [stdout] 277 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r`
[INFO] [stdout]    --> src/range_proof.rs:315:49
[INFO] [stdout]     |
[INFO] [stdout] 315 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stdout]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `L` should have a snake case name
[INFO] [stdout]  --> src/range_proof.rs:7:6
[INFO] [stdout]   |
[INFO] [stdout] 7 |     pub L: Vec<BigInt>,  // Left commitments at each level
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `R` should have a snake case name
[INFO] [stdout]  --> src/range_proof.rs:8:6
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub R: Vec<BigInt>,  // Right commitments at each level
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:15:6
[INFO] [stdout]    |
[INFO] [stdout] 15 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:16:6
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:17:6
[INFO] [stdout]    |
[INFO] [stdout] 17 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:18:6
[INFO] [stdout]    |
[INFO] [stdout] 18 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:22:6
[INFO] [stdout]    |
[INFO] [stdout] 22 |     pub C: BigInt,  // Commitment to value v
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:23:6
[INFO] [stdout]    |
[INFO] [stdout] 23 |     pub C_v1: BigInt,  // Commitment to v1 = 4v - 4a + 1
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:24:6
[INFO] [stdout]    |
[INFO] [stdout] 24 |     pub C_v2: BigInt,  // Commitment to v2 = 4b - 4v + 1
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sL` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:42:6
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub sL: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sR` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:43:6
[INFO] [stdout]    |
[INFO] [stdout] 43 |     pub sR: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:61:6
[INFO] [stdout]    |
[INFO] [stdout] 61 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:62:6
[INFO] [stdout]    |
[INFO] [stdout] 62 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:63:6
[INFO] [stdout]    |
[INFO] [stdout] 63 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:64:6
[INFO] [stdout]    |
[INFO] [stdout] 64 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:97:6
[INFO] [stdout]    |
[INFO] [stdout] 97 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:98:6
[INFO] [stdout]    |
[INFO] [stdout] 98 |     let c_R = inner_product(l_right, r_left);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:101:6
[INFO] [stdout]     |
[INFO] [stdout] 101 |     let r_L = random_bigint(256);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:102:6
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let r_R = random_bigint(256);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:103:6
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:104:6
[INFO] [stdout]     |
[INFO] [stdout] 104 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:115:28
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:145:6
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:149:6
[INFO] [stdout]     |
[INFO] [stdout] 149 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:150:6
[INFO] [stdout]     |
[INFO] [stdout] 150 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:152:6
[INFO] [stdout]     |
[INFO] [stdout] 152 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:155:7
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:156:7
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:157:7
[INFO] [stdout]     |
[INFO] [stdout] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:165:41
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:166:35
[INFO] [stdout]     |
[INFO] [stdout] 166 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:186:6
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:187:6
[INFO] [stdout]     |
[INFO] [stdout] 187 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:195:15
[INFO] [stdout]     |
[INFO] [stdout] 195 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:197:15
[INFO] [stdout]     |
[INFO] [stdout] 197 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:204:25
[INFO] [stdout]     |
[INFO] [stdout] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:204:32
[INFO] [stdout]     |
[INFO] [stdout] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:214:6
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:215:6
[INFO] [stdout]     |
[INFO] [stdout] 215 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:216:6
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:257:69
[INFO] [stdout]     |
[INFO] [stdout] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:257:81
[INFO] [stdout]     |
[INFO] [stdout] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:263:69
[INFO] [stdout]     |
[INFO] [stdout] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:263:82
[INFO] [stdout]     |
[INFO] [stdout] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:330:7
[INFO] [stdout]     |
[INFO] [stdout] 330 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:331:7
[INFO] [stdout]     |
[INFO] [stdout] 331 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:332:7
[INFO] [stdout]     |
[INFO] [stdout] 332 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:336:6
[INFO] [stdout]     |
[INFO] [stdout] 336 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:337:6
[INFO] [stdout]     |
[INFO] [stdout] 337 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:341:6
[INFO] [stdout]     |
[INFO] [stdout] 341 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:343:6
[INFO] [stdout]     |
[INFO] [stdout] 343 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:355:41
[INFO] [stdout]     |
[INFO] [stdout] 355 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:356:35
[INFO] [stdout]     |
[INFO] [stdout] 356 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:362:6
[INFO] [stdout]     |
[INFO] [stdout] 362 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:363:6
[INFO] [stdout]     |
[INFO] [stdout] 363 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:376:44
[INFO] [stdout]     |
[INFO] [stdout] 376 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:377:44
[INFO] [stdout]     |
[INFO] [stdout] 377 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:379:25
[INFO] [stdout]     |
[INFO] [stdout] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:379:32
[INFO] [stdout]     |
[INFO] [stdout] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:469:6
[INFO] [stdout]     |
[INFO] [stdout] 469 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:470:6
[INFO] [stdout]     |
[INFO] [stdout] 470 |     let c_R = inner_product(l_right, l_left);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/util.rs:144:9
[INFO] [stdout]     |
[INFO] [stdout] 144 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/util.rs:145:9
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/util.rs:146:9
[INFO] [stdout]     |
[INFO] [stdout] 146 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/util.rs:147:9
[INFO] [stdout]     |
[INFO] [stdout] 147 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/util.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/util.rs:152:9
[INFO] [stdout]     |
[INFO] [stdout] 152 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/util.rs:153:9
[INFO] [stdout]     |
[INFO] [stdout] 153 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/util.rs:163:13
[INFO] [stdout]     |
[INFO] [stdout] 163 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/util.rs:168:13
[INFO] [stdout]     |
[INFO] [stdout] 168 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_bigint::BigInt`
[INFO] [stdout]  --> src/main.rs:2:5
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_bigint::BigInt;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `cuproof_verify`
[INFO] [stdout]  --> src/main.rs:5:23
[INFO] [stdout]   |
[INFO] [stdout] 5 | use cuproof::verify::{cuproof_verify, cuproof_verify_with_range};
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `Signed`
[INFO] [stdout]  --> src/setup.rs:2:18
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stdout]   |                  ^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_traits::Zero`
[INFO] [stdout]  --> src/range_proof.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use num_traits::Zero;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `util::*`
[INFO] [stdout]  --> src/verify.rs:1:13
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stdout]   |             ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_bigint::BigInt`
[INFO] [stdout]  --> src_256/main.rs:2:5
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_bigint::BigInt;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `Signed`
[INFO] [stdout]  --> src_256/setup.rs:2:18
[INFO] [stdout]   |
[INFO] [stdout] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stdout]   |                  ^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `num_traits::Zero`
[INFO] [stdout]  --> src_256/range_proof.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use num_traits::Zero;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `util::*`
[INFO] [stdout]  --> src_256/verify.rs:1:13
[INFO] [stdout]   |
[INFO] [stdout] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stdout]   |             ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::util::bigint_to_hex`
[INFO] [stdout]  --> src_256/evm.rs:2:5
[INFO] [stdout]   |
[INFO] [stdout] 2 | use crate::util::bigint_to_hex;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `bits`
[INFO] [stdout]   --> src/setup.rs:66:22
[INFO] [stdout]    |
[INFO] [stdout] 66 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C`
[INFO] [stdout]    --> src/range_proof.rs:155:7
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v1`
[INFO] [stdout]    --> src/range_proof.rs:156:7
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v2`
[INFO] [stdout]    --> src/range_proof.rs:157:7
[INFO] [stdout]     |
[INFO] [stdout] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `l0`
[INFO] [stdout]    --> src/range_proof.rs:182:6
[INFO] [stdout]     |
[INFO] [stdout] 182 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r0`
[INFO] [stdout]    --> src/range_proof.rs:183:6
[INFO] [stdout]     |
[INFO] [stdout] 183 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `final_proof`
[INFO] [stdout]    --> src/range_proof.rs:218:6
[INFO] [stdout]     |
[INFO] [stdout] 218 |     let final_proof = Cuproof {
[INFO] [stdout]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `g`
[INFO] [stdout]    --> src/range_proof.rs:277:146
[INFO] [stdout]     |
[INFO] [stdout] 277 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `h`
[INFO] [stdout]    --> src/range_proof.rs:277:158
[INFO] [stdout]     |
[INFO] [stdout] 277 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `n`
[INFO] [stdout]    --> src/range_proof.rs:277:170
[INFO] [stdout]     |
[INFO] [stdout] 277 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r`
[INFO] [stdout]    --> src/range_proof.rs:315:49
[INFO] [stdout]     |
[INFO] [stdout] 315 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stdout]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `bits`
[INFO] [stdout]   --> src_256/setup.rs:60:22
[INFO] [stdout]    |
[INFO] [stdout] 60 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `L` should have a snake case name
[INFO] [stdout]  --> src/range_proof.rs:7:6
[INFO] [stdout]   |
[INFO] [stdout] 7 |     pub L: Vec<BigInt>,  // Left commitments at each level
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `R` should have a snake case name
[INFO] [stdout]  --> src/range_proof.rs:8:6
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub R: Vec<BigInt>,  // Right commitments at each level
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:15:6
[INFO] [stdout]    |
[INFO] [stdout] 15 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:16:6
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:17:6
[INFO] [stdout]    |
[INFO] [stdout] 17 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:18:6
[INFO] [stdout]    |
[INFO] [stdout] 18 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:22:6
[INFO] [stdout]    |
[INFO] [stdout] 22 |     pub C: BigInt,  // Commitment to value v
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:23:6
[INFO] [stdout]    |
[INFO] [stdout] 23 |     pub C_v1: BigInt,  // Commitment to v1 = 4v - 4a + 1
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:24:6
[INFO] [stdout]    |
[INFO] [stdout] 24 |     pub C_v2: BigInt,  // Commitment to v2 = 4b - 4v + 1
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sL` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:42:6
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub sL: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sR` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:43:6
[INFO] [stdout]    |
[INFO] [stdout] 43 |     pub sR: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:61:6
[INFO] [stdout]    |
[INFO] [stdout] 61 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:62:6
[INFO] [stdout]    |
[INFO] [stdout] 62 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:63:6
[INFO] [stdout]    |
[INFO] [stdout] 63 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:64:6
[INFO] [stdout]    |
[INFO] [stdout] 64 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:97:6
[INFO] [stdout]    |
[INFO] [stdout] 97 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]   --> src/range_proof.rs:98:6
[INFO] [stdout]    |
[INFO] [stdout] 98 |     let c_R = inner_product(l_right, r_left);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:101:6
[INFO] [stdout]     |
[INFO] [stdout] 101 |     let r_L = random_bigint(256);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:102:6
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let r_R = random_bigint(256);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:103:6
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:104:6
[INFO] [stdout]     |
[INFO] [stdout] 104 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:115:28
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:145:6
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:149:6
[INFO] [stdout]     |
[INFO] [stdout] 149 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:150:6
[INFO] [stdout]     |
[INFO] [stdout] 150 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:152:6
[INFO] [stdout]     |
[INFO] [stdout] 152 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:155:7
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:156:7
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:157:7
[INFO] [stdout]     |
[INFO] [stdout] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:165:41
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:166:35
[INFO] [stdout]     |
[INFO] [stdout] 166 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:186:6
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:187:6
[INFO] [stdout]     |
[INFO] [stdout] 187 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:195:15
[INFO] [stdout]     |
[INFO] [stdout] 195 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:197:15
[INFO] [stdout]     |
[INFO] [stdout] 197 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:204:25
[INFO] [stdout]     |
[INFO] [stdout] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:204:32
[INFO] [stdout]     |
[INFO] [stdout] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:214:6
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:215:6
[INFO] [stdout]     |
[INFO] [stdout] 215 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:216:6
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:257:69
[INFO] [stdout]     |
[INFO] [stdout] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:257:81
[INFO] [stdout]     |
[INFO] [stdout] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:263:69
[INFO] [stdout]     |
[INFO] [stdout] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:263:82
[INFO] [stdout]     |
[INFO] [stdout] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:330:7
[INFO] [stdout]     |
[INFO] [stdout] 330 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:331:7
[INFO] [stdout]     |
[INFO] [stdout] 331 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:332:7
[INFO] [stdout]     |
[INFO] [stdout] 332 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:336:6
[INFO] [stdout]     |
[INFO] [stdout] 336 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:337:6
[INFO] [stdout]     |
[INFO] [stdout] 337 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:341:6
[INFO] [stdout]     |
[INFO] [stdout] 341 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:343:6
[INFO] [stdout]     |
[INFO] [stdout] 343 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:355:41
[INFO] [stdout]     |
[INFO] [stdout] 355 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:356:35
[INFO] [stdout]     |
[INFO] [stdout] 356 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:362:6
[INFO] [stdout]     |
[INFO] [stdout] 362 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:363:6
[INFO] [stdout]     |
[INFO] [stdout] 363 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:376:44
[INFO] [stdout]     |
[INFO] [stdout] 376 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:377:44
[INFO] [stdout]     |
[INFO] [stdout] 377 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:379:25
[INFO] [stdout]     |
[INFO] [stdout] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:379:32
[INFO] [stdout]     |
[INFO] [stdout] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:469:6
[INFO] [stdout]     |
[INFO] [stdout] 469 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]    --> src/range_proof.rs:470:6
[INFO] [stdout]     |
[INFO] [stdout] 470 |     let c_R = inner_product(l_right, l_left);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src/util.rs:144:9
[INFO] [stdout]     |
[INFO] [stdout] 144 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src/util.rs:145:9
[INFO] [stdout]     |
[INFO] [stdout] 145 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src/util.rs:146:9
[INFO] [stdout]     |
[INFO] [stdout] 146 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src/util.rs:147:9
[INFO] [stdout]     |
[INFO] [stdout] 147 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src/util.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src/util.rs:152:9
[INFO] [stdout]     |
[INFO] [stdout] 152 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src/util.rs:153:9
[INFO] [stdout]     |
[INFO] [stdout] 153 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src/util.rs:163:13
[INFO] [stdout]     |
[INFO] [stdout] 163 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src/util.rs:168:13
[INFO] [stdout]     |
[INFO] [stdout] 168 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C`
[INFO] [stdout]    --> src_256/range_proof.rs:141:7
[INFO] [stdout]     |
[INFO] [stdout] 141 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v1`
[INFO] [stdout]    --> src_256/range_proof.rs:142:7
[INFO] [stdout]     |
[INFO] [stdout] 142 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `C_v2`
[INFO] [stdout]    --> src_256/range_proof.rs:143:7
[INFO] [stdout]     |
[INFO] [stdout] 143 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `l0`
[INFO] [stdout]    --> src_256/range_proof.rs:165:6
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r0`
[INFO] [stdout]    --> src_256/range_proof.rs:166:6
[INFO] [stdout]     |
[INFO] [stdout] 166 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `final_proof`
[INFO] [stdout]    --> src_256/range_proof.rs:197:6
[INFO] [stdout]     |
[INFO] [stdout] 197 |     let final_proof = Cuproof {
[INFO] [stdout]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `g`
[INFO] [stdout]    --> src_256/range_proof.rs:251:146
[INFO] [stdout]     |
[INFO] [stdout] 251 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `h`
[INFO] [stdout]    --> src_256/range_proof.rs:251:158
[INFO] [stdout]     |
[INFO] [stdout] 251 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `n`
[INFO] [stdout]    --> src_256/range_proof.rs:251:170
[INFO] [stdout]     |
[INFO] [stdout] 251 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stdout]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `r`
[INFO] [stdout]    --> src_256/range_proof.rs:265:49
[INFO] [stdout]     |
[INFO] [stdout] 265 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stdout]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `trusted_setup` is never used
[INFO] [stdout]   --> src_256/setup.rs:60:8
[INFO] [stdout]    |
[INFO] [stdout] 60 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stdout]    |        ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct `ProverState` is never constructed
[INFO] [stdout]   --> src_256/range_proof.rs:34:12
[INFO] [stdout]    |
[INFO] [stdout] 34 | pub struct ProverState {
[INFO] [stdout]    |            ^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct `VerifierState` is never constructed
[INFO] [stdout]   --> src_256/range_proof.rs:56:12
[INFO] [stdout]    |
[INFO] [stdout] 56 | pub struct VerifierState {
[INFO] [stdout]    |            ^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_prove_step1` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:118:8
[INFO] [stdout]     |
[INFO] [stdout] 118 | pub fn interactive_prove_step1(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (ProverState,...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_prove_step2` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:164:8
[INFO] [stdout]     |
[INFO] [stdout] 164 | pub fn interactive_prove_step2(prover_state: &ProverState, y: &BigInt, z: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, ...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_prove_step3` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:174:8
[INFO] [stdout]     |
[INFO] [stdout] 174 | pub fn interactive_prove_step3(prover_state: &ProverState, x: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, BigInt, BigI...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step1` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:219:8
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub fn interactive_verify_step1(g: &BigInt, h: &BigInt, n: &BigInt) -> (VerifierState, BigInt, BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step2` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:234:8
[INFO] [stdout]     |
[INFO] [stdout] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step3` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:239:8
[INFO] [stdout]     |
[INFO] [stdout] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_step4` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:244:8
[INFO] [stdout]     |
[INFO] [stdout] 244 | pub fn interactive_verify_step4(verifier_state: &mut VerifierState, g: &BigInt, n: &BigInt) -> BigInt {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `interactive_verify_final` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:251:8
[INFO] [stdout]     |
[INFO] [stdout] 251 | pub fn interactive_verify_final(verifier_state: &VerifierState, t_hat: &BigInt, mu: &BigInt, tau_x: &BigInt, a_final: &BigInt, b_fi...
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `inner_product_argument` is never used
[INFO] [stdout]    --> src_256/range_proof.rs:388:8
[INFO] [stdout]     |
[INFO] [stdout] 388 | pub fn inner_product_argument(l_vec: &[BigInt], r_vec: &[BigInt], g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, BigInt) {
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `L` should have a snake case name
[INFO] [stdout]  --> src_256/range_proof.rs:7:6
[INFO] [stdout]   |
[INFO] [stdout] 7 |     pub L: Vec<BigInt>,
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `R` should have a snake case name
[INFO] [stdout]  --> src_256/range_proof.rs:8:6
[INFO] [stdout]   |
[INFO] [stdout] 8 |     pub R: Vec<BigInt>,
[INFO] [stdout]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:15:6
[INFO] [stdout]    |
[INFO] [stdout] 15 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:16:6
[INFO] [stdout]    |
[INFO] [stdout] 16 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:17:6
[INFO] [stdout]    |
[INFO] [stdout] 17 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:18:6
[INFO] [stdout]    |
[INFO] [stdout] 18 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:22:6
[INFO] [stdout]    |
[INFO] [stdout] 22 |     pub C: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v1` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:23:6
[INFO] [stdout]    |
[INFO] [stdout] 23 |     pub C_v1: BigInt,
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `C_v2` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:24:6
[INFO] [stdout]    |
[INFO] [stdout] 24 |     pub C_v2: BigInt,
[INFO] [stdout]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sL` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:41:6
[INFO] [stdout]    |
[INFO] [stdout] 41 |     pub sL: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `sR` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:42:6
[INFO] [stdout]    |
[INFO] [stdout] 42 |     pub sR: Vec<BigInt>,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `A` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:60:6
[INFO] [stdout]    |
[INFO] [stdout] 60 |     pub A: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `S` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:61:6
[INFO] [stdout]    |
[INFO] [stdout] 61 |     pub S: BigInt,
[INFO] [stdout]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T1` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:62:6
[INFO] [stdout]    |
[INFO] [stdout] 62 |     pub T1: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: structure field `T2` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:63:6
[INFO] [stdout]    |
[INFO] [stdout] 63 |     pub T2: BigInt,
[INFO] [stdout]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:93:6
[INFO] [stdout]    |
[INFO] [stdout] 93 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:94:6
[INFO] [stdout]    |
[INFO] [stdout] 94 |     let c_R = inner_product(l_right, r_left);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_L` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:96:6
[INFO] [stdout]    |
[INFO] [stdout] 96 |     let r_L = random_bigint(256);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `r_R` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:97:6
[INFO] [stdout]    |
[INFO] [stdout] 97 |     let r_R = random_bigint(256);
[INFO] [stdout]    |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:98:6
[INFO] [stdout]    |
[INFO] [stdout] 98 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R` should have a snake case name
[INFO] [stdout]   --> src_256/range_proof.rs:99:6
[INFO] [stdout]    |
[INFO] [stdout] 99 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stdout]    |         ^ help: convert the identifier to snake case: `r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:110:17
[INFO] [stdout]     |
[INFO] [stdout] 110 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:110:28
[INFO] [stdout]     |
[INFO] [stdout] 110 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stdout]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:133:6
[INFO] [stdout]     |
[INFO] [stdout] 133 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:136:6
[INFO] [stdout]     |
[INFO] [stdout] 136 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:137:6
[INFO] [stdout]     |
[INFO] [stdout] 137 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:139:6
[INFO] [stdout]     |
[INFO] [stdout] 139 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:141:7
[INFO] [stdout]     |
[INFO] [stdout] 141 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:142:7
[INFO] [stdout]     |
[INFO] [stdout] 142 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:143:7
[INFO] [stdout]     |
[INFO] [stdout] 143 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:149:41
[INFO] [stdout]     |
[INFO] [stdout] 149 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:150:35
[INFO] [stdout]     |
[INFO] [stdout] 150 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:168:6
[INFO] [stdout]     |
[INFO] [stdout] 168 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:169:6
[INFO] [stdout]     |
[INFO] [stdout] 169 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:176:15
[INFO] [stdout]     |
[INFO] [stdout] 176 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:178:15
[INFO] [stdout]     |
[INFO] [stdout] 178 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stdout]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:184:25
[INFO] [stdout]     |
[INFO] [stdout] 184 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:184:32
[INFO] [stdout]     |
[INFO] [stdout] 184 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:193:6
[INFO] [stdout]     |
[INFO] [stdout] 193 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:194:6
[INFO] [stdout]     |
[INFO] [stdout] 194 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:195:6
[INFO] [stdout]     |
[INFO] [stdout] 195 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:234:69
[INFO] [stdout]     |
[INFO] [stdout] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:234:81
[INFO] [stdout]     |
[INFO] [stdout] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stdout]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:239:69
[INFO] [stdout]     |
[INFO] [stdout] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:239:82
[INFO] [stdout]     |
[INFO] [stdout] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stdout]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:277:7
[INFO] [stdout]     |
[INFO] [stdout] 277 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stdout]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:278:7
[INFO] [stdout]     |
[INFO] [stdout] 278 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:279:7
[INFO] [stdout]     |
[INFO] [stdout] 279 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stdout]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sL` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:283:6
[INFO] [stdout]     |
[INFO] [stdout] 283 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sR` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:284:6
[INFO] [stdout]     |
[INFO] [stdout] 284 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:287:6
[INFO] [stdout]     |
[INFO] [stdout] 287 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:289:6
[INFO] [stdout]     |
[INFO] [stdout] 289 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:298:41
[INFO] [stdout]     |
[INFO] [stdout] 298 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stdout]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:299:35
[INFO] [stdout]     |
[INFO] [stdout] 299 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stdout]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:304:6
[INFO] [stdout]     |
[INFO] [stdout] 304 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:305:6
[INFO] [stdout]     |
[INFO] [stdout] 305 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sLi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:314:44
[INFO] [stdout]     |
[INFO] [stdout] 314 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `sRi` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:315:44
[INFO] [stdout]     |
[INFO] [stdout] 315 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stdout]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:317:25
[INFO] [stdout]     |
[INFO] [stdout] 317 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:317:32
[INFO] [stdout]     |
[INFO] [stdout] 317 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stdout]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_L` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:399:6
[INFO] [stdout]     |
[INFO] [stdout] 399 |     let c_L = inner_product(l_left, r_right);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `c_R` should have a snake case name
[INFO] [stdout]    --> src_256/range_proof.rs:400:6
[INFO] [stdout]     |
[INFO] [stdout] 400 |     let c_R = inner_product(l_right, l_left);
[INFO] [stdout]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `A` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:110:9
[INFO] [stdout]     |
[INFO] [stdout] 110 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `S` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:111:9
[INFO] [stdout]     |
[INFO] [stdout] 111 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:112:9
[INFO] [stdout]     |
[INFO] [stdout] 112 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:113:9
[INFO] [stdout]     |
[INFO] [stdout] 113 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:117:9
[INFO] [stdout]     |
[INFO] [stdout] 117 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v1` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `C_v2` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:119:9
[INFO] [stdout]     |
[INFO] [stdout] 119 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stdout]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `L_vec` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `R_vec` should have a snake case name
[INFO] [stdout]    --> src_256/util.rs:133:13
[INFO] [stdout]     |
[INFO] [stdout] 133 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stdout]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1_recalc` should have a snake case name
[INFO] [stdout]   --> src_256/evm.rs:38:9
[INFO] [stdout]    |
[INFO] [stdout] 38 |     let T1_recalc = pedersen_commit(g, h, &t1_mod, &tau1_mod, n);
[INFO] [stdout]    |         ^^^^^^^^^ help: convert the identifier to snake case: `t1_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2_recalc` should have a snake case name
[INFO] [stdout]   --> src_256/evm.rs:39:9
[INFO] [stdout]    |
[INFO] [stdout] 39 |     let T2_recalc = pedersen_commit(g, h, &t2_mod, &tau2_mod, n);
[INFO] [stdout]    |         ^^^^^^^^^ help: convert the identifier to snake case: `t2_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T1_recalc` should have a snake case name
[INFO] [stdout]    --> src_256/evm.rs:137:9
[INFO] [stdout]     |
[INFO] [stdout] 137 |     let T1_recalc = pedersen_commit(g, h, &t1_mod, &tau1_mod, n);
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `t1_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `T2_recalc` should have a snake case name
[INFO] [stdout]    --> src_256/evm.rs:138:9
[INFO] [stdout]     |
[INFO] [stdout] 138 |     let T2_recalc = pedersen_commit(g, h, &t2_mod, &tau2_mod, n);
[INFO] [stdout]     |         ^^^^^^^^^ help: convert the identifier to snake case: `t2_recalc`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 20.90s
[INFO] running `Command { std: "docker" "inspect" "eff7b14bec38404f93e5700ea8f4206e3bcc5ba9e4abf36709329df3d316e097", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "eff7b14bec38404f93e5700ea8f4206e3bcc5ba9e4abf36709329df3d316e097", kill_on_drop: false }`
[INFO] [stdout] eff7b14bec38404f93e5700ea8f4206e3bcc5ba9e4abf36709329df3d316e097
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc1/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:aa71247004a7fa38d13ec170f48f06cdedf5bc50b2a8645e56ed7e992e6fa513" "/opt/rustwide/cargo-home/bin/cargo" "+2fd6efc32704647e64d3d646d21c4c68eae100e4" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] 33ee0a37e7db1f9069aae4dbad409a2da4f12b0daca6982e0f7a87d24aa938be
[INFO] running `Command { std: "docker" "start" "-a" "33ee0a37e7db1f9069aae4dbad409a2da4f12b0daca6982e0f7a87d24aa938be", kill_on_drop: false }`
[INFO] [stderr] warning: unused import: `Signed`
[INFO] [stderr]  --> src/setup.rs:2:18
[INFO] [stderr]   |
[INFO] [stderr] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stderr]   |                  ^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `num_traits::Zero`
[INFO] [stderr]  --> src/range_proof.rs:3:5
[INFO] [stderr]   |
[INFO] [stderr] 3 | use num_traits::Zero;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `util::*`
[INFO] [stderr]  --> src/verify.rs:1:13
[INFO] [stderr]   |
[INFO] [stderr] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stderr]   |             ^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `bits`
[INFO] [stderr]   --> src/setup.rs:66:22
[INFO] [stderr]    |
[INFO] [stderr] 66 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stderr]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `C`
[INFO] [stderr]    --> src/range_proof.rs:155:7
[INFO] [stderr]     |
[INFO] [stderr] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stderr]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `C_v1`
[INFO] [stderr]    --> src/range_proof.rs:156:7
[INFO] [stderr]     |
[INFO] [stderr] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stderr]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `C_v2`
[INFO] [stderr]    --> src/range_proof.rs:157:7
[INFO] [stderr]     |
[INFO] [stderr] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stderr]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `l0`
[INFO] [stderr]    --> src/range_proof.rs:182:6
[INFO] [stderr]     |
[INFO] [stderr] 182 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `r0`
[INFO] [stderr]    --> src/range_proof.rs:183:6
[INFO] [stderr]     |
[INFO] [stderr] 183 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `final_proof`
[INFO] [stderr]    --> src/range_proof.rs:218:6
[INFO] [stderr]     |
[INFO] [stderr] 218 |     let final_proof = Cuproof {
[INFO] [stderr]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `g`
[INFO] [stderr]    --> src/range_proof.rs:277:146
[INFO] [stderr]     |
[INFO] [stderr] 277 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stderr]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `h`
[INFO] [stderr]    --> src/range_proof.rs:277:158
[INFO] [stderr]     |
[INFO] [stderr] 277 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stderr]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `n`
[INFO] [stderr]    --> src/range_proof.rs:277:170
[INFO] [stderr]     |
[INFO] [stderr] 277 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stderr]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `r`
[INFO] [stderr]    --> src/range_proof.rs:315:49
[INFO] [stderr]     |
[INFO] [stderr] 315 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stderr]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `L` should have a snake case name
[INFO] [stderr]  --> src/range_proof.rs:7:6
[INFO] [stderr]   |
[INFO] [stderr] 7 |     pub L: Vec<BigInt>,  // Left commitments at each level
[INFO] [stderr]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `R` should have a snake case name
[INFO] [stderr]  --> src/range_proof.rs:8:6
[INFO] [stderr]   |
[INFO] [stderr] 8 |     pub R: Vec<BigInt>,  // Right commitments at each level
[INFO] [stderr]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `A` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:15:6
[INFO] [stderr]    |
[INFO] [stderr] 15 |     pub A: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `S` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:16:6
[INFO] [stderr]    |
[INFO] [stderr] 16 |     pub S: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T1` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:17:6
[INFO] [stderr]    |
[INFO] [stderr] 17 |     pub T1: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T2` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:18:6
[INFO] [stderr]    |
[INFO] [stderr] 18 |     pub T2: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `C` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:22:6
[INFO] [stderr]    |
[INFO] [stderr] 22 |     pub C: BigInt,  // Commitment to value v
[INFO] [stderr]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `C_v1` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:23:6
[INFO] [stderr]    |
[INFO] [stderr] 23 |     pub C_v1: BigInt,  // Commitment to v1 = 4v - 4a + 1
[INFO] [stderr]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `C_v2` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:24:6
[INFO] [stderr]    |
[INFO] [stderr] 24 |     pub C_v2: BigInt,  // Commitment to v2 = 4b - 4v + 1
[INFO] [stderr]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `sL` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:42:6
[INFO] [stderr]    |
[INFO] [stderr] 42 |     pub sL: Vec<BigInt>,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `sR` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:43:6
[INFO] [stderr]    |
[INFO] [stderr] 43 |     pub sR: Vec<BigInt>,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `A` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:61:6
[INFO] [stderr]    |
[INFO] [stderr] 61 |     pub A: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `S` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:62:6
[INFO] [stderr]    |
[INFO] [stderr] 62 |     pub S: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T1` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:63:6
[INFO] [stderr]    |
[INFO] [stderr] 63 |     pub T1: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T2` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:64:6
[INFO] [stderr]    |
[INFO] [stderr] 64 |     pub T2: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_L` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:97:6
[INFO] [stderr]    |
[INFO] [stderr] 97 |     let c_L = inner_product(l_left, r_right);
[INFO] [stderr]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_R` should have a snake case name
[INFO] [stderr]   --> src/range_proof.rs:98:6
[INFO] [stderr]    |
[INFO] [stderr] 98 |     let c_R = inner_product(l_right, r_left);
[INFO] [stderr]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `r_L` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:101:6
[INFO] [stderr]     |
[INFO] [stderr] 101 |     let r_L = random_bigint(256);
[INFO] [stderr]     |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `r_R` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:102:6
[INFO] [stderr]     |
[INFO] [stderr] 102 |     let r_R = random_bigint(256);
[INFO] [stderr]     |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:103:6
[INFO] [stderr]     |
[INFO] [stderr] 103 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:104:6
[INFO] [stderr]     |
[INFO] [stderr] 104 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:115:17
[INFO] [stderr]     |
[INFO] [stderr] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stderr]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:115:28
[INFO] [stderr]     |
[INFO] [stderr] 115 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stderr]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:145:6
[INFO] [stderr]     |
[INFO] [stderr] 145 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sL` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:149:6
[INFO] [stderr]     |
[INFO] [stderr] 149 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sR` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:150:6
[INFO] [stderr]     |
[INFO] [stderr] 150 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:152:6
[INFO] [stderr]     |
[INFO] [stderr] 152 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:155:7
[INFO] [stderr]     |
[INFO] [stderr] 155 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stderr]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:156:7
[INFO] [stderr]     |
[INFO] [stderr] 156 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:157:7
[INFO] [stderr]     |
[INFO] [stderr] 157 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:165:41
[INFO] [stderr]     |
[INFO] [stderr] 165 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stderr]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:166:35
[INFO] [stderr]     |
[INFO] [stderr] 166 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stderr]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:186:6
[INFO] [stderr]     |
[INFO] [stderr] 186 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:187:6
[INFO] [stderr]     |
[INFO] [stderr] 187 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:195:15
[INFO] [stderr]     |
[INFO] [stderr] 195 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stderr]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:197:15
[INFO] [stderr]     |
[INFO] [stderr] 197 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stderr]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:204:25
[INFO] [stderr]     |
[INFO] [stderr] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:204:32
[INFO] [stderr]     |
[INFO] [stderr] 204 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:214:6
[INFO] [stderr]     |
[INFO] [stderr] 214 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:215:6
[INFO] [stderr]     |
[INFO] [stderr] 215 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:216:6
[INFO] [stderr]     |
[INFO] [stderr] 216 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:257:69
[INFO] [stderr]     |
[INFO] [stderr] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stderr]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:257:81
[INFO] [stderr]     |
[INFO] [stderr] 257 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stderr]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:263:69
[INFO] [stderr]     |
[INFO] [stderr] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stderr]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:263:82
[INFO] [stderr]     |
[INFO] [stderr] 263 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stderr]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:330:7
[INFO] [stderr]     |
[INFO] [stderr] 330 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stderr]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:331:7
[INFO] [stderr]     |
[INFO] [stderr] 331 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:332:7
[INFO] [stderr]     |
[INFO] [stderr] 332 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sL` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:336:6
[INFO] [stderr]     |
[INFO] [stderr] 336 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sR` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:337:6
[INFO] [stderr]     |
[INFO] [stderr] 337 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:341:6
[INFO] [stderr]     |
[INFO] [stderr] 341 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:343:6
[INFO] [stderr]     |
[INFO] [stderr] 343 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:355:41
[INFO] [stderr]     |
[INFO] [stderr] 355 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stderr]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:356:35
[INFO] [stderr]     |
[INFO] [stderr] 356 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stderr]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:362:6
[INFO] [stderr]     |
[INFO] [stderr] 362 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:363:6
[INFO] [stderr]     |
[INFO] [stderr] 363 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:376:44
[INFO] [stderr]     |
[INFO] [stderr] 376 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stderr]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:377:44
[INFO] [stderr]     |
[INFO] [stderr] 377 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stderr]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:379:25
[INFO] [stderr]     |
[INFO] [stderr] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:379:32
[INFO] [stderr]     |
[INFO] [stderr] 379 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_L` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:469:6
[INFO] [stderr]     |
[INFO] [stderr] 469 |     let c_L = inner_product(l_left, r_right);
[INFO] [stderr]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_R` should have a snake case name
[INFO] [stderr]    --> src/range_proof.rs:470:6
[INFO] [stderr]     |
[INFO] [stderr] 470 |     let c_R = inner_product(l_right, l_left);
[INFO] [stderr]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src/util.rs:144:9
[INFO] [stderr]     |
[INFO] [stderr] 144 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src/util.rs:145:9
[INFO] [stderr]     |
[INFO] [stderr] 145 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src/util.rs:146:9
[INFO] [stderr]     |
[INFO] [stderr] 146 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src/util.rs:147:9
[INFO] [stderr]     |
[INFO] [stderr] 147 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src/util.rs:151:9
[INFO] [stderr]     |
[INFO] [stderr] 151 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src/util.rs:152:9
[INFO] [stderr]     |
[INFO] [stderr] 152 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src/util.rs:153:9
[INFO] [stderr]     |
[INFO] [stderr] 153 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src/util.rs:163:13
[INFO] [stderr]     |
[INFO] [stderr] 163 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stderr]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src/util.rs:168:13
[INFO] [stderr]     |
[INFO] [stderr] 168 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stderr]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: `cuproof` (lib) generated 85 warnings (run `cargo fix --lib -p cuproof` to apply 14 suggestions)
[INFO] [stderr] warning: unused import: `num_bigint::BigInt`
[INFO] [stderr]  --> src/main.rs:2:5
[INFO] [stderr]   |
[INFO] [stderr] 2 | use num_bigint::BigInt;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `cuproof_verify`
[INFO] [stderr]  --> src/main.rs:5:23
[INFO] [stderr]   |
[INFO] [stderr] 5 | use cuproof::verify::{cuproof_verify, cuproof_verify_with_range};
[INFO] [stderr]   |                       ^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `num_bigint::BigInt`
[INFO] [stderr]  --> src_256/main.rs:2:5
[INFO] [stderr]   |
[INFO] [stderr] 2 | use num_bigint::BigInt;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `Signed`
[INFO] [stderr]  --> src_256/setup.rs:2:18
[INFO] [stderr]   |
[INFO] [stderr] 2 | use num_traits::{Signed, Zero, One};
[INFO] [stderr]   |                  ^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `num_traits::Zero`
[INFO] [stderr]  --> src_256/range_proof.rs:3:5
[INFO] [stderr]   |
[INFO] [stderr] 3 | use num_traits::Zero;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `util::*`
[INFO] [stderr]  --> src_256/verify.rs:1:13
[INFO] [stderr]   |
[INFO] [stderr] 1 | use crate::{util::*, fiat_shamir::*, commitment::*};
[INFO] [stderr]   |             ^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::util::bigint_to_hex`
[INFO] [stderr]  --> src_256/evm.rs:2:5
[INFO] [stderr]   |
[INFO] [stderr] 2 | use crate::util::bigint_to_hex;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `bits`
[INFO] [stderr]   --> src_256/setup.rs:60:22
[INFO] [stderr]    |
[INFO] [stderr] 60 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stderr]    |                      ^^^^ help: if this is intentional, prefix it with an underscore: `_bits`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `C`
[INFO] [stderr]    --> src_256/range_proof.rs:141:7
[INFO] [stderr]     |
[INFO] [stderr] 141 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stderr]     |          ^ help: if this is intentional, prefix it with an underscore: `_C`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `C_v1`
[INFO] [stderr]    --> src_256/range_proof.rs:142:7
[INFO] [stderr]     |
[INFO] [stderr] 142 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stderr]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `C_v2`
[INFO] [stderr]    --> src_256/range_proof.rs:143:7
[INFO] [stderr]     |
[INFO] [stderr] 143 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stderr]     |          ^^^^ help: if this is intentional, prefix it with an underscore: `_C_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `l0`
[INFO] [stderr]    --> src_256/range_proof.rs:165:6
[INFO] [stderr]     |
[INFO] [stderr] 165 |     let l0 = prover_state.l0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: if this is intentional, prefix it with an underscore: `_l0`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `r0`
[INFO] [stderr]    --> src_256/range_proof.rs:166:6
[INFO] [stderr]     |
[INFO] [stderr] 166 |     let r0 = prover_state.r0.iter().map(|di| z * di + y).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: if this is intentional, prefix it with an underscore: `_r0`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `final_proof`
[INFO] [stderr]    --> src_256/range_proof.rs:197:6
[INFO] [stderr]     |
[INFO] [stderr] 197 |     let final_proof = Cuproof {
[INFO] [stderr]     |         ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_final_proof`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `g`
[INFO] [stderr]    --> src_256/range_proof.rs:251:146
[INFO] [stderr]     |
[INFO] [stderr] 251 | ...al: &BigInt, b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stderr]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_g`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `h`
[INFO] [stderr]    --> src_256/range_proof.rs:251:158
[INFO] [stderr]     |
[INFO] [stderr] 251 | ... b_final: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stderr]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_h`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `n`
[INFO] [stderr]    --> src_256/range_proof.rs:251:170
[INFO] [stderr]     |
[INFO] [stderr] 251 | ...igInt, g: &BigInt, h: &BigInt, n: &BigInt) -> bool {
[INFO] [stderr]     |                                   ^ help: if this is intentional, prefix it with an underscore: `_n`
[INFO] [stderr] 
[INFO] [stderr] warning: unused variable: `r`
[INFO] [stderr]    --> src_256/range_proof.rs:265:49
[INFO] [stderr]     |
[INFO] [stderr] 265 | pub fn cuproof_prove_with_dimension(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt, dimension: ...
[INFO] [stderr]     |                                                 ^ help: if this is intentional, prefix it with an underscore: `_r`
[INFO] [stderr] 
[INFO] [stderr] warning: function `trusted_setup` is never used
[INFO] [stderr]   --> src_256/setup.rs:60:8
[INFO] [stderr]    |
[INFO] [stderr] 60 | pub fn trusted_setup(bits: usize) -> (BigInt, BigInt, BigInt) {
[INFO] [stderr]    |        ^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: struct `ProverState` is never constructed
[INFO] [stderr]   --> src_256/range_proof.rs:34:12
[INFO] [stderr]    |
[INFO] [stderr] 34 | pub struct ProverState {
[INFO] [stderr]    |            ^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: struct `VerifierState` is never constructed
[INFO] [stderr]   --> src_256/range_proof.rs:56:12
[INFO] [stderr]    |
[INFO] [stderr] 56 | pub struct VerifierState {
[INFO] [stderr]    |            ^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_prove_step1` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:118:8
[INFO] [stderr]     |
[INFO] [stderr] 118 | pub fn interactive_prove_step1(v: &BigInt, r: &BigInt, a: &BigInt, b: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (ProverState,...
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_prove_step2` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:164:8
[INFO] [stderr]     |
[INFO] [stderr] 164 | pub fn interactive_prove_step2(prover_state: &ProverState, y: &BigInt, z: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, ...
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_prove_step3` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:174:8
[INFO] [stderr]     |
[INFO] [stderr] 174 | pub fn interactive_prove_step3(prover_state: &ProverState, x: &BigInt, g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, BigInt, BigI...
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_verify_step1` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:219:8
[INFO] [stderr]     |
[INFO] [stderr] 219 | pub fn interactive_verify_step1(g: &BigInt, h: &BigInt, n: &BigInt) -> (VerifierState, BigInt, BigInt) {
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_verify_step2` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:234:8
[INFO] [stderr]     |
[INFO] [stderr] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_verify_step3` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:239:8
[INFO] [stderr]     |
[INFO] [stderr] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_verify_step4` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:244:8
[INFO] [stderr]     |
[INFO] [stderr] 244 | pub fn interactive_verify_step4(verifier_state: &mut VerifierState, g: &BigInt, n: &BigInt) -> BigInt {
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `interactive_verify_final` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:251:8
[INFO] [stderr]     |
[INFO] [stderr] 251 | pub fn interactive_verify_final(verifier_state: &VerifierState, t_hat: &BigInt, mu: &BigInt, tau_x: &BigInt, a_final: &BigInt, b_fi...
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: function `inner_product_argument` is never used
[INFO] [stderr]    --> src_256/range_proof.rs:388:8
[INFO] [stderr]     |
[INFO] [stderr] 388 | pub fn inner_product_argument(l_vec: &[BigInt], r_vec: &[BigInt], g: &BigInt, h: &BigInt, n: &BigInt) -> (BigInt, BigInt) {
[INFO] [stderr]     |        ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `L` should have a snake case name
[INFO] [stderr]  --> src_256/range_proof.rs:7:6
[INFO] [stderr]   |
[INFO] [stderr] 7 |     pub L: Vec<BigInt>,
[INFO] [stderr]   |         ^ help: convert the identifier to snake case: `l`
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `R` should have a snake case name
[INFO] [stderr]  --> src_256/range_proof.rs:8:6
[INFO] [stderr]   |
[INFO] [stderr] 8 |     pub R: Vec<BigInt>,
[INFO] [stderr]   |         ^ help: convert the identifier to snake case: `r`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `A` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:15:6
[INFO] [stderr]    |
[INFO] [stderr] 15 |     pub A: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `S` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:16:6
[INFO] [stderr]    |
[INFO] [stderr] 16 |     pub S: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T1` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:17:6
[INFO] [stderr]    |
[INFO] [stderr] 17 |     pub T1: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T2` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:18:6
[INFO] [stderr]    |
[INFO] [stderr] 18 |     pub T2: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `C` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:22:6
[INFO] [stderr]    |
[INFO] [stderr] 22 |     pub C: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `C_v1` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:23:6
[INFO] [stderr]    |
[INFO] [stderr] 23 |     pub C_v1: BigInt,
[INFO] [stderr]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `C_v2` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:24:6
[INFO] [stderr]    |
[INFO] [stderr] 24 |     pub C_v2: BigInt,
[INFO] [stderr]    |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `sL` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:41:6
[INFO] [stderr]    |
[INFO] [stderr] 41 |     pub sL: Vec<BigInt>,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `sR` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:42:6
[INFO] [stderr]    |
[INFO] [stderr] 42 |     pub sR: Vec<BigInt>,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `A` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:60:6
[INFO] [stderr]    |
[INFO] [stderr] 60 |     pub A: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `S` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:61:6
[INFO] [stderr]    |
[INFO] [stderr] 61 |     pub S: BigInt,
[INFO] [stderr]    |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T1` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:62:6
[INFO] [stderr]    |
[INFO] [stderr] 62 |     pub T1: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: structure field `T2` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:63:6
[INFO] [stderr]    |
[INFO] [stderr] 63 |     pub T2: BigInt,
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_L` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:93:6
[INFO] [stderr]    |
[INFO] [stderr] 93 |     let c_L = inner_product(l_left, r_right);
[INFO] [stderr]    |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_R` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:94:6
[INFO] [stderr]    |
[INFO] [stderr] 94 |     let c_R = inner_product(l_right, r_left);
[INFO] [stderr]    |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `r_L` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:96:6
[INFO] [stderr]    |
[INFO] [stderr] 96 |     let r_L = random_bigint(256);
[INFO] [stderr]    |         ^^^ help: convert the identifier to snake case: `r_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `r_R` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:97:6
[INFO] [stderr]    |
[INFO] [stderr] 97 |     let r_R = random_bigint(256);
[INFO] [stderr]    |         ^^^ help: convert the identifier to snake case: `r_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:98:6
[INFO] [stderr]    |
[INFO] [stderr] 98 |     let L = pedersen_commit(g, h, &c_L, &r_L, n);
[INFO] [stderr]    |         ^ help: convert the identifier to snake case: `l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R` should have a snake case name
[INFO] [stderr]   --> src_256/range_proof.rs:99:6
[INFO] [stderr]    |
[INFO] [stderr] 99 |     let R = pedersen_commit(g, h, &c_R, &r_R, n);
[INFO] [stderr]    |         ^ help: convert the identifier to snake case: `r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:110:17
[INFO] [stderr]     |
[INFO] [stderr] 110 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stderr]     |                    ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:110:28
[INFO] [stderr]     |
[INFO] [stderr] 110 |     let (a, b, mut L_vec, mut R_vec) = inner_product_argument_recursive(&l_new, &r_new, g, h, n, level + 1);
[INFO] [stderr]     |                               ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:133:6
[INFO] [stderr]     |
[INFO] [stderr] 133 |     let A = pedersen_commit(g, h, &d.iter().sum::<BigInt>(), &alpha, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sL` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:136:6
[INFO] [stderr]     |
[INFO] [stderr] 136 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sR` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:137:6
[INFO] [stderr]     |
[INFO] [stderr] 137 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:139:6
[INFO] [stderr]     |
[INFO] [stderr] 139 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:141:7
[INFO] [stderr]     |
[INFO] [stderr] 141 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stderr]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:142:7
[INFO] [stderr]     |
[INFO] [stderr] 142 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:143:7
[INFO] [stderr]     |
[INFO] [stderr] 143 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:149:41
[INFO] [stderr]     |
[INFO] [stderr] 149 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stderr]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:150:35
[INFO] [stderr]     |
[INFO] [stderr] 150 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stderr]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:168:6
[INFO] [stderr]     |
[INFO] [stderr] 168 |     let T1 = pedersen_commit(g, h, &prover_state.t1, &prover_state.tau1, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:169:6
[INFO] [stderr]     |
[INFO] [stderr] 169 |     let T2 = pedersen_commit(g, h, &prover_state.t2, &prover_state.tau2, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:176:15
[INFO] [stderr]     |
[INFO] [stderr] 176 |         .map(|(l0i, sLi)| l0i + &(sLi * x)).collect::<Vec<_>>();
[INFO] [stderr]     |                     ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:178:15
[INFO] [stderr]     |
[INFO] [stderr] 178 |         .map(|(r0i, sRi)| r0i + &(sRi * x)).collect::<Vec<_>>();
[INFO] [stderr]     |                     ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:184:25
[INFO] [stderr]     |
[INFO] [stderr] 184 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:184:32
[INFO] [stderr]     |
[INFO] [stderr] 184 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:193:6
[INFO] [stderr]     |
[INFO] [stderr] 193 |     let C = pedersen_commit(g, h, &prover_state.v, &prover_state.r, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:194:6
[INFO] [stderr]     |
[INFO] [stderr] 194 |     let C_v1 = pedersen_commit(g, h, &prover_state.v1, &random_bigint(256), n);
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:195:6
[INFO] [stderr]     |
[INFO] [stderr] 195 |     let C_v2 = pedersen_commit(g, h, &prover_state.v2, &random_bigint(256), n);
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:234:69
[INFO] [stderr]     |
[INFO] [stderr] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stderr]     |                                                                     ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:234:81
[INFO] [stderr]     |
[INFO] [stderr] 234 | pub fn interactive_verify_step2(verifier_state: &mut VerifierState, A: &BigInt, S: &BigInt) {
[INFO] [stderr]     |                                                                                 ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:239:69
[INFO] [stderr]     |
[INFO] [stderr] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stderr]     |                                                                     ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:239:82
[INFO] [stderr]     |
[INFO] [stderr] 239 | pub fn interactive_verify_step3(verifier_state: &mut VerifierState, T1: &BigInt, T2: &BigInt) {
[INFO] [stderr]     |                                                                                  ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:277:7
[INFO] [stderr]     |
[INFO] [stderr] 277 |     let (C, _r_v) = commit_value(g, h, v, n);
[INFO] [stderr]     |          ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:278:7
[INFO] [stderr]     |
[INFO] [stderr] 278 |     let (C_v1, _r_v1) = commit_value(g, h, &v1, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:279:7
[INFO] [stderr]     |
[INFO] [stderr] 279 |     let (C_v2, _r_v2) = commit_value(g, h, &v2, n);
[INFO] [stderr]     |          ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sL` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:283:6
[INFO] [stderr]     |
[INFO] [stderr] 283 |     let sL = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sR` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:284:6
[INFO] [stderr]     |
[INFO] [stderr] 284 |     let sR = (0..dimension).map(|_| random_bigint(256)).collect::<Vec<_>>();
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `s_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:287:6
[INFO] [stderr]     |
[INFO] [stderr] 287 |     let A = pedersen_commit(g, h, &sum_d, &alpha, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:289:6
[INFO] [stderr]     |
[INFO] [stderr] 289 |     let S = pedersen_commit(g, h, &sum_s, &rho, n);
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:298:41
[INFO] [stderr]     |
[INFO] [stderr] 298 |     let t1 = l0.iter().zip(&sR).map(|(l0i, sRi)| l0i * sRi).sum::<BigInt>()
[INFO] [stderr]     |                                            ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:299:35
[INFO] [stderr]     |
[INFO] [stderr] 299 |         + r0.iter().zip(&sL).map(|(r0i, sLi)| r0i * sLi).sum::<BigInt>();
[INFO] [stderr]     |                                         ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:304:6
[INFO] [stderr]     |
[INFO] [stderr] 304 |     let T1 = pedersen_commit(g, h, &t1, &tau1, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:305:6
[INFO] [stderr]     |
[INFO] [stderr] 305 |     let T2 = pedersen_commit(g, h, &t2, &tau2, n);
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sLi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:314:44
[INFO] [stderr]     |
[INFO] [stderr] 314 |     let l_vec = l0.iter().zip(&sL).map(|(l0i, sLi)| l0i + &(sLi * &x)).collect::<Vec<_>>();
[INFO] [stderr]     |                                               ^^^ help: convert the identifier to snake case: `s_li`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `sRi` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:315:44
[INFO] [stderr]     |
[INFO] [stderr] 315 |     let r_vec = r0.iter().zip(&sR).map(|(r0i, sRi)| r0i + &(sRi * &x)).collect::<Vec<_>>();
[INFO] [stderr]     |                                               ^^^ help: convert the identifier to snake case: `s_ri`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:317:25
[INFO] [stderr]     |
[INFO] [stderr] 317 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                            ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:317:32
[INFO] [stderr]     |
[INFO] [stderr] 317 |     let (a_final, b_final, L_vec, R_vec) = inner_product_argument_recursive(&l_vec, &r_vec, g, h, n, 0);
[INFO] [stderr]     |                                   ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_L` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:399:6
[INFO] [stderr]     |
[INFO] [stderr] 399 |     let c_L = inner_product(l_left, r_right);
[INFO] [stderr]     |         ^^^ help: convert the identifier to snake case: `c_l`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `c_R` should have a snake case name
[INFO] [stderr]    --> src_256/range_proof.rs:400:6
[INFO] [stderr]     |
[INFO] [stderr] 400 |     let c_R = inner_product(l_right, l_left);
[INFO] [stderr]     |         ^^^ help: convert the identifier to snake case: `c_r`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `A` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:110:9
[INFO] [stderr]     |
[INFO] [stderr] 110 |     let A = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^ help: convert the identifier to snake case: `a`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `S` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:111:9
[INFO] [stderr]     |
[INFO] [stderr] 111 |     let S = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `s`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:112:9
[INFO] [stderr]     |
[INFO] [stderr] 112 |     let T1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:113:9
[INFO] [stderr]     |
[INFO] [stderr] 113 |     let T2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:117:9
[INFO] [stderr]     |
[INFO] [stderr] 117 |     let C = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^ help: convert the identifier to snake case (notice the capitalization): `c`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v1` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:118:9
[INFO] [stderr]     |
[INFO] [stderr] 118 |     let C_v1 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v1`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `C_v2` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:119:9
[INFO] [stderr]     |
[INFO] [stderr] 119 |     let C_v2 = hex_to_bigint_strict(&take(&mut i)?)?;
[INFO] [stderr]     |         ^^^^ help: convert the identifier to snake case (notice the capitalization): `c_v2`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `L_vec` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:128:13
[INFO] [stderr]     |
[INFO] [stderr] 128 |     let mut L_vec = Vec::with_capacity(l_len);
[INFO] [stderr]     |             ^^^^^ help: convert the identifier to snake case: `l_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `R_vec` should have a snake case name
[INFO] [stderr]    --> src_256/util.rs:133:13
[INFO] [stderr]     |
[INFO] [stderr] 133 |     let mut R_vec = Vec::with_capacity(r_len);
[INFO] [stderr]     |             ^^^^^ help: convert the identifier to snake case: `r_vec`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1_recalc` should have a snake case name
[INFO] [stderr]   --> src_256/evm.rs:38:9
[INFO] [stderr]    |
[INFO] [stderr] 38 |     let T1_recalc = pedersen_commit(g, h, &t1_mod, &tau1_mod, n);
[INFO] [stderr]    |         ^^^^^^^^^ help: convert the identifier to snake case: `t1_recalc`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2_recalc` should have a snake case name
[INFO] [stderr]   --> src_256/evm.rs:39:9
[INFO] [stderr]    |
[INFO] [stderr] 39 |     let T2_recalc = pedersen_commit(g, h, &t2_mod, &tau2_mod, n);
[INFO] [stderr]    |         ^^^^^^^^^ help: convert the identifier to snake case: `t2_recalc`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T1_recalc` should have a snake case name
[INFO] [stderr]    --> src_256/evm.rs:137:9
[INFO] [stderr]     |
[INFO] [stderr] 137 |     let T1_recalc = pedersen_commit(g, h, &t1_mod, &tau1_mod, n);
[INFO] [stderr]     |         ^^^^^^^^^ help: convert the identifier to snake case: `t1_recalc`
[INFO] [stderr] 
[INFO] [stderr] warning: variable `T2_recalc` should have a snake case name
[INFO] [stderr]    --> src_256/evm.rs:138:9
[INFO] [stderr]     |
[INFO] [stderr] 138 |     let T2_recalc = pedersen_commit(g, h, &t2_mod, &tau2_mod, n);
[INFO] [stderr]     |         ^^^^^^^^^ help: convert the identifier to snake case: `t2_recalc`
[INFO] [stderr] 
[INFO] [stderr] warning: `cuproof` (lib test) generated 85 warnings (85 duplicates)
[INFO] [stderr] warning: `cuproof` (bin "cuproof" test) generated 2 warnings (run `cargo fix --bin "cuproof" -p cuproof --tests` to apply 2 suggestions)
[INFO] [stderr] warning: `cuproof` (bin "cuproof256" test) generated 103 warnings (run `cargo fix --bin "cuproof256" -p cuproof --tests` to apply 16 suggestions)
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 0.28s
[INFO] [stderr]      Running unittests src/lib.rs (/opt/rustwide/target/debug/deps/cuproof-ce79cf7ad8a4595c)
[INFO] [stdout] 
[INFO] [stdout] running 12 tests
[INFO] [stdout] test lagrange::tests::small_numbers_have_valid_decompositions ... ok
[INFO] [stdout] test fiat_shamir::tests::fs_deterministic_and_order_sensitive ... ok
[INFO] [stdout] test commitment::tests::pedersen_basic_properties ... ok
[INFO] [stdout] test util::tests::hex_roundtrip_and_inner_product ... ok
[INFO] [stdout] test range_proof::tests::prove_smoke_nonzero_size ... ok
[INFO] [stdout] test setup::tests::fast_setup_generates_valid_params ... ok
[INFO] [stdout] test verify::tests::verify_pass_and_tamper_fail ... ok
[INFO] [stdout] test benchmark::tests::test_benchmark_small_range ... ok
[INFO] [stdout] test tests::test_basic_range_proof ... ok
[INFO] [stdout] test benchmark::tests::test_benchmark_multiple_ranges ... ok
[INFO] [stdout] test tests::test_multiple_values ... ok
[INFO] [stdout] test tests::test_different_ranges ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 12 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 59.07s
[INFO] [stdout] 
[INFO] [stderr]      Running unittests src/main.rs (/opt/rustwide/target/debug/deps/cuproof-5c59f4568bb2716e)
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stderr]      Running unittests src_256/main.rs (/opt/rustwide/target/debug/deps/cuproof256-15e01b845cfc1c9f)
[INFO] [stdout] 
[INFO] [stdout] running 12 tests
[INFO] [stdout] test lagrange::tests::small_numbers_have_valid_decompositions ... ok
[INFO] [stdout] test fiat_shamir::tests::fs_deterministic_and_order_sensitive ... ok
[INFO] [stdout] test util::tests::hex_roundtrip_and_inner_product ... ok
[INFO] [stdout] test setup::tests::setup_256_generates_valid_params ... ok
[INFO] [stdout] test commitment::tests::pedersen_basic_properties ... ok
[INFO] [stdout] test setup::tests::fast_setup_generates_valid_params ... ok
[INFO] [stdout] test verify::tests::verify_save_and_load ... FAILED
[INFO] [stdout] test range_proof::tests::prove_smoke_nonzero_size ... ok
[INFO] [stdout] test verify::tests::verify_pass_and_tamper_fail ... ok
[INFO] [stdout] test evm::tests::test_serialize_proof ... ok
[INFO] [stdout] test benchmark::tests::test_benchmark_small_range ... ok
[INFO] [stdout] test benchmark::tests::test_benchmark_multiple_ranges ... ok
[INFO] [stderr] error: test failed, to rerun pass `--bin cuproof256`
[INFO] [stdout] 
[INFO] [stdout] failures:
[INFO] [stdout] 
[INFO] [stdout] ---- verify::tests::verify_save_and_load stdout ----
[INFO] [stdout] 
[INFO] [stdout] thread 'verify::tests::verify_save_and_load' (42) panicked at src_256/verify.rs:108:52:
[INFO] [stdout] called `Result::unwrap()` on an `Err` value: Os { code: 30, kind: ReadOnlyFilesystem, message: "Read-only file system" }
[INFO] [stdout] stack backtrace:
[INFO] [stdout]    0:     0x5a69b6539fa2 - std[716c9a7a72e5c14e]::backtrace_rs::backtrace::libunwind::trace
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/../../backtrace/src/backtrace/libunwind.rs:117:9
[INFO] [stdout]    1:     0x5a69b6539fa2 - std[716c9a7a72e5c14e]::backtrace_rs::backtrace::trace_unsynchronized::<std[716c9a7a72e5c14e]::sys::backtrace::_print_fmt::{closure#1}>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/../../backtrace/src/backtrace/mod.rs:66:14
[INFO] [stdout]    2:     0x5a69b6539fa2 - std[716c9a7a72e5c14e]::sys::backtrace::_print_fmt
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/sys/backtrace.rs:74:9
[INFO] [stdout]    3:     0x5a69b6539fa2 - <<std[716c9a7a72e5c14e]::sys::backtrace::BacktraceLock>::print::DisplayBacktrace as core[c5ed12ab89cc536a]::fmt::Display>::fmt
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/sys/backtrace.rs:44:26
[INFO] [stdout]    4:     0x5a69b654efda - <core[c5ed12ab89cc536a]::fmt::rt::Argument>::fmt
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/fmt/rt.rs:152:76
[INFO] [stdout]    5:     0x5a69b654efda - core[c5ed12ab89cc536a]::fmt::write
[INFO] [stdout]    6:     0x5a69b653edd6 - std[716c9a7a72e5c14e]::io::default_write_fmt::<alloc[9c68fdf4f4f29218]::vec::Vec<u8>>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/io/mod.rs:639:11
[INFO] [stdout]    7:     0x5a69b653edd6 - <alloc[9c68fdf4f4f29218]::vec::Vec<u8> as std[716c9a7a72e5c14e]::io::Write>::write_fmt
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/io/mod.rs:1994:13
[INFO] [stdout]    8:     0x5a69b651770f - <std[716c9a7a72e5c14e]::sys::backtrace::BacktraceLock>::print
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/sys/backtrace.rs:47:9
[INFO] [stdout]    9:     0x5a69b651770f - std[716c9a7a72e5c14e]::panicking::default_hook::{closure#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:292:27
[INFO] [stdout]   10:     0x5a69b6531ee9 - std[716c9a7a72e5c14e]::panicking::default_hook
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:316:9
[INFO] [stdout]   11:     0x5a69b649d7be - <alloc[9c68fdf4f4f29218]::boxed::Box<dyn for<'a, 'b> core[c5ed12ab89cc536a]::ops::function::Fn<(&'a std[716c9a7a72e5c14e]::panic::PanicHookInfo<'b>,), Output = ()> + core[c5ed12ab89cc536a]::marker::Sync + core[c5ed12ab89cc536a]::marker::Send> as core[c5ed12ab89cc536a]::ops::function::Fn<(&std[716c9a7a72e5c14e]::panic::PanicHookInfo,)>>::call
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/alloc/src/boxed.rs:2220:9
[INFO] [stdout]   12:     0x5a69b649d7be - test[64760d2bdea328cc]::test_main_with_exit_callback::<test[64760d2bdea328cc]::test_main::{closure#0}>::{closure#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/test/src/lib.rs:145:21
[INFO] [stdout]   13:     0x5a69b65320a2 - <alloc[9c68fdf4f4f29218]::boxed::Box<dyn for<'a, 'b> core[c5ed12ab89cc536a]::ops::function::Fn<(&'a std[716c9a7a72e5c14e]::panic::PanicHookInfo<'b>,), Output = ()> + core[c5ed12ab89cc536a]::marker::Sync + core[c5ed12ab89cc536a]::marker::Send> as core[c5ed12ab89cc536a]::ops::function::Fn<(&std[716c9a7a72e5c14e]::panic::PanicHookInfo,)>>::call
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/alloc/src/boxed.rs:2220:9
[INFO] [stdout]   14:     0x5a69b65320a2 - std[716c9a7a72e5c14e]::panicking::panic_with_hook
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:833:13
[INFO] [stdout]   15:     0x5a69b65177c8 - std[716c9a7a72e5c14e]::panicking::panic_handler::{closure#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:698:13
[INFO] [stdout]   16:     0x5a69b650efb9 - std[716c9a7a72e5c14e]::sys::backtrace::__rust_end_short_backtrace::<std[716c9a7a72e5c14e]::panicking::panic_handler::{closure#0}, !>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/sys/backtrace.rs:182:18
[INFO] [stdout]   17:     0x5a69b651861d - __rustc[4f0b026143eab78e]::rust_begin_unwind
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:689:5
[INFO] [stdout]   18:     0x5a69b654f6ec - core[c5ed12ab89cc536a]::panicking::panic_fmt
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/panicking.rs:80:14
[INFO] [stdout]   19:     0x5a69b654f462 - core[c5ed12ab89cc536a]::result::unwrap_failed
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/result.rs:1867:5
[INFO] [stdout]   20:     0x5a69b646a8bd - <core[c5ed12ab89cc536a]::result::Result<(), std[716c9a7a72e5c14e]::io::error::Error>>::unwrap
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/result.rs:1233:23
[INFO] [stdout]   21:     0x5a69b646a8bd - cuproof256[c5a7fefb062a5f34]::verify::tests::verify_save_and_load
[INFO] [stdout]                                at /opt/rustwide/workdir/src_256/verify.rs:108:52
[INFO] [stdout]   22:     0x5a69b6465847 - cuproof256[c5a7fefb062a5f34]::verify::tests::verify_save_and_load::{closure#0}
[INFO] [stdout]                                at /opt/rustwide/workdir/src_256/verify.rs:100:30
[INFO] [stdout]   23:     0x5a69b648dba6 - <cuproof256[c5a7fefb062a5f34]::verify::tests::verify_save_and_load::{closure#0} as core[c5ed12ab89cc536a]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   24:     0x5a69b6491b6b - <fn() -> core[c5ed12ab89cc536a]::result::Result<(), alloc[9c68fdf4f4f29218]::string::String> as core[c5ed12ab89cc536a]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   25:     0x5a69b6491b6b - test[64760d2bdea328cc]::__rust_begin_short_backtrace::<core[c5ed12ab89cc536a]::result::Result<(), alloc[9c68fdf4f4f29218]::string::String>, fn() -> core[c5ed12ab89cc536a]::result::Result<(), alloc[9c68fdf4f4f29218]::string::String>>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/test/src/lib.rs:663:18
[INFO] [stdout]   26:     0x5a69b649e3ca - test[64760d2bdea328cc]::run_test_in_process::{closure#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/test/src/lib.rs:686:74
[INFO] [stdout]   27:     0x5a69b649e3ca - <core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<test[64760d2bdea328cc]::run_test_in_process::{closure#0}> as core[c5ed12ab89cc536a]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/panic/unwind_safe.rs:274:9
[INFO] [stdout]   28:     0x5a69b649e3ca - std[716c9a7a72e5c14e]::panicking::catch_unwind::do_call::<core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<test[64760d2bdea328cc]::run_test_in_process::{closure#0}>, core[c5ed12ab89cc536a]::result::Result<(), alloc[9c68fdf4f4f29218]::string::String>>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:581:40
[INFO] [stdout]   29:     0x5a69b649e3ca - std[716c9a7a72e5c14e]::panicking::catch_unwind::<core[c5ed12ab89cc536a]::result::Result<(), alloc[9c68fdf4f4f29218]::string::String>, core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<test[64760d2bdea328cc]::run_test_in_process::{closure#0}>>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:544:19
[INFO] [stdout]   30:     0x5a69b649e3ca - std[716c9a7a72e5c14e]::panic::catch_unwind::<core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<test[64760d2bdea328cc]::run_test_in_process::{closure#0}>, core[c5ed12ab89cc536a]::result::Result<(), alloc[9c68fdf4f4f29218]::string::String>>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panic.rs:359:14
[INFO] [stdout]   31:     0x5a69b649e3ca - test[64760d2bdea328cc]::run_test_in_process
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/test/src/lib.rs:686:27
[INFO] [stdout]   32:     0x5a69b649e3ca - test[64760d2bdea328cc]::run_test::{closure#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/test/src/lib.rs:607:43
[INFO] [stdout]   33:     0x5a69b6498894 - test[64760d2bdea328cc]::run_test::{closure#1}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/test/src/lib.rs:637:41
[INFO] [stdout]   34:     0x5a69b6498894 - std[716c9a7a72e5c14e]::sys::backtrace::__rust_begin_short_backtrace::<test[64760d2bdea328cc]::run_test::{closure#1}, ()>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/sys/backtrace.rs:166:18
[INFO] [stdout]   35:     0x5a69b64a0ec2 - std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked::<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/thread/lifecycle.rs:91:13
[INFO] [stdout]   36:     0x5a69b64a0ec2 - <core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}> as core[c5ed12ab89cc536a]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/panic/unwind_safe.rs:274:9
[INFO] [stdout]   37:     0x5a69b64a0ec2 - std[716c9a7a72e5c14e]::panicking::catch_unwind::do_call::<core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}>, ()>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:581:40
[INFO] [stdout]   38:     0x5a69b64a0ec2 - std[716c9a7a72e5c14e]::panicking::catch_unwind::<(), core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}>>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panicking.rs:544:19
[INFO] [stdout]   39:     0x5a69b64a0ec2 - std[716c9a7a72e5c14e]::panic::catch_unwind::<core[c5ed12ab89cc536a]::panic::unwind_safe::AssertUnwindSafe<std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1}::{closure#0}>, ()>
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/panic.rs:359:14
[INFO] [stdout]   40:     0x5a69b64a0ec2 - std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked::<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/thread/lifecycle.rs:89:26
[INFO] [stdout]   41:     0x5a69b64a0ec2 - <std[716c9a7a72e5c14e]::thread::lifecycle::spawn_unchecked<test[64760d2bdea328cc]::run_test::{closure#1}, ()>::{closure#1} as core[c5ed12ab89cc536a]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0}
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   42:     0x5a69b65394af - <alloc[9c68fdf4f4f29218]::boxed::Box<dyn core[c5ed12ab89cc536a]::ops::function::FnOnce<(), Output = ()> + core[c5ed12ab89cc536a]::marker::Send> as core[c5ed12ab89cc536a]::ops::function::FnOnce<()>>::call_once
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/alloc/src/boxed.rs:2206:9
[INFO] [stdout]   43:     0x5a69b65394af - <std[716c9a7a72e5c14e]::sys::thread::unix::Thread>::new::thread_start
[INFO] [stdout]                                at /rustc/2fd6efc32704647e64d3d646d21c4c68eae100e4/library/std/src/sys/thread/unix.rs:119:17
[INFO] [stdout]   44:     0x7f7f569c4aa4 - <unknown>
[INFO] [stdout]   45:     0x7f7f56a51a64 - clone
[INFO] [stdout]   46:                0x0 - <unknown>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] failures:
[INFO] [stdout]     verify::tests::verify_save_and_load
[INFO] [stdout] 
[INFO] [stdout] test result: FAILED. 11 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 4.52s
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "33ee0a37e7db1f9069aae4dbad409a2da4f12b0daca6982e0f7a87d24aa938be", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "33ee0a37e7db1f9069aae4dbad409a2da4f12b0daca6982e0f7a87d24aa938be", kill_on_drop: false }`
[INFO] [stdout] 33ee0a37e7db1f9069aae4dbad409a2da4f12b0daca6982e0f7a87d24aa938be
