[INFO] fetching crate starling 4.0.0...
[INFO] checking starling-4.0.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate starling 4.0.0 into /workspace/builds/worker-4-tc2/source
[INFO] started tweaking crates.io crate starling 4.0.0
[INFO] finished tweaking crates.io crate starling 4.0.0
[INFO] tweaked toml for crates.io crate starling 4.0.0 written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate starling 4.0.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate starling 4.0.0 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" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/target:/opt/rustwide/target:rw,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" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266
[INFO] running `Command { std: "docker" "start" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-w" "/opt/rustwide/workdir" "--user" "0:0" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.126
[INFO] [stderr]    Compiling serde v1.0.138
[INFO] [stderr]    Compiling semver v1.0.12
[INFO] [stderr]     Checking once_cell v1.12.0
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.9
[INFO] [stderr]    Compiling proc-macro2 v1.0.40
[INFO] [stderr]    Compiling memchr v2.5.0
[INFO] [stderr]    Compiling quote v1.0.20
[INFO] [stderr]     Checking crossbeam-utils v0.8.10
[INFO] [stderr]    Compiling unicode-ident v1.0.1
[INFO] [stderr]    Compiling num-traits v0.2.15
[INFO] [stderr]     Checking ryu v1.0.10
[INFO] [stderr]     Checking either v1.7.0
[INFO] [stderr]    Compiling syn v1.0.98
[INFO] [stderr]    Compiling serde_json v1.0.82
[INFO] [stderr]    Compiling rustc_version v0.4.0
[INFO] [stderr]     Checking crossbeam-channel v0.5.5
[INFO] [stderr]     Checking crossbeam-deque v0.8.1
[INFO] [stderr]    Compiling rayon v1.5.3
[INFO] [stderr]     Checking getrandom v0.2.7
[INFO] [stderr]     Checking num_cpus v1.13.1
[INFO] [stderr]     Checking itoa v1.0.2
[INFO] [stderr]    Compiling cast v0.2.7
[INFO] [stderr]    Compiling serde_derive v1.0.138
[INFO] [stderr]     Checking textwrap v0.11.0
[INFO] [stderr]     Checking plotters-svg v0.3.1
[INFO] [stderr]     Checking rayon-core v1.9.3
[INFO] [stderr]     Checking rand_core v0.6.3
[INFO] [stderr]     Checking csv-core v0.1.10
[INFO] [stderr]     Checking itertools v0.10.3
[INFO] [stderr]     Checking regex-syntax v0.6.26
[INFO] [stderr]     Checking ppv-lite86 v0.2.16
[INFO] [stderr]     Checking half v1.8.2
[INFO] [stderr]    Compiling starling v4.0.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking clap v2.34.0
[INFO] [stderr]     Checking plotters v0.3.1
[INFO] [stderr]     Checking rand_chacha v0.3.1
[INFO] [stderr]     Checking atty v0.2.14
[INFO] [stderr]     Checking criterion-plot v0.4.4
[INFO] [stderr]     Checking rand v0.8.5
[INFO] [stderr]     Checking regex v1.5.6
[INFO] [stderr]     Checking bstr v0.2.17
[INFO] [stderr]     Checking serde_cbor v0.11.2
[INFO] [stderr]     Checking csv v1.1.6
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking criterion v0.3.5
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]  --> examples/main.rs:7:15
[INFO] [stdout]   |
[INFO] [stdout] 7 |     let key = [0x00; 32].into();
[INFO] [stdout]   |               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]   = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]   |
[INFO] [stdout] 7 -     let key = [0x00; 32].into();
[INFO] [stdout] 7 +     let key = [0x00; 32];
[INFO] [stdout]   |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]   |
[INFO] [stdout] 7 -     let key = [0x00; 32].into();
[INFO] [stdout] 7 +     let key = <[u8; 32] as Into<_>>::into([0x00; 32]);
[INFO] [stdout]   |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (example "main") due to 1 previous error
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> benches/big_benches.rs:143:19
[INFO] [stdout]     |
[INFO] [stdout] 143 |         keys.push(key_value.into());
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 143 -         keys.push(key_value.into());
[INFO] [stdout] 143 +         keys.push(key_value);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 -         keys.push(key_value.into());
[INFO] [stdout] 143 +         keys.push(<[u8; 32] as Into<_>>::into(key_value));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (bench "big_benches") due to 1 previous error
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> benches/merkle_bit_benches.rs:140:19
[INFO] [stdout]     |
[INFO] [stdout] 140 |         keys.push(key_value.into());
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 140 -         keys.push(key_value.into());
[INFO] [stdout] 140 +         keys.push(key_value);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 140 -         keys.push(key_value.into());
[INFO] [stdout] 140 +         keys.push(<[u8; 32] as Into<_>>::into(key_value));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (bench "merkle_bit_benches") due to 1 previous error
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1081:14
[INFO] [stdout]      |
[INFO] [stdout] 1081 |         for &res in result.0 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout]      |
[INFO] [stdout]      = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1085:14
[INFO] [stdout]      |
[INFO] [stdout] 1085 |         for &res in result.1 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1111:14
[INFO] [stdout]      |
[INFO] [stdout] 1111 |         for &res in result.0 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1115:14
[INFO] [stdout]      |
[INFO] [stdout] 1115 |         for &res in result.1 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:935:38
[INFO] [stdout]     |
[INFO] [stdout] 935 |             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 935 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 935 +             let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 935 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 935 +             let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:947:42
[INFO] [stdout]     |
[INFO] [stdout] 947 |                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 947 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 947 +                 let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 947 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 947 +                 let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:955:38
[INFO] [stdout]     |
[INFO] [stdout] 955 |             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 955 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 955 +             let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 955 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 955 +             let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:968:42
[INFO] [stdout]     |
[INFO] [stdout] 968 |                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 968 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 968 +                 let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 968 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 968 +                 let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:976:38
[INFO] [stdout]     |
[INFO] [stdout] 976 |             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 976 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 976 +             let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 976 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 976 +             let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (lib test) due to 5 previous errors; 4 warnings emitted
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:192:23
[INFO] [stdout]     |
[INFO] [stdout] 192 |             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 192 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 192 +             keys.push([i << 5u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 192 +             keys.push(<[u8; 32] as Into<_>>::into([i << 5u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:214:23
[INFO] [stdout]     |
[INFO] [stdout] 214 |             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 214 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 214 +             keys.push([i << 5u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 214 +             keys.push(<[u8; 32] as Into<_>>::into([i << 5u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:237:23
[INFO] [stdout]     |
[INFO] [stdout] 237 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 237 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 237 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 237 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 237 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:261:23
[INFO] [stdout]     |
[INFO] [stdout] 261 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 261 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 261 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:285:23
[INFO] [stdout]     |
[INFO] [stdout] 285 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 285 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 285 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:309:23
[INFO] [stdout]     |
[INFO] [stdout] 309 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 309 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 309 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 309 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 309 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:332:23
[INFO] [stdout]     |
[INFO] [stdout] 332 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 332 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 332 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 332 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:364:23
[INFO] [stdout]     |
[INFO] [stdout] 364 |             keys.push(key.into());
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 364 -             keys.push(key.into());
[INFO] [stdout] 364 +             keys.push(key);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 -             keys.push(key.into());
[INFO] [stdout] 364 +             keys.push(<[u8; 32] as Into<_>>::into(key));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:394:23
[INFO] [stdout]     |
[INFO] [stdout] 394 |             keys.push(key.into());
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 394 -             keys.push(key.into());
[INFO] [stdout] 394 +             keys.push(key);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 394 -             keys.push(key.into());
[INFO] [stdout] 394 +             keys.push(<[u8; 32] as Into<_>>::into(key));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:421:25
[INFO] [stdout]     |
[INFO] [stdout] 421 |         let pop_key_d = [0x60u8; KEY_LEN].into(); // 0110_0000   96 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -         let pop_key_d = [0x60u8; KEY_LEN].into(); // 0110_0000   96 (Dec)
[INFO] [stdout] 421 +         let pop_key_d = [0x60u8; KEY_LEN]; // 0110_0000   96 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -         let pop_key_d = [0x60u8; KEY_LEN].into(); // 0110_0000   96 (Dec)
[INFO] [stdout] 421 +         let pop_key_d = <[u8; 32] as Into<_>>::into([0x60u8; KEY_LEN]); // 0110_0000   96 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:422:25
[INFO] [stdout]     |
[INFO] [stdout] 422 |         let pop_key_e = [0x68u8; KEY_LEN].into(); // 0110_1000  104 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 422 -         let pop_key_e = [0x68u8; KEY_LEN].into(); // 0110_1000  104 (Dec)
[INFO] [stdout] 422 +         let pop_key_e = [0x68u8; KEY_LEN]; // 0110_1000  104 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 -         let pop_key_e = [0x68u8; KEY_LEN].into(); // 0110_1000  104 (Dec)
[INFO] [stdout] 422 +         let pop_key_e = <[u8; 32] as Into<_>>::into([0x68u8; KEY_LEN]); // 0110_1000  104 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:423:25
[INFO] [stdout]     |
[INFO] [stdout] 423 |         let pop_key_i = [0x80u8; KEY_LEN].into(); // 1000_0000  128 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 423 -         let pop_key_i = [0x80u8; KEY_LEN].into(); // 1000_0000  128 (Dec)
[INFO] [stdout] 423 +         let pop_key_i = [0x80u8; KEY_LEN]; // 1000_0000  128 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 -         let pop_key_i = [0x80u8; KEY_LEN].into(); // 1000_0000  128 (Dec)
[INFO] [stdout] 423 +         let pop_key_i = <[u8; 32] as Into<_>>::into([0x80u8; KEY_LEN]); // 1000_0000  128 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:424:25
[INFO] [stdout]     |
[INFO] [stdout] 424 |         let pop_key_o = [0xF0u8; KEY_LEN].into(); // 1111_0000  240 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 424 -         let pop_key_o = [0xF0u8; KEY_LEN].into(); // 1111_0000  240 (Dec)
[INFO] [stdout] 424 +         let pop_key_o = [0xF0u8; KEY_LEN]; // 1111_0000  240 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 -         let pop_key_o = [0xF0u8; KEY_LEN].into(); // 1111_0000  240 (Dec)
[INFO] [stdout] 424 +         let pop_key_o = <[u8; 32] as Into<_>>::into([0xF0u8; KEY_LEN]); // 1111_0000  240 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:443:21
[INFO] [stdout]     |
[INFO] [stdout] 443 |         let key_a = [0x00u8; KEY_LEN].into(); // 0000_0000     0 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 443 -         let key_a = [0x00u8; KEY_LEN].into(); // 0000_0000     0 (Dec)
[INFO] [stdout] 443 +         let key_a = [0x00u8; KEY_LEN]; // 0000_0000     0 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 443 -         let key_a = [0x00u8; KEY_LEN].into(); // 0000_0000     0 (Dec)
[INFO] [stdout] 443 +         let key_a = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]); // 0000_0000     0 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:444:21
[INFO] [stdout]     |
[INFO] [stdout] 444 |         let key_b = [0x40u8; KEY_LEN].into(); // 0100_0000    64 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 444 -         let key_b = [0x40u8; KEY_LEN].into(); // 0100_0000    64 (Dec)
[INFO] [stdout] 444 +         let key_b = [0x40u8; KEY_LEN]; // 0100_0000    64 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 -         let key_b = [0x40u8; KEY_LEN].into(); // 0100_0000    64 (Dec)
[INFO] [stdout] 444 +         let key_b = <[u8; 32] as Into<_>>::into([0x40u8; KEY_LEN]); // 0100_0000    64 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:445:21
[INFO] [stdout]     |
[INFO] [stdout] 445 |         let key_c = [0x41u8; KEY_LEN].into(); // 0100_0001    65 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 445 -         let key_c = [0x41u8; KEY_LEN].into(); // 0100_0001    65 (Dec)
[INFO] [stdout] 445 +         let key_c = [0x41u8; KEY_LEN]; // 0100_0001    65 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 -         let key_c = [0x41u8; KEY_LEN].into(); // 0100_0001    65 (Dec)
[INFO] [stdout] 445 +         let key_c = <[u8; 32] as Into<_>>::into([0x41u8; KEY_LEN]); // 0100_0001    65 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:446:21
[INFO] [stdout]     |
[INFO] [stdout] 446 |         let key_f = [0x70u8; KEY_LEN].into(); // 0111_0000   112 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -         let key_f = [0x70u8; KEY_LEN].into(); // 0111_0000   112 (Dec)
[INFO] [stdout] 446 +         let key_f = [0x70u8; KEY_LEN]; // 0111_0000   112 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -         let key_f = [0x70u8; KEY_LEN].into(); // 0111_0000   112 (Dec)
[INFO] [stdout] 446 +         let key_f = <[u8; 32] as Into<_>>::into([0x70u8; KEY_LEN]); // 0111_0000   112 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:447:21
[INFO] [stdout]     |
[INFO] [stdout] 447 |         let key_g = [0x71u8; KEY_LEN].into(); // 0111_0001   113 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 447 -         let key_g = [0x71u8; KEY_LEN].into(); // 0111_0001   113 (Dec)
[INFO] [stdout] 447 +         let key_g = [0x71u8; KEY_LEN]; // 0111_0001   113 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 447 -         let key_g = [0x71u8; KEY_LEN].into(); // 0111_0001   113 (Dec)
[INFO] [stdout] 447 +         let key_g = <[u8; 32] as Into<_>>::into([0x71u8; KEY_LEN]); // 0111_0001   113 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:448:21
[INFO] [stdout]     |
[INFO] [stdout] 448 |         let key_h = [0x72u8; KEY_LEN].into(); // 0111_0010   114 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 448 -         let key_h = [0x72u8; KEY_LEN].into(); // 0111_0010   114 (Dec)
[INFO] [stdout] 448 +         let key_h = [0x72u8; KEY_LEN]; // 0111_0010   114 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 448 -         let key_h = [0x72u8; KEY_LEN].into(); // 0111_0010   114 (Dec)
[INFO] [stdout] 448 +         let key_h = <[u8; 32] as Into<_>>::into([0x72u8; KEY_LEN]); // 0111_0010   114 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:449:21
[INFO] [stdout]     |
[INFO] [stdout] 449 |         let key_j = [0xC0u8; KEY_LEN].into(); // 1100_0000   192 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 449 -         let key_j = [0xC0u8; KEY_LEN].into(); // 1100_0000   192 (Dec)
[INFO] [stdout] 449 +         let key_j = [0xC0u8; KEY_LEN]; // 1100_0000   192 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 449 -         let key_j = [0xC0u8; KEY_LEN].into(); // 1100_0000   192 (Dec)
[INFO] [stdout] 449 +         let key_j = <[u8; 32] as Into<_>>::into([0xC0u8; KEY_LEN]); // 1100_0000   192 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:450:21
[INFO] [stdout]     |
[INFO] [stdout] 450 |         let key_k = [0xC1u8; KEY_LEN].into(); // 1100_0001   193 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 450 -         let key_k = [0xC1u8; KEY_LEN].into(); // 1100_0001   193 (Dec)
[INFO] [stdout] 450 +         let key_k = [0xC1u8; KEY_LEN]; // 1100_0001   193 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 450 -         let key_k = [0xC1u8; KEY_LEN].into(); // 1100_0001   193 (Dec)
[INFO] [stdout] 450 +         let key_k = <[u8; 32] as Into<_>>::into([0xC1u8; KEY_LEN]); // 1100_0001   193 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:451:21
[INFO] [stdout]     |
[INFO] [stdout] 451 |         let key_l = [0xE0u8; KEY_LEN].into(); // 1110_0000   224 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 451 -         let key_l = [0xE0u8; KEY_LEN].into(); // 1110_0000   224 (Dec)
[INFO] [stdout] 451 +         let key_l = [0xE0u8; KEY_LEN]; // 1110_0000   224 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 451 -         let key_l = [0xE0u8; KEY_LEN].into(); // 1110_0000   224 (Dec)
[INFO] [stdout] 451 +         let key_l = <[u8; 32] as Into<_>>::into([0xE0u8; KEY_LEN]); // 1110_0000   224 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:452:21
[INFO] [stdout]     |
[INFO] [stdout] 452 |         let key_m = [0xE1u8; KEY_LEN].into(); // 1110_0001   225 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 452 -         let key_m = [0xE1u8; KEY_LEN].into(); // 1110_0001   225 (Dec)
[INFO] [stdout] 452 +         let key_m = [0xE1u8; KEY_LEN]; // 1110_0001   225 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 452 -         let key_m = [0xE1u8; KEY_LEN].into(); // 1110_0001   225 (Dec)
[INFO] [stdout] 452 +         let key_m = <[u8; 32] as Into<_>>::into([0xE1u8; KEY_LEN]); // 1110_0001   225 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:453:21
[INFO] [stdout]     |
[INFO] [stdout] 453 |         let key_n = [0xE2u8; KEY_LEN].into(); // 1110_0010   226 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 453 -         let key_n = [0xE2u8; KEY_LEN].into(); // 1110_0010   226 (Dec)
[INFO] [stdout] 453 +         let key_n = [0xE2u8; KEY_LEN]; // 1110_0010   226 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 453 -         let key_n = [0xE2u8; KEY_LEN].into(); // 1110_0010   226 (Dec)
[INFO] [stdout] 453 +         let key_n = <[u8; 32] as Into<_>>::into([0xE2u8; KEY_LEN]); // 1110_0010   226 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:454:21
[INFO] [stdout]     |
[INFO] [stdout] 454 |         let key_p = [0xF8u8; KEY_LEN].into(); // 1111_1000   248 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 454 -         let key_p = [0xF8u8; KEY_LEN].into(); // 1111_1000   248 (Dec)
[INFO] [stdout] 454 +         let key_p = [0xF8u8; KEY_LEN]; // 1111_1000   248 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 454 -         let key_p = [0xF8u8; KEY_LEN].into(); // 1111_1000   248 (Dec)
[INFO] [stdout] 454 +         let key_p = <[u8; 32] as Into<_>>::into([0xF8u8; KEY_LEN]); // 1111_1000   248 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:493:27
[INFO] [stdout]     |
[INFO] [stdout] 493 |         let initial_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let initial_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 493 +         let initial_key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let initial_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 493 +         let initial_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:498:23
[INFO] [stdout]     |
[INFO] [stdout] 498 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 498 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 498 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 498 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 498 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:523:29
[INFO] [stdout]     |
[INFO] [stdout] 523 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![[0x00u8; KEY_LEN], [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![<[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]), [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:523:55
[INFO] [stdout]     |
[INFO] [stdout] 523 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN]];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN])];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:542:29
[INFO] [stdout]     |
[INFO] [stdout] 542 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![[0x00u8; KEY_LEN], [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![<[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]), [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:542:55
[INFO] [stdout]     |
[INFO] [stdout] 542 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN]];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), <[u8; 32] as Into<_>>::into([0x80u8; KEY_LEN])];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:560:19
[INFO] [stdout]     |
[INFO] [stdout] 560 |         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 560 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 560 +         let key = [0xAAu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 560 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 560 +         let key = <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:577:13
[INFO] [stdout]     |
[INFO] [stdout] 577 |             [0xAAu8; KEY_LEN].into(), // 1010_1010
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 577 -             [0xAAu8; KEY_LEN].into(), // 1010_1010
[INFO] [stdout] 577 +             [0xAAu8; KEY_LEN], // 1010_1010
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 577 -             [0xAAu8; KEY_LEN].into(), // 1010_1010
[INFO] [stdout] 577 +             <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]), // 1010_1010
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:578:13
[INFO] [stdout]     |
[INFO] [stdout] 578 |             [0xBBu8; KEY_LEN].into(), // 1011_1011
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 578 -             [0xBBu8; KEY_LEN].into(), // 1011_1011
[INFO] [stdout] 578 +             [0xBBu8; KEY_LEN], // 1011_1011
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 578 -             [0xBBu8; KEY_LEN].into(), // 1011_1011
[INFO] [stdout] 578 +             <[u8; 32] as Into<_>>::into([0xBBu8; KEY_LEN]), // 1011_1011
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:579:13
[INFO] [stdout]     |
[INFO] [stdout] 579 |             [0xCCu8; KEY_LEN].into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 579 -             [0xCCu8; KEY_LEN].into(),
[INFO] [stdout] 579 +             [0xCCu8; KEY_LEN],
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 579 -             [0xCCu8; KEY_LEN].into(),
[INFO] [stdout] 579 +             <[u8; 32] as Into<_>>::into([0xCCu8; KEY_LEN]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:724:25
[INFO] [stdout]     |
[INFO] [stdout] 724 |         let first_key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 724 -         let first_key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 724 +         let first_key = [0xAAu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 -         let first_key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 724 +         let first_key = <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:727:26
[INFO] [stdout]     |
[INFO] [stdout] 727 |         let second_key = [0xCCu8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 727 -         let second_key = [0xCCu8; KEY_LEN].into();
[INFO] [stdout] 727 +         let second_key = [0xCCu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 -         let second_key = [0xCCu8; KEY_LEN].into();
[INFO] [stdout] 727 +         let second_key = <[u8; 32] as Into<_>>::into([0xCCu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:819:19
[INFO] [stdout]     |
[INFO] [stdout] 819 |         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 819 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 819 +         let key = [0xAAu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 819 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 819 +         let key = <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:883:33
[INFO] [stdout]     |
[INFO] [stdout] 883 |         let missing_root_hash = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                                 ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 883 -         let missing_root_hash = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 883 +         let missing_root_hash = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 883 -         let missing_root_hash = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 883 +         let missing_root_hash = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:894:19
[INFO] [stdout]     |
[INFO] [stdout] 894 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 894 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 894 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 894 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 894 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:951:25
[INFO] [stdout]     |
[INFO] [stdout] 951 |         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 951 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 951 +         let first_key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 951 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 951 +         let first_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:957:26
[INFO] [stdout]     |
[INFO] [stdout] 957 |         let second_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 957 -         let second_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 957 +         let second_key = [0x02u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 957 -         let second_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 957 +         let second_key = <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:979:25
[INFO] [stdout]     |
[INFO] [stdout] 979 |         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 979 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 979 +         let first_key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 979 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 979 +         let first_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:980:26
[INFO] [stdout]     |
[INFO] [stdout] 980 |         let second_key = [0x01u8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 980 -         let second_key = [0x01u8; KEY_LEN].into();
[INFO] [stdout] 980 +         let second_key = [0x01u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 -         let second_key = [0x01u8; KEY_LEN].into();
[INFO] [stdout] 980 +         let second_key = <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:981:25
[INFO] [stdout]     |
[INFO] [stdout] 981 |         let third_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 981 -         let third_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 981 +         let third_key = [0x02u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 981 -         let third_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 981 +         let third_key = <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:982:26
[INFO] [stdout]     |
[INFO] [stdout] 982 |         let fourth_key = [0x03u8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 982 -         let fourth_key = [0x03u8; KEY_LEN].into();
[INFO] [stdout] 982 +         let fourth_key = [0x03u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 -         let fourth_key = [0x03u8; KEY_LEN].into();
[INFO] [stdout] 982 +         let fourth_key = <[u8; 32] as Into<_>>::into([0x03u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1079:13
[INFO] [stdout]      |
[INFO] [stdout] 1079 |             [0x00u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1079 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1079 +             [0x00u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1079 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1079 +             <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1080:13
[INFO] [stdout]      |
[INFO] [stdout] 1080 |             [0x01u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1080 +             [0x01u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1080 +             <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1081:13
[INFO] [stdout]      |
[INFO] [stdout] 1081 |             [0x02u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1081 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1081 +             [0x02u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1081 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1081 +             <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1082:13
[INFO] [stdout]      |
[INFO] [stdout] 1082 |             [0x10u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1082 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1082 +             [0x10u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1082 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1082 +             <[u8; 32] as Into<_>>::into([0x10u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1083:13
[INFO] [stdout]      |
[INFO] [stdout] 1083 |             [0x20u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1083 -             [0x20u8; KEY_LEN].into(),
[INFO] [stdout] 1083 +             [0x20u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 -             [0x20u8; KEY_LEN].into(),
[INFO] [stdout] 1083 +             <[u8; 32] as Into<_>>::into([0x20u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1112:13
[INFO] [stdout]      |
[INFO] [stdout] 1112 |             [0x10u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1112 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1112 +             [0x10u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1112 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1112 +             <[u8; 32] as Into<_>>::into([0x10u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1113:13
[INFO] [stdout]      |
[INFO] [stdout] 1113 |             [0x11u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1113 -             [0x11u8; KEY_LEN].into(),
[INFO] [stdout] 1113 +             [0x11u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1113 -             [0x11u8; KEY_LEN].into(),
[INFO] [stdout] 1113 +             <[u8; 32] as Into<_>>::into([0x11u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1114:13
[INFO] [stdout]      |
[INFO] [stdout] 1114 |             [0x00u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1114 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1114 +             [0x00u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1114 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1114 +             <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1115:13
[INFO] [stdout]      |
[INFO] [stdout] 1115 |             [0x01u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1115 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1115 +             [0x01u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1115 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1115 +             <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1116:13
[INFO] [stdout]      |
[INFO] [stdout] 1116 |             [0x02u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1116 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1116 +             [0x02u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1116 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1116 +             <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1169:19
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1169 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1169 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1189:19
[INFO] [stdout]      |
[INFO] [stdout] 1189 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1189 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1189 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1189 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1189 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1207:19
[INFO] [stdout]      |
[INFO] [stdout] 1207 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1207 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1207 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1207 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1207 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1213:45
[INFO] [stdout]      |
[INFO] [stdout] 1213 |         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN].into(), key, &data, &inclusion_proof) {
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1213 -         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN].into(), key, &data, &inclusion_proof) {
[INFO] [stdout] 1213 +         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN], key, &data, &inclusion_proof) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1213 -         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN].into(), key, &data, &inclusion_proof) {
[INFO] [stdout] 1213 +         match Tree::verify_inclusion_proof(&<[u8; 32] as Into<_>>::into([01u8; KEY_LEN]), key, &data, &inclusion_proof) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1288:18
[INFO] [stdout]      |
[INFO] [stdout] 1288 |                 &[0x03; KEY_LEN].into(),
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1288 -                 &[0x03; KEY_LEN].into(),
[INFO] [stdout] 1288 +                 &[0x03; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1288 -                 &[0x03; KEY_LEN].into(),
[INFO] [stdout] 1288 +                 &<[u8; 32] as Into<_>>::into([0x03; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1305:19
[INFO] [stdout]      |
[INFO] [stdout] 1305 |         let key = [0x96u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1305 -         let key = [0x96u8; KEY_LEN].into();
[INFO] [stdout] 1305 +         let key = [0x96u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1305 -         let key = [0x96u8; KEY_LEN].into();
[INFO] [stdout] 1305 +         let key = <[u8; 32] as Into<_>>::into([0x96u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1348:19
[INFO] [stdout]      |
[INFO] [stdout] 1348 |         let key = [0x78u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1348 -         let key = [0x78u8; KEY_LEN].into();
[INFO] [stdout] 1348 +         let key = [0x78u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1348 -         let key = [0x78u8; KEY_LEN].into();
[INFO] [stdout] 1348 +         let key = <[u8; 32] as Into<_>>::into([0x78u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1377:24
[INFO] [stdout]      |
[INFO] [stdout] 1377 |         let test_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1377 -         let test_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1377 +         let test_key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1377 -         let test_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1377 +         let test_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1552:23
[INFO] [stdout]      |
[INFO] [stdout] 1552 |             keys.push(key_value.into());
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1552 -             keys.push(key_value.into());
[INFO] [stdout] 1552 +             keys.push(key_value);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1552 -             keys.push(key_value.into());
[INFO] [stdout] 1552 +             keys.push(<[u8; 32] as Into<_>>::into(key_value));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 2]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1417 |     test_key_size!(it_handles_key_size_of_two, 2, [0x94u8; 32], 16, 16);
[INFO] [stdout]      |     ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 2] as Into<[u8; 2]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 3]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1418 |     test_key_size!(it_handles_key_size_of_three, 3, [0x95u8; 32], 32, 32);
[INFO] [stdout]      |     --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 3] as Into<[u8; 3]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 4]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1419 |     test_key_size!(it_handles_key_size_of_four, 4, [0x96u8; 32], 64, 64);
[INFO] [stdout]      |     -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 4] as Into<[u8; 4]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 5]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1420 |     test_key_size!(it_handles_key_size_of_five, 5, [0x97u8; 32], 128, 128);
[INFO] [stdout]      |     ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 5] as Into<[u8; 5]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 6]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1421 |     test_key_size!(it_handles_key_size_of_six, 6, [0x98u8; 32], 256, 256);
[INFO] [stdout]      |     --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 6] as Into<[u8; 6]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 7]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1422 |     test_key_size!(it_handles_key_size_of_seven, 7, [0x99u8; 32], 512, 512);
[INFO] [stdout]      |     ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 7] as Into<[u8; 7]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 8]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1423 |     test_key_size!(it_handles_key_size_of_eight, 8, [0x9Au8; 32], 1024, 512);
[INFO] [stdout]      |     ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 8] as Into<[u8; 8]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 9]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1424 |     test_key_size!(it_handles_key_size_of_nine, 9, [0x9Bu8; 32], 2048, 512);
[INFO] [stdout]      |     ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 9] as Into<[u8; 9]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 10]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1425 |     test_key_size!(it_handles_key_size_of_ten, 10, [0x9Cu8; 32], 4096, 512);
[INFO] [stdout]      |     ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 10] as Into<[u8; 10]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 11]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1426 |     test_key_size!(it_handles_key_size_of_eleven, 11, [0x9Du8; 32], 4096, 512);
[INFO] [stdout]      |     -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 11] as Into<[u8; 11]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 12]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1427 |     test_key_size!(it_handles_key_size_of_twelve, 12, [0x9Eu8; 32], 4096, 512);
[INFO] [stdout]      |     -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 12] as Into<[u8; 12]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 13]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1428 |     test_key_size!(it_handles_key_size_of_thirteen, 13, [0x9Fu8; 32], 4096, 512);
[INFO] [stdout]      |     ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 13] as Into<[u8; 13]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 14]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1429 |     test_key_size!(it_handles_key_size_of_fourteen, 14, [0xA0u8; 32], 4096, 512);
[INFO] [stdout]      |     ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 14] as Into<[u8; 14]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 15]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1430 |     test_key_size!(it_handles_key_size_of_fifteen, 15, [0xA1u8; 32], 4096, 512);
[INFO] [stdout]      |     --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 15] as Into<[u8; 15]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 16]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1431 |     test_key_size!(it_handles_key_size_of_sixteen, 16, [0xA2u8; 32], 4096, 512);
[INFO] [stdout]      |     --------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 16] as Into<[u8; 16]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 17]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1432 | /     test_key_size!(
[INFO] [stdout] 1433 | |         it_handles_key_size_of_seventeen,
[INFO] [stdout] 1434 | |         17,
[INFO] [stdout] 1435 | |         [0xA3u8; 32],
[INFO] [stdout] 1436 | |         4096,
[INFO] [stdout] 1437 | |         512
[INFO] [stdout] 1438 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 17] as Into<[u8; 17]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 18]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1439 |     test_key_size!(it_handles_key_size_of_eighteen, 18, [0xA4u8; 32], 4096, 512);
[INFO] [stdout]      |     ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 18] as Into<[u8; 18]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 19]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1440 |     test_key_size!(it_handles_key_size_of_nineteen, 19, [0xA5u8; 32], 4096, 512);
[INFO] [stdout]      |     ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 19] as Into<[u8; 19]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 20]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1441 |     test_key_size!(it_handles_key_size_of_twenty, 20, [0xA6u8; 32], 4096, 512);
[INFO] [stdout]      |     -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 20] as Into<[u8; 20]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 21]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1442 | /     test_key_size!(
[INFO] [stdout] 1443 | |         it_handles_key_size_of_twenty_one,
[INFO] [stdout] 1444 | |         21,
[INFO] [stdout] 1445 | |         [0xA7u8; 32],
[INFO] [stdout] 1446 | |         4096,
[INFO] [stdout] 1447 | |         512
[INFO] [stdout] 1448 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 21] as Into<[u8; 21]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 22]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1449 | /     test_key_size!(
[INFO] [stdout] 1450 | |         it_handles_key_size_of_twenty_two,
[INFO] [stdout] 1451 | |         22,
[INFO] [stdout] 1452 | |         [0xA8u8; 32],
[INFO] [stdout] 1453 | |         4096,
[INFO] [stdout] 1454 | |         512
[INFO] [stdout] 1455 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 22] as Into<[u8; 22]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 23]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1456 | /     test_key_size!(
[INFO] [stdout] 1457 | |         it_handles_key_size_of_twenty_three,
[INFO] [stdout] 1458 | |         23,
[INFO] [stdout] 1459 | |         [0xA9u8; 32],
[INFO] [stdout] 1460 | |         4096,
[INFO] [stdout] 1461 | |         512
[INFO] [stdout] 1462 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 23] as Into<[u8; 23]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 24]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1463 | /     test_key_size!(
[INFO] [stdout] 1464 | |         it_handles_key_size_of_twenty_four,
[INFO] [stdout] 1465 | |         24,
[INFO] [stdout] 1466 | |         [0xAAu8; 32],
[INFO] [stdout] 1467 | |         4096,
[INFO] [stdout] 1468 | |         512
[INFO] [stdout] 1469 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 24] as Into<[u8; 24]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 25]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1470 | /     test_key_size!(
[INFO] [stdout] 1471 | |         it_handles_key_size_of_twenty_five,
[INFO] [stdout] 1472 | |         25,
[INFO] [stdout] 1473 | |         [0xABu8; 32],
[INFO] [stdout] 1474 | |         4096,
[INFO] [stdout] 1475 | |         512
[INFO] [stdout] 1476 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 25] as Into<[u8; 25]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 26]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1477 | /     test_key_size!(
[INFO] [stdout] 1478 | |         it_handles_key_size_of_twenty_six,
[INFO] [stdout] 1479 | |         26,
[INFO] [stdout] 1480 | |         [0xACu8; 32],
[INFO] [stdout] 1481 | |         4096,
[INFO] [stdout] 1482 | |         512
[INFO] [stdout] 1483 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 26] as Into<[u8; 26]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 27]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1484 | /     test_key_size!(
[INFO] [stdout] 1485 | |         it_handles_key_size_of_twenty_seven,
[INFO] [stdout] 1486 | |         27,
[INFO] [stdout] 1487 | |         [0xADu8; 32],
[INFO] [stdout] 1488 | |         4096,
[INFO] [stdout] 1489 | |         512
[INFO] [stdout] 1490 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 27] as Into<[u8; 27]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 28]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1491 | /     test_key_size!(
[INFO] [stdout] 1492 | |         it_handles_key_size_of_twenty_eight,
[INFO] [stdout] 1493 | |         28,
[INFO] [stdout] 1494 | |         [0xAEu8; 32],
[INFO] [stdout] 1495 | |         4096,
[INFO] [stdout] 1496 | |         512
[INFO] [stdout] 1497 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 28] as Into<[u8; 28]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 29]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1498 | /     test_key_size!(
[INFO] [stdout] 1499 | |         it_handles_key_size_of_twenty_nine,
[INFO] [stdout] 1500 | |         29,
[INFO] [stdout] 1501 | |         [0xAFu8; 32],
[INFO] [stdout] 1502 | |         4096,
[INFO] [stdout] 1503 | |         512
[INFO] [stdout] 1504 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 29] as Into<[u8; 29]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 30]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |     macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                     keys.push(key_value.into());
[INFO] [stdout]      |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1505 |     test_key_size!(it_handles_key_size_of_thirty, 30, [0xB0u8; 32], 4096, 512);
[INFO] [stdout]      |     -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 30] as Into<[u8; 30]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 31]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1506 | /     test_key_size!(
[INFO] [stdout] 1507 | |         it_handles_key_size_of_thirty_one,
[INFO] [stdout] 1508 | |         31,
[INFO] [stdout] 1509 | |         [0xB1u8; 32],
[INFO] [stdout] 1510 | |         4096,
[INFO] [stdout] 1511 | |         512
[INFO] [stdout] 1512 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 31] as Into<[u8; 31]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1513 | /     test_key_size!(
[INFO] [stdout] 1514 | |         it_handles_key_size_of_thirty_two,
[INFO] [stdout] 1515 | |         32,
[INFO] [stdout] 1516 | |         [0xB2u8; 32],
[INFO] [stdout] 1517 | |         4096,
[INFO] [stdout] 1518 | |         512
[INFO] [stdout] 1519 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 32] as Into<[u8; 32]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 33]`
[INFO] [stdout]     --> tests/merkle_bit.rs:47:31
[INFO] [stdout]      |
[INFO] [stdout]   23 |       macro_rules! test_key_size {
[INFO] [stdout] ...
[INFO] [stdout]   47 |                       keys.push(key_value.into());
[INFO] [stdout]      |                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 1520 | /     test_key_size!(
[INFO] [stdout] 1521 | |         it_handles_key_size_of_thirty_three,
[INFO] [stdout] 1522 | |         33,
[INFO] [stdout] 1523 | |         [0xB2u8; 32],
[INFO] [stdout] 1524 | |         4096,
[INFO] [stdout] 1525 | |         512
[INFO] [stdout] 1526 | |     );
[INFO] [stdout]      | |_____- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]      = note: you can instead use the fully-qualified path `<[u8; 33] as Into<[u8; 33]>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (test "merkle_bit") due to 97 previous errors
[INFO] running `Command { std: "docker" "inspect" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266", kill_on_drop: false }`
[INFO] [stdout] 70c09247009d4c74994b56b728f84ada8d9a9723f163b747a10567fe97d49266
