[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 1.94.0 for beta-1.95-1
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaoKiet251%2FCuproof" "/workspace/builds/worker-3-tc1/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-3-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-3-tc1/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/CaoKiet251/Cuproof on toolchain 1.94.0
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.94.0" "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" "+1.94.0" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+1.94.0" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 4eaf54d0e83038825e887604fd2f3455c8bbba1ff31f85b58dd7b9c3e2fa0305
[INFO] running `Command { std: "docker" "start" "-a" "4eaf54d0e83038825e887604fd2f3455c8bbba1ff31f85b58dd7b9c3e2fa0305", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "4eaf54d0e83038825e887604fd2f3455c8bbba1ff31f85b58dd7b9c3e2fa0305", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "4eaf54d0e83038825e887604fd2f3455c8bbba1ff31f85b58dd7b9c3e2fa0305", kill_on_drop: false }`
[INFO] [stdout] 4eaf54d0e83038825e887604fd2f3455c8bbba1ff31f85b58dd7b9c3e2fa0305
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+1.94.0" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 7830041bab3d196a3a721b89a2c8574a1a1e7f9cd6dd9ea0a7709ed7e4e91256
[INFO] running `Command { std: "docker" "start" "-a" "7830041bab3d196a3a721b89a2c8574a1a1e7f9cd6dd9ea0a7709ed7e4e91256", kill_on_drop: false }`
[INFO] [stderr]    Compiling typenum v1.18.0
[INFO] [stderr]    Compiling libc v0.2.174
[INFO] [stderr]    Compiling zerocopy v0.8.26
[INFO] [stderr]    Compiling cfg-if v1.0.1
[INFO] [stderr]    Compiling generic-array v0.14.7
[INFO] [stderr]    Compiling num-integer v0.1.46
[INFO] [stderr]    Compiling getrandom v0.2.16
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling crypto-common v0.1.6
[INFO] [stderr]    Compiling block-buffer v0.10.4
[INFO] [stderr]    Compiling digest v0.10.7
[INFO] [stderr]    Compiling sha2 v0.10.9
[INFO] [stderr]    Compiling sha3 v0.10.8
[INFO] [stderr]    Compiling ppv-lite86 v0.2.21
[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 9.96s
[INFO] running `Command { std: "docker" "inspect" "7830041bab3d196a3a721b89a2c8574a1a1e7f9cd6dd9ea0a7709ed7e4e91256", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "7830041bab3d196a3a721b89a2c8574a1a1e7f9cd6dd9ea0a7709ed7e4e91256", kill_on_drop: false }`
[INFO] [stdout] 7830041bab3d196a3a721b89a2c8574a1a1e7f9cd6dd9ea0a7709ed7e4e91256
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+1.94.0" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] aa8b0a990c5ab700bbbb89046a0fe272d6ae9e65c63eaf37ace64f846d6c08ed
[INFO] running `Command { std: "docker" "start" "-a" "aa8b0a990c5ab700bbbb89046a0fe272d6ae9e65c63eaf37ace64f846d6c08ed", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.95
[INFO] [stderr]    Compiling libc v0.2.174
[INFO] [stderr]    Compiling unicode-ident v1.0.18
[INFO] [stderr]    Compiling serde v1.0.219
[INFO] [stderr]    Compiling serde_json v1.0.142
[INFO] [stderr]    Compiling either v1.15.0
[INFO] [stderr]    Compiling half v2.6.0
[INFO] [stderr]    Compiling plotters-backend v0.3.7
[INFO] [stderr]    Compiling clap_lex v0.7.5
[INFO] [stderr]    Compiling memchr v2.7.5
[INFO] [stderr]    Compiling ciborium-io v0.2.2
[INFO] [stderr]    Compiling regex-syntax v0.8.5
[INFO] [stderr]    Compiling anstyle v1.0.11
[INFO] [stderr]    Compiling rayon-core v1.12.1
[INFO] [stderr]    Compiling oorandom v11.1.5
[INFO] [stderr]    Compiling anes v0.1.6
[INFO] [stderr]    Compiling clap_builder v4.5.42
[INFO] [stderr]    Compiling plotters-svg v0.3.7
[INFO] [stderr]    Compiling ciborium-ll v0.2.2
[INFO] [stderr]    Compiling itertools v0.10.5
[INFO] [stderr]    Compiling plotters v0.3.7
[INFO] [stderr]    Compiling rayon v1.10.0
[INFO] [stderr]    Compiling quote v1.0.40
[INFO] [stderr]    Compiling syn v2.0.104
[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 criterion-plot v0.5.0
[INFO] [stderr]    Compiling regex-automata v0.4.9
[INFO] [stderr]    Compiling num-bigint v0.4.6
[INFO] [stderr]    Compiling clap v4.5.42
[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] [stderr]    Compiling regex v1.11.1
[INFO] [stderr]    Compiling serde_derive v1.0.219
[INFO] [stderr]    Compiling ciborium v0.2.2
[INFO] [stderr]    Compiling tinytemplate v1.2.1
[INFO] [stderr]    Compiling criterion v0.5.1
[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: `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/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: `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: 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: 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 31.34s
[INFO] running `Command { std: "docker" "inspect" "aa8b0a990c5ab700bbbb89046a0fe272d6ae9e65c63eaf37ace64f846d6c08ed", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "aa8b0a990c5ab700bbbb89046a0fe272d6ae9e65c63eaf37ace64f846d6c08ed", kill_on_drop: false }`
[INFO] [stdout] aa8b0a990c5ab700bbbb89046a0fe272d6ae9e65c63eaf37ace64f846d6c08ed
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:d429b63d4308055ea97f60fb1d3dfca48854a00942f1bd2ad806beaf015945ec" "/opt/rustwide/cargo-home/bin/cargo" "+1.94.0" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] ca905abed5b02c79517b029418021a2bdb542ae83d349ce30c64fede6a8f4d44
[INFO] running `Command { std: "docker" "start" "-a" "ca905abed5b02c79517b029418021a2bdb542ae83d349ce30c64fede6a8f4d44", 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_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] [stdout] 
[INFO] [stderr] warning: unused variable: `r0`
[INFO] [stdout] running 12 tests
[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] [stdout] test fiat_shamir::tests::fs_deterministic_and_order_sensitive ... ok
[INFO] [stderr]    |         ^^ help: convert the identifier to snake case: `t2`
[INFO] [stdout] test lagrange::tests::small_numbers_have_valid_decompositions ... ok
[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] [stdout] test util::tests::hex_roundtrip_and_inner_product ... ok
[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: 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: `cuproof` (lib test) generated 85 warnings (85 duplicates)
[INFO] [stderr] warning: `cuproof` (bin "cuproof256" test) generated 103 warnings (run `cargo fix --bin "cuproof256" -p cuproof --tests` to apply 16 suggestions)
[INFO] [stderr] warning: `cuproof` (bin "cuproof" test) generated 2 warnings (run `cargo fix --bin "cuproof" -p cuproof --tests` to apply 2 suggestions)
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 0.15s
[INFO] [stderr]      Running unittests src/lib.rs (/opt/rustwide/target/debug/deps/cuproof-d8b8d30d59021b92)
[INFO] [stdout] test setup::tests::fast_setup_generates_valid_params ... ok
[INFO] [stdout] test commitment::tests::pedersen_basic_properties ... ok
[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 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_different_ranges ... ok
[INFO] [stdout] test tests::test_multiple_values ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 12 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 28.37s
[INFO] [stdout] 
[INFO] [stderr]      Running unittests src/main.rs (/opt/rustwide/target/debug/deps/cuproof-b16e1fa24c09fae4)
[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-1c1758f1679de62a)
[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 verify::tests::verify_pass_and_tamper_fail ... ok
[INFO] [stdout] test range_proof::tests::prove_smoke_nonzero_size ... ok
[INFO] [stdout] test verify::tests::verify_save_and_load ... FAILED
[INFO] [stdout] test setup::tests::fast_setup_generates_valid_params ... 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] [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' (50) 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:     0x5560e7b56222 - std::backtrace_rs::backtrace::libunwind::trace::hff358a60abf734fc
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/../../backtrace/src/backtrace/libunwind.rs:117:9
[INFO] [stdout]    1:     0x5560e7b56222 - std::backtrace_rs::backtrace::trace_unsynchronized::h3b121f916dd95ec6
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/../../backtrace/src/backtrace/mod.rs:66:14
[INFO] [stdout]    2:     0x5560e7b56222 - std::sys::backtrace::_print_fmt::hde0a62ded68798e9
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/sys/backtrace.rs:74:9
[INFO] [stdout]    3:     0x5560e7b56222 - <std::sys::backtrace::BacktraceLock::print::DisplayBacktrace as core::fmt::Display>::fmt::h93773fc827e3113d
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/sys/backtrace.rs:44:26
[INFO] [stdout]    4:     0x5560e7b66c6a - core::fmt::rt::Argument::fmt::h01eff69902dad97f
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/fmt/rt.rs:152:76
[INFO] [stdout]    5:     0x5560e7b66c6a - core::fmt::write::hed7b5c73d82ecb7c
[INFO] [stdout]    6:     0x5560e7b24e16 - std::io::default_write_fmt::h2f696ff5b8bbaa4b
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/io/mod.rs:639:11
[INFO] [stdout]    7:     0x5560e7b24e16 - std::io::Write::write_fmt::h5e66814db8a9cfce
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/io/mod.rs:1994:13
[INFO] [stdout]    8:     0x5560e7b35709 - std::sys::backtrace::BacktraceLock::print::h8b1d6fcc5a56d1a3
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/sys/backtrace.rs:47:9
[INFO] [stdout]    9:     0x5560e7b35709 - std::panicking::default_hook::{{closure}}::h2be84df4f189ae36
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:292:27
[INFO] [stdout]   10:     0x5560e7b355a1 - std::panicking::default_hook::hf0ea8939246f43a9
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:316:9
[INFO] [stdout]   11:     0x5560e7ac97de - <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call::h02d35e3888986252
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/alloc/src/boxed.rs:2220:9
[INFO] [stdout]   12:     0x5560e7ac97de - test::test_main_with_exit_callback::{{closure}}::h939640a27d647173
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/test/src/lib.rs:145:21
[INFO] [stdout]   13:     0x5560e7b35982 - <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call::hc9df09ff391af3e7
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/alloc/src/boxed.rs:2220:9
[INFO] [stdout]   14:     0x5560e7b35982 - std::panicking::panic_with_hook::hb4bd9ac1123582a0
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:833:13
[INFO] [stdout]   15:     0x5560e7b357c8 - std::panicking::panic_handler::{{closure}}::hde00dd15f5637fe2
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:698:13
[INFO] [stdout]   16:     0x5560e7b30ce9 - std::sys::backtrace::__rust_end_short_backtrace::hb72197fa777c1785
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/sys/backtrace.rs:182:18
[INFO] [stdout]   17:     0x5560e7b18b8d - __rustc[4425a7e20b4c8619]::rust_begin_unwind
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:689:5
[INFO] [stdout]   18:     0x5560e7b6e12c - core::panicking::panic_fmt::ha59b517dd231f4da
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/panicking.rs:80:14
[INFO] [stdout]   19:     0x5560e7b6d912 - core::result::unwrap_failed::hf2d1f30a3ac850fc
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/result.rs:1867:5
[INFO] [stdout]   20:     0x5560e7a968ad - core::result::Result<T,E>::unwrap::h9e88858484a06a63
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/result.rs:1233:23
[INFO] [stdout]   21:     0x5560e7a968ad - cuproof256::verify::tests::verify_save_and_load::ha406919afa516d7b
[INFO] [stdout]                                at /opt/rustwide/workdir/src_256/verify.rs:108:52
[INFO] [stdout]   22:     0x5560e7a96f27 - cuproof256::verify::tests::verify_save_and_load::{{closure}}::hd64f21cbf84c9719
[INFO] [stdout]                                at /opt/rustwide/workdir/src_256/verify.rs:100:30
[INFO] [stdout]   23:     0x5560e7a9b276 - core::ops::function::FnOnce::call_once::h08251895ebaae9d0
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   24:     0x5560e7ac959b - core::ops::function::FnOnce::call_once::hddb3cd395c36bfbb
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   25:     0x5560e7ac959b - test::__rust_begin_short_backtrace::h0b6a7601d9750bfa
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/test/src/lib.rs:663:18
[INFO] [stdout]   26:     0x5560e7adcfaa - test::run_test_in_process::{{closure}}::h444209903f00b347
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/test/src/lib.rs:686:74
[INFO] [stdout]   27:     0x5560e7adcfaa - <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once::hfb3ba8f46e537649
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/panic/unwind_safe.rs:274:9
[INFO] [stdout]   28:     0x5560e7adcfaa - std::panicking::catch_unwind::do_call::h1672a45911fcf9dc
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:581:40
[INFO] [stdout]   29:     0x5560e7adcfaa - std::panicking::catch_unwind::h0fadaee22787a6dd
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:544:19
[INFO] [stdout]   30:     0x5560e7adcfaa - std::panic::catch_unwind::hc47ad190f2c8e188
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panic.rs:359:14
[INFO] [stdout]   31:     0x5560e7adcfaa - test::run_test_in_process::hcd7faaf934f29999
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/test/src/lib.rs:686:27
[INFO] [stdout]   32:     0x5560e7adcfaa - test::run_test::{{closure}}::hddc4550da4871867
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/test/src/lib.rs:607:43
[INFO] [stdout]   33:     0x5560e7ab7404 - test::run_test::{{closure}}::h98ae26689f13ed94
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/test/src/lib.rs:637:41
[INFO] [stdout]   34:     0x5560e7ab7404 - std::sys::backtrace::__rust_begin_short_backtrace::h3ec4d1f21ad44588
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/sys/backtrace.rs:166:18
[INFO] [stdout]   35:     0x5560e7abada2 - std::thread::lifecycle::spawn_unchecked::{{closure}}::{{closure}}::hd8bf2c73d479939f
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/thread/lifecycle.rs:91:13
[INFO] [stdout]   36:     0x5560e7abada2 - <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once::h3b4248f358af2491
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/panic/unwind_safe.rs:274:9
[INFO] [stdout]   37:     0x5560e7abada2 - std::panicking::catch_unwind::do_call::hda10a64f4b8daebe
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:581:40
[INFO] [stdout]   38:     0x5560e7abada2 - std::panicking::catch_unwind::h659e5ee8336ec8c7
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panicking.rs:544:19
[INFO] [stdout]   39:     0x5560e7abada2 - std::panic::catch_unwind::h9d4d66a538912c18
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/panic.rs:359:14
[INFO] [stdout]   40:     0x5560e7abada2 - std::thread::lifecycle::spawn_unchecked::{{closure}}::h7557906bb51d79f1
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/thread/lifecycle.rs:89:26
[INFO] [stdout]   41:     0x5560e7abada2 - core::ops::function::FnOnce::call_once{{vtable.shim}}::h9e460d1d7fc83d35
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   42:     0x5560e7b2becf - <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once::h61282da819d64ea9
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/alloc/src/boxed.rs:2206:9
[INFO] [stdout]   43:     0x5560e7b2becf - std::sys::thread::unix::Thread::new::thread_start::h982f9ea829d1b5fb
[INFO] [stdout]                                at /rustc/4a4ef493e3a1488c6e321570238084b38948f6db/library/std/src/sys/thread/unix.rs:127:17
[INFO] [stdout]   44:     0x74962bd4aaa4 - <unknown>
[INFO] [stdout]   45:     0x74962bdd7a64 - 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 3.45s
[INFO] [stdout] 
[INFO] [stderr] error: test failed, to rerun pass `--bin cuproof256`
[INFO] running `Command { std: "docker" "inspect" "ca905abed5b02c79517b029418021a2bdb542ae83d349ce30c64fede6a8f4d44", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "ca905abed5b02c79517b029418021a2bdb542ae83d349ce30c64fede6a8f4d44", kill_on_drop: false }`
[INFO] [stdout] ca905abed5b02c79517b029418021a2bdb542ae83d349ce30c64fede6a8f4d44
