[INFO] fetching crate generic-arraydeque 0.2.0...
[INFO] checking generic-arraydeque-0.2.0 against 760e1de835e253bf28bbcbfee38b5e8ed9ffe074 for pr-133502-26
[INFO] extracting crate generic-arraydeque 0.2.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate generic-arraydeque 0.2.0
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate generic-arraydeque 0.2.0
[INFO] tweaked toml for crates.io crate generic-arraydeque 0.2.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate generic-arraydeque 0.2.0 on toolchain 760e1de835e253bf28bbcbfee38b5e8ed9ffe074
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+760e1de835e253bf28bbcbfee38b5e8ed9ffe074" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate generic-arraydeque 0.2.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" "+760e1de835e253bf28bbcbfee38b5e8ed9ffe074" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-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:1fa6594d87c8fa7b311925a7a77a16f539833322d9dfba4ce891f211db2f90b1" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 9e924bff765c620dd78e9b2c55893618bb203e4ce0fec2f0a90510b9e1bc0e9c
[INFO] running `Command { std: "docker" "start" "9e924bff765c620dd78e9b2c55893618bb203e4ce0fec2f0a90510b9e1bc0e9c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9e924bff765c620dd78e9b2c55893618bb203e4ce0fec2f0a90510b9e1bc0e9c", 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" "9e924bff765c620dd78e9b2c55893618bb203e4ce0fec2f0a90510b9e1bc0e9c" "/opt/rustwide/cargo-home/bin/cargo" "+760e1de835e253bf28bbcbfee38b5e8ed9ffe074" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9e924bff765c620dd78e9b2c55893618bb203e4ce0fec2f0a90510b9e1bc0e9c", 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" "9e924bff765c620dd78e9b2c55893618bb203e4ce0fec2f0a90510b9e1bc0e9c" "/opt/rustwide/cargo-home/bin/cargo" "+760e1de835e253bf28bbcbfee38b5e8ed9ffe074" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]    Compiling generic-arraydeque v0.2.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking generic-array v1.3.5
[INFO] [stderr]     Checking serde_test v1.0.177
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<usize, UInt<UInt<UInt<UInt<UInt<_, B0>, B0>, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/tests.rs:821:11
[INFO] [stdout]     |
[INFO] [stdout] 821 |     test: GenericArrayDeque<usize, Sum<U8192, U4>>,
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout]     = note: `#[warn(recursion_depth_exceeding_limit)]` (part of `#[warn(future_incompatible)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<usize, UInt<UInt<UInt<UInt<UInt<_, B0>, B0>, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/tests.rs:822:15
[INFO] [stdout]     |
[INFO] [stdout] 822 |     expected: GenericArrayDeque<usize, Sum<U8192, U4>>,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:393:49
[INFO] [stdout]     |
[INFO] [stdout] 393 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:393:21
[INFO] [stdout]     |
[INFO] [stdout] 393 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:395:21
[INFO] [stdout]     |
[INFO] [stdout] 395 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:400:24
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:405:22
[INFO] [stdout]     |
[INFO] [stdout] 405 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:393:21
[INFO] [stdout]     |
[INFO] [stdout] 393 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:393:21
[INFO] [stdout]     |
[INFO] [stdout] 393 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:395:21
[INFO] [stdout]     |
[INFO] [stdout] 395 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: IntoIterator`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as IntoIterator>::IntoIter == _`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:400:24
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:400:24
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as Iterator>::Item == i32`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:400:18
[INFO] [stdout]     |
[INFO] [stdout] 400 |     for value in deque.drain(2..4) {
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:405:22
[INFO] [stdout]     |
[INFO] [stdout] 405 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:406:16
[INFO] [stdout]     |
[INFO] [stdout] 406 |     assert_eq!(deque[0], 0);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:407:16
[INFO] [stdout]     |
[INFO] [stdout] 407 |     assert_eq!(deque[1], 1);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:408:16
[INFO] [stdout]     |
[INFO] [stdout] 408 |     assert_eq!(deque[2], 4);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:409:16
[INFO] [stdout]     |
[INFO] [stdout] 409 |     assert_eq!(deque[3], 5);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]   |
[INFO] [stdout]   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]   = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]   = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]   = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/drain.rs:406:16
[INFO] [stdout]     |
[INFO] [stdout] 406 |     assert_eq!(deque[0], 0);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/drain.rs:407:16
[INFO] [stdout]     |
[INFO] [stdout] 407 |     assert_eq!(deque[1], 1);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/drain.rs:408:16
[INFO] [stdout]     |
[INFO] [stdout] 408 |     assert_eq!(deque[2], 4);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/drain.rs:409:16
[INFO] [stdout]     |
[INFO] [stdout] 409 |     assert_eq!(deque[3], 5);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:414:49
[INFO] [stdout]     |
[INFO] [stdout] 414 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:414:21
[INFO] [stdout]     |
[INFO] [stdout] 414 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:416:21
[INFO] [stdout]     |
[INFO] [stdout] 416 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:419:27
[INFO] [stdout]     |
[INFO] [stdout] 419 |     let mut drain = deque.drain(1..4);
[INFO] [stdout]     |                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:425:22
[INFO] [stdout]     |
[INFO] [stdout] 425 |     assert_eq!(deque.len(), 2);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:414:21
[INFO] [stdout]     |
[INFO] [stdout] 414 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:414:21
[INFO] [stdout]     |
[INFO] [stdout] 414 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:416:21
[INFO] [stdout]     |
[INFO] [stdout] 416 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:419:27
[INFO] [stdout]     |
[INFO] [stdout] 419 |     let mut drain = deque.drain(1..4);
[INFO] [stdout]     |                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:419:27
[INFO] [stdout]     |
[INFO] [stdout] 419 |     let mut drain = deque.drain(1..4);
[INFO] [stdout]     |                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as Iterator>::Item == i32`
[INFO] [stdout]    --> src/drain.rs:420:22
[INFO] [stdout]     |
[INFO] [stdout] 420 |     assert_eq!(drain.next_back(), Some(3));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/drain.rs:420:22
[INFO] [stdout]     |
[INFO] [stdout] 420 |     assert_eq!(drain.next_back(), Some(3));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: DoubleEndedIterator`
[INFO] [stdout]    --> src/drain.rs:420:22
[INFO] [stdout]     |
[INFO] [stdout] 420 |     assert_eq!(drain.next_back(), Some(3));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:420:16
[INFO] [stdout]     |
[INFO] [stdout] 420 |     assert_eq!(drain.next_back(), Some(3));
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:420:22
[INFO] [stdout]     |
[INFO] [stdout] 420 |     assert_eq!(drain.next_back(), Some(3));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as Iterator>::Item == i32`
[INFO] [stdout]    --> src/drain.rs:421:22
[INFO] [stdout]     |
[INFO] [stdout] 421 |     assert_eq!(drain.next(), Some(1));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/drain.rs:421:22
[INFO] [stdout]     |
[INFO] [stdout] 421 |     assert_eq!(drain.next(), Some(1));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:421:16
[INFO] [stdout]     |
[INFO] [stdout] 421 |     assert_eq!(drain.next(), Some(1));
[INFO] [stdout]     |                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:421:22
[INFO] [stdout]     |
[INFO] [stdout] 421 |     assert_eq!(drain.next(), Some(1));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as Iterator>::Item == i32`
[INFO] [stdout]    --> src/drain.rs:422:22
[INFO] [stdout]     |
[INFO] [stdout] 422 |     assert_eq!(drain.next(), Some(2));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/drain.rs:422:22
[INFO] [stdout]     |
[INFO] [stdout] 422 |     assert_eq!(drain.next(), Some(2));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:422:16
[INFO] [stdout]     |
[INFO] [stdout] 422 |     assert_eq!(drain.next(), Some(2));
[INFO] [stdout]     |                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:422:22
[INFO] [stdout]     |
[INFO] [stdout] 422 |     assert_eq!(drain.next(), Some(2));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/drain.rs:423:22
[INFO] [stdout]     |
[INFO] [stdout] 423 |     assert_eq!(drain.next(), None);
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/drain.rs:423:22
[INFO] [stdout]     |
[INFO] [stdout] 423 |     assert_eq!(drain.next(), None);
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:423:16
[INFO] [stdout]     |
[INFO] [stdout] 423 |     assert_eq!(drain.next(), None);
[INFO] [stdout]     |                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:423:22
[INFO] [stdout]     |
[INFO] [stdout] 423 |     assert_eq!(drain.next(), None);
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:424:5
[INFO] [stdout]     |
[INFO] [stdout] 424 |     drop(drain);
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:424:10
[INFO] [stdout]     |
[INFO] [stdout] 424 |     drop(drain);
[INFO] [stdout]     |          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:425:22
[INFO] [stdout]     |
[INFO] [stdout] 425 |     assert_eq!(deque.len(), 2);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:426:16
[INFO] [stdout]     |
[INFO] [stdout] 426 |     assert_eq!(deque[0], 0);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:427:16
[INFO] [stdout]     |
[INFO] [stdout] 427 |     assert_eq!(deque[1], 4);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/drain.rs:426:16
[INFO] [stdout]     |
[INFO] [stdout] 426 |     assert_eq!(deque[0], 0);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/drain.rs:427:16
[INFO] [stdout]     |
[INFO] [stdout] 427 |     assert_eq!(deque[1], 4);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:434:51
[INFO] [stdout]     |
[INFO] [stdout] 434 |       let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:434:23
[INFO] [stdout]     |
[INFO] [stdout] 434 |       let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:436:23
[INFO] [stdout]     |
[INFO] [stdout] 436 |         assert!(deque.push_back(DropSpy).is_none());
[INFO] [stdout]     |                       ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<DropSpy, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:434:23
[INFO] [stdout]     |
[INFO] [stdout] 434 |       let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<DropSpy, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:434:23
[INFO] [stdout]     |
[INFO] [stdout] 434 |       let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<DropSpy, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:436:23
[INFO] [stdout]     |
[INFO] [stdout] 436 |         assert!(deque.push_back(DropSpy).is_none());
[INFO] [stdout]     |                       ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:438:21
[INFO] [stdout]     |
[INFO] [stdout] 438 |       let _ = deque.drain(1..3);
[INFO] [stdout]     |                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, DropSpy, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:438:21
[INFO] [stdout]     |
[INFO] [stdout] 438 |       let _ = deque.drain(1..3);
[INFO] [stdout]     |                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<DropSpy, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:438:21
[INFO] [stdout]     |
[INFO] [stdout] 438 |       let _ = deque.drain(1..3);
[INFO] [stdout]     |                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/drain.rs:439:24
[INFO] [stdout]     |
[INFO] [stdout] 439 |       assert_eq!(deque.len(), 2);
[INFO] [stdout]     |                        ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<DropSpy, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/drain.rs:439:24
[INFO] [stdout]     |
[INFO] [stdout] 439 |       assert_eq!(deque.len(), 2);
[INFO] [stdout]     |                        ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/into_iter.rs:83:49
[INFO] [stdout]    |
[INFO] [stdout] 83 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]    |                                                 ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/into_iter.rs:83:21
[INFO] [stdout]    |
[INFO] [stdout] 83 |     let mut deque = GenericArrayDeque::<_, U8>::new();
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/into_iter.rs:85:21
[INFO] [stdout]    |
[INFO] [stdout] 85 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]    |                     ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/into_iter.rs:88:20
[INFO] [stdout]    |
[INFO] [stdout] 88 |     let mut iter = IntoIter::new(deque.clone());
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0282]: type annotations needed
[INFO] [stdout]   --> src/into_iter.rs:95:17
[INFO] [stdout]    |
[INFO] [stdout] 95 |     let count = deque.into_iter().count();
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^ cannot infer type
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:102:49
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:102:21
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:104:21
[INFO] [stdout]     |
[INFO] [stdout] 104 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:106:15
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:109:16
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:102:21
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:102:21
[INFO] [stdout]     |
[INFO] [stdout] 102 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:104:21
[INFO] [stdout]     |
[INFO] [stdout] 104 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:15
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |               ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:29
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Clone`
[INFO] [stdout]    --> src/into_iter.rs:106:35
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:35
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:35
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:15
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:106:44
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |                                            ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/into_iter.rs:106:15
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == i32`
[INFO] [stdout]    --> src/into_iter.rs:106:15
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:15
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:106:44
[INFO] [stdout]     |
[INFO] [stdout] 106 |     let sum = IntoIter::new(deque.clone()).fold(0, |acc, value| acc + value);
[INFO] [stdout]     |                                            ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:109:16
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:109:30
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                              ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:109:16
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == i32`
[INFO] [stdout]    --> src/into_iter.rs:109:37
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                                     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:109:37
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                                     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/into_iter.rs:109:16
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:109:16
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:109:37
[INFO] [stdout]     |
[INFO] [stdout] 109 |     let last = IntoIter::new(deque).last();
[INFO] [stdout]     |                                     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:115:49
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:115:21
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:117:21
[INFO] [stdout]     |
[INFO] [stdout] 117 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/into_iter.rs:119:20
[INFO] [stdout]     |
[INFO] [stdout] 119 |     let mut iter = IntoIter::new(deque);
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:115:21
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:115:21
[INFO] [stdout]     |
[INFO] [stdout] 115 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:117:21
[INFO] [stdout]     |
[INFO] [stdout] 117 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:119:20
[INFO] [stdout]     |
[INFO] [stdout] 119 |     let mut iter = IntoIter::new(deque);
[INFO] [stdout]     |                    ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:119:34
[INFO] [stdout]     |
[INFO] [stdout] 119 |     let mut iter = IntoIter::new(deque);
[INFO] [stdout]     |                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:119:20
[INFO] [stdout]     |
[INFO] [stdout] 119 |     let mut iter = IntoIter::new(deque);
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:120:21
[INFO] [stdout]     |
[INFO] [stdout] 120 |     assert_eq!(iter.size_hint(), (4, Some(4)));
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:120:16
[INFO] [stdout]     |
[INFO] [stdout] 120 |     assert_eq!(iter.size_hint(), (4, Some(4)));
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:120:21
[INFO] [stdout]     |
[INFO] [stdout] 120 |     assert_eq!(iter.size_hint(), (4, Some(4)));
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/into_iter.rs:121:10
[INFO] [stdout]     |
[INFO] [stdout] 121 |     iter.next();
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:121:10
[INFO] [stdout]     |
[INFO] [stdout] 121 |     iter.next();
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:121:5
[INFO] [stdout]     |
[INFO] [stdout] 121 |     iter.next();
[INFO] [stdout]     |     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:121:10
[INFO] [stdout]     |
[INFO] [stdout] 121 |     iter.next();
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:122:21
[INFO] [stdout]     |
[INFO] [stdout] 122 |     assert_eq!(iter.size_hint(), (3, Some(3)));
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:122:16
[INFO] [stdout]     |
[INFO] [stdout] 122 |     assert_eq!(iter.size_hint(), (3, Some(3)));
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:122:21
[INFO] [stdout]     |
[INFO] [stdout] 122 |     assert_eq!(iter.size_hint(), (3, Some(3)));
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/into_iter.rs:123:10
[INFO] [stdout]     |
[INFO] [stdout] 123 |     iter.next_back();
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:123:10
[INFO] [stdout]     |
[INFO] [stdout] 123 |     iter.next_back();
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: DoubleEndedIterator`
[INFO] [stdout]    --> src/into_iter.rs:123:10
[INFO] [stdout]     |
[INFO] [stdout] 123 |     iter.next_back();
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:123:5
[INFO] [stdout]     |
[INFO] [stdout] 123 |     iter.next_back();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:123:10
[INFO] [stdout]     |
[INFO] [stdout] 123 |     iter.next_back();
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/into_iter.rs:124:21
[INFO] [stdout]     |
[INFO] [stdout] 124 |     assert_eq!(iter.size_hint(), (2, Some(2)));
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:124:16
[INFO] [stdout]     |
[INFO] [stdout] 124 |     assert_eq!(iter.size_hint(), (2, Some(2)));
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&into_iter::IntoIter<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/into_iter.rs:124:21
[INFO] [stdout]     |
[INFO] [stdout] 124 |     assert_eq!(iter.size_hint(), (2, Some(2)));
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:271:21
[INFO] [stdout]     |
[INFO] [stdout] 271 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:271:50
[INFO] [stdout]     |
[INFO] [stdout] 271 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:271:21
[INFO] [stdout]     |
[INFO] [stdout] 271 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:271:21
[INFO] [stdout]     |
[INFO] [stdout] 271 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:273:21
[INFO] [stdout]     |
[INFO] [stdout] 273 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:273:21
[INFO] [stdout]     |
[INFO] [stdout] 273 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:277:16
[INFO] [stdout]     |
[INFO] [stdout] 277 |     let read = Read::read(&mut deque, &mut buf).unwrap();
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:277:16
[INFO] [stdout]     |
[INFO] [stdout] 277 |     let read = Read::read(&mut deque, &mut buf).unwrap();
[INFO] [stdout]     |                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:277:27
[INFO] [stdout]     |
[INFO] [stdout] 277 |     let read = Read::read(&mut deque, &mut buf).unwrap();
[INFO] [stdout]     |                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: IntoIterator`
[INFO] [stdout]    --> src/io.rs:280:22
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as IntoIterator>::IntoIter well-formed`
[INFO] [stdout]    --> src/io.rs:280:22
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as IntoIterator>::IntoIter == _`
[INFO] [stdout]    --> src/io.rs:280:22
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:280:16
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:280:22
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:280:22
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/io.rs:280:34
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/io.rs:280:16
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:280:16
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:280:34
[INFO] [stdout]     |
[INFO] [stdout] 280 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), b"lo".to_vec());
[INFO] [stdout]     |                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:285:21
[INFO] [stdout]     |
[INFO] [stdout] 285 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:285:50
[INFO] [stdout]     |
[INFO] [stdout] 285 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:285:21
[INFO] [stdout]     |
[INFO] [stdout] 285 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:285:21
[INFO] [stdout]     |
[INFO] [stdout] 285 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:287:21
[INFO] [stdout]     |
[INFO] [stdout] 287 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:287:21
[INFO] [stdout]     |
[INFO] [stdout] 287 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:289:22
[INFO] [stdout]     |
[INFO] [stdout] 289 |     assert_eq!(deque.pop_front(), Some(b'a'));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:289:22
[INFO] [stdout]     |
[INFO] [stdout] 289 |     assert_eq!(deque.pop_front(), Some(b'a'));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:290:19
[INFO] [stdout]     |
[INFO] [stdout] 290 |     assert!(deque.push_back(b'e').is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:290:19
[INFO] [stdout]     |
[INFO] [stdout] 290 |     assert!(deque.push_back(b'e').is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:293:11
[INFO] [stdout]     |
[INFO] [stdout] 293 |     deque.read_exact(&mut buf).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:293:5
[INFO] [stdout]     |
[INFO] [stdout] 293 |     deque.read_exact(&mut buf).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:293:11
[INFO] [stdout]     |
[INFO] [stdout] 293 |     deque.read_exact(&mut buf).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: IntoIterator`
[INFO] [stdout]    --> src/io.rs:295:22
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as IntoIterator>::IntoIter well-formed`
[INFO] [stdout]    --> src/io.rs:295:22
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as IntoIterator>::IntoIter == _`
[INFO] [stdout]    --> src/io.rs:295:22
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:295:16
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:295:22
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:295:22
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/io.rs:295:34
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/io.rs:295:16
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:295:16
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:295:34
[INFO] [stdout]     |
[INFO] [stdout] 295 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'e']);
[INFO] [stdout]     |                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:300:21
[INFO] [stdout]     |
[INFO] [stdout] 300 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:300:50
[INFO] [stdout]     |
[INFO] [stdout] 300 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:300:21
[INFO] [stdout]     |
[INFO] [stdout] 300 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:300:21
[INFO] [stdout]     |
[INFO] [stdout] 300 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:301:19
[INFO] [stdout]     |
[INFO] [stdout] 301 |     assert!(deque.push_back(b'x').is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:301:19
[INFO] [stdout]     |
[INFO] [stdout] 301 |     assert!(deque.push_back(b'x').is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:304:15
[INFO] [stdout]     |
[INFO] [stdout] 304 |     let err = Read::read_exact(&mut deque, &mut buf).unwrap_err();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:304:15
[INFO] [stdout]     |
[INFO] [stdout] 304 |     let err = Read::read_exact(&mut deque, &mut buf).unwrap_err();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:304:32
[INFO] [stdout]     |
[INFO] [stdout] 304 |     let err = Read::read_exact(&mut deque, &mut buf).unwrap_err();
[INFO] [stdout]     |                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:307:22
[INFO] [stdout]     |
[INFO] [stdout] 307 |     assert_eq!(deque.len(), 1);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:307:22
[INFO] [stdout]     |
[INFO] [stdout] 307 |     assert_eq!(deque.len(), 1);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:308:22
[INFO] [stdout]     |
[INFO] [stdout] 308 |     assert_eq!(deque.pop_front(), Some(b'x'));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:308:22
[INFO] [stdout]     |
[INFO] [stdout] 308 |     assert_eq!(deque.pop_front(), Some(b'x'));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:313:21
[INFO] [stdout]     |
[INFO] [stdout] 313 |     let mut deque = GenericArrayDeque::<u8, U6>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:313:50
[INFO] [stdout]     |
[INFO] [stdout] 313 |     let mut deque = GenericArrayDeque::<u8, U6>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:313:21
[INFO] [stdout]     |
[INFO] [stdout] 313 |     let mut deque = GenericArrayDeque::<u8, U6>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:313:21
[INFO] [stdout]     |
[INFO] [stdout] 313 |     let mut deque = GenericArrayDeque::<u8, U6>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:315:21
[INFO] [stdout]     |
[INFO] [stdout] 315 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:315:21
[INFO] [stdout]     |
[INFO] [stdout] 315 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:318:11
[INFO] [stdout]     |
[INFO] [stdout] 318 |     deque.read_to_end(&mut buf).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:318:5
[INFO] [stdout]     |
[INFO] [stdout] 318 |     deque.read_to_end(&mut buf).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:318:11
[INFO] [stdout]     |
[INFO] [stdout] 318 |     deque.read_to_end(&mut buf).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:320:19
[INFO] [stdout]     |
[INFO] [stdout] 320 |     assert!(deque.is_empty());
[INFO] [stdout]     |                   ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:320:19
[INFO] [stdout]     |
[INFO] [stdout] 320 |     assert!(deque.is_empty());
[INFO] [stdout]     |                   ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:323:21
[INFO] [stdout]     |
[INFO] [stdout] 323 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:323:21
[INFO] [stdout]     |
[INFO] [stdout] 323 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:326:11
[INFO] [stdout]     |
[INFO] [stdout] 326 |     deque.read_to_string(&mut string).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:326:5
[INFO] [stdout]     |
[INFO] [stdout] 326 |     deque.read_to_string(&mut string).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:326:11
[INFO] [stdout]     |
[INFO] [stdout] 326 |     deque.read_to_string(&mut string).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:329:19
[INFO] [stdout]     |
[INFO] [stdout] 329 |     assert!(deque.is_empty());
[INFO] [stdout]     |                   ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:329:19
[INFO] [stdout]     |
[INFO] [stdout] 329 |     assert!(deque.is_empty());
[INFO] [stdout]     |                   ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:331:11
[INFO] [stdout]     |
[INFO] [stdout] 331 |     deque.clear();
[INFO] [stdout]     |           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:331:11
[INFO] [stdout]     |
[INFO] [stdout] 331 |     deque.clear();
[INFO] [stdout]     |           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:332:11
[INFO] [stdout]     |
[INFO] [stdout] 332 |     deque.push_back(0xFF);
[INFO] [stdout]     |           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:332:11
[INFO] [stdout]     |
[INFO] [stdout] 332 |     deque.push_back(0xFF);
[INFO] [stdout]     |           ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:334:21
[INFO] [stdout]     |
[INFO] [stdout] 334 |     let err = deque.read_to_string(&mut invalid).unwrap_err();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:334:15
[INFO] [stdout]     |
[INFO] [stdout] 334 |     let err = deque.read_to_string(&mut invalid).unwrap_err();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:334:21
[INFO] [stdout]     |
[INFO] [stdout] 334 |     let err = deque.read_to_string(&mut invalid).unwrap_err();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:340:21
[INFO] [stdout]     |
[INFO] [stdout] 340 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:340:50
[INFO] [stdout]     |
[INFO] [stdout] 340 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:340:21
[INFO] [stdout]     |
[INFO] [stdout] 340 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:340:21
[INFO] [stdout]     |
[INFO] [stdout] 340 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:342:21
[INFO] [stdout]     |
[INFO] [stdout] 342 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:342:21
[INFO] [stdout]     |
[INFO] [stdout] 342 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:345:15
[INFO] [stdout]     |
[INFO] [stdout] 345 |     let buf = BufRead::fill_buf(&mut deque).unwrap();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: BufRead`
[INFO] [stdout]    --> src/io.rs:345:15
[INFO] [stdout]     |
[INFO] [stdout] 345 |     let buf = BufRead::fill_buf(&mut deque).unwrap();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:345:15
[INFO] [stdout]     |
[INFO] [stdout] 345 |     let buf = BufRead::fill_buf(&mut deque).unwrap();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:345:33
[INFO] [stdout]     |
[INFO] [stdout] 345 |     let buf = BufRead::fill_buf(&mut deque).unwrap();
[INFO] [stdout]     |                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:347:5
[INFO] [stdout]     |
[INFO] [stdout] 347 |     BufRead::consume(&mut deque, 3);
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: BufRead`
[INFO] [stdout]    --> src/io.rs:347:5
[INFO] [stdout]     |
[INFO] [stdout] 347 |     BufRead::consume(&mut deque, 3);
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:347:5
[INFO] [stdout]     |
[INFO] [stdout] 347 |     BufRead::consume(&mut deque, 3);
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:347:22
[INFO] [stdout]     |
[INFO] [stdout] 347 |     BufRead::consume(&mut deque, 3);
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: IntoIterator`
[INFO] [stdout]    --> src/io.rs:348:22
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as IntoIterator>::IntoIter well-formed`
[INFO] [stdout]    --> src/io.rs:348:22
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as IntoIterator>::IntoIter == _`
[INFO] [stdout]    --> src/io.rs:348:22
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:348:16
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:348:22
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:348:22
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: Iterator`
[INFO] [stdout]    --> src/io.rs:348:34
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> as Iterator>::Item == _`
[INFO] [stdout]    --> src/io.rs:348:16
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:348:16
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `into_iter::IntoIter<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:348:34
[INFO] [stdout]     |
[INFO] [stdout] 348 |     assert_eq!(deque.into_iter().collect::<Vec<_>>(), vec![b'd']);
[INFO] [stdout]     |                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:353:21
[INFO] [stdout]     |
[INFO] [stdout] 353 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:353:50
[INFO] [stdout]     |
[INFO] [stdout] 353 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:353:21
[INFO] [stdout]     |
[INFO] [stdout] 353 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:353:21
[INFO] [stdout]     |
[INFO] [stdout] 353 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:354:19
[INFO] [stdout]     |
[INFO] [stdout] 354 |     let written = Write::write(&mut deque, b"abcdef").unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:354:19
[INFO] [stdout]     |
[INFO] [stdout] 354 |     let written = Write::write(&mut deque, b"abcdef").unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:354:32
[INFO] [stdout]     |
[INFO] [stdout] 354 |     let written = Write::write(&mut deque, b"abcdef").unwrap();
[INFO] [stdout]     |                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:356:22
[INFO] [stdout]     |
[INFO] [stdout] 356 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:356:22
[INFO] [stdout]     |
[INFO] [stdout] 356 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:358:21
[INFO] [stdout]     |
[INFO] [stdout] 358 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:358:50
[INFO] [stdout]     |
[INFO] [stdout] 358 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:358:21
[INFO] [stdout]     |
[INFO] [stdout] 358 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:358:21
[INFO] [stdout]     |
[INFO] [stdout] 358 |     let mut deque = GenericArrayDeque::<u8, U8>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:360:16
[INFO] [stdout]     |
[INFO] [stdout] 360 |     assert_eq!(Write::write_vectored(&mut deque, &slices).unwrap(), 4);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:360:16
[INFO] [stdout]     |
[INFO] [stdout] 360 |     assert_eq!(Write::write_vectored(&mut deque, &slices).unwrap(), 4);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:360:38
[INFO] [stdout]     |
[INFO] [stdout] 360 |     assert_eq!(Write::write_vectored(&mut deque, &slices).unwrap(), 4);
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:361:22
[INFO] [stdout]     |
[INFO] [stdout] 361 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:361:22
[INFO] [stdout]     |
[INFO] [stdout] 361 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:365:19
[INFO] [stdout]     |
[INFO] [stdout] 365 |     let written = Write::write_vectored(&mut deque, &overflow).unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:365:19
[INFO] [stdout]     |
[INFO] [stdout] 365 |     let written = Write::write_vectored(&mut deque, &overflow).unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:365:41
[INFO] [stdout]     |
[INFO] [stdout] 365 |     let written = Write::write_vectored(&mut deque, &overflow).unwrap();
[INFO] [stdout]     |                                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:367:22
[INFO] [stdout]     |
[INFO] [stdout] 367 |     assert_eq!(deque.len(), 8);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:367:22
[INFO] [stdout]     |
[INFO] [stdout] 367 |     assert_eq!(deque.len(), 8);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:369:21
[INFO] [stdout]     |
[INFO] [stdout] 369 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:369:50
[INFO] [stdout]     |
[INFO] [stdout] 369 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:369:21
[INFO] [stdout]     |
[INFO] [stdout] 369 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:369:21
[INFO] [stdout]     |
[INFO] [stdout] 369 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:370:5
[INFO] [stdout]     |
[INFO] [stdout] 370 |     Write::write_all(&mut deque, b"wxyz").unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:370:5
[INFO] [stdout]     |
[INFO] [stdout] 370 |     Write::write_all(&mut deque, b"wxyz").unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:370:22
[INFO] [stdout]     |
[INFO] [stdout] 370 |     Write::write_all(&mut deque, b"wxyz").unwrap();
[INFO] [stdout]     |                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:371:15
[INFO] [stdout]     |
[INFO] [stdout] 371 |     let err = Write::write_all(&mut deque, b"overflow").unwrap_err();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:371:15
[INFO] [stdout]     |
[INFO] [stdout] 371 |     let err = Write::write_all(&mut deque, b"overflow").unwrap_err();
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:371:32
[INFO] [stdout]     |
[INFO] [stdout] 371 |     let err = Write::write_all(&mut deque, b"overflow").unwrap_err();
[INFO] [stdout]     |                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UTerm, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:374:21
[INFO] [stdout]     |
[INFO] [stdout] 374 |     let mut deque = GenericArrayDeque::<u8, U2>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UTerm, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:374:50
[INFO] [stdout]     |
[INFO] [stdout] 374 |     let mut deque = GenericArrayDeque::<u8, U2>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UTerm, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:374:21
[INFO] [stdout]     |
[INFO] [stdout] 374 |     let mut deque = GenericArrayDeque::<u8, U2>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UTerm, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:374:21
[INFO] [stdout]     |
[INFO] [stdout] 374 |     let mut deque = GenericArrayDeque::<u8, U2>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UTerm, B1>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:375:5
[INFO] [stdout]     |
[INFO] [stdout] 375 |     Write::flush(&mut deque).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UTerm, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:375:5
[INFO] [stdout]     |
[INFO] [stdout] 375 |     Write::flush(&mut deque).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UTerm, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:375:18
[INFO] [stdout]     |
[INFO] [stdout] 375 |     Write::flush(&mut deque).unwrap();
[INFO] [stdout]     |                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:383:21
[INFO] [stdout]     |
[INFO] [stdout] 383 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:383:50
[INFO] [stdout]     |
[INFO] [stdout] 383 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:383:21
[INFO] [stdout]     |
[INFO] [stdout] 383 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:383:21
[INFO] [stdout]     |
[INFO] [stdout] 383 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:387:21
[INFO] [stdout]     |
[INFO] [stdout] 387 |       assert!(deque.push_back(b'x').is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:387:21
[INFO] [stdout]     |
[INFO] [stdout] 387 |       assert!(deque.push_back(b'x').is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:389:19
[INFO] [stdout]     |
[INFO] [stdout] 389 |     assert!(deque.push_back(0xC3).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:389:19
[INFO] [stdout]     |
[INFO] [stdout] 389 |     assert!(deque.push_back(0xC3).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:391:13
[INFO] [stdout]     |
[INFO] [stdout] 391 |       deque.pop_front();
[INFO] [stdout]     |             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:391:13
[INFO] [stdout]     |
[INFO] [stdout] 391 |       deque.pop_front();
[INFO] [stdout]     |             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:393:19
[INFO] [stdout]     |
[INFO] [stdout] 393 |     assert!(deque.push_back(0xA9).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:393:19
[INFO] [stdout]     |
[INFO] [stdout] 393 |     assert!(deque.push_back(0xA9).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:395:31
[INFO] [stdout]     |
[INFO] [stdout] 395 |     let (front, back) = deque.as_slices();
[INFO] [stdout]     |                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:395:31
[INFO] [stdout]     |
[INFO] [stdout] 395 |     let (front, back) = deque.as_slices();
[INFO] [stdout]     |                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:400:19
[INFO] [stdout]     |
[INFO] [stdout] 400 |     let n = deque.read_to_string(&mut s).unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:400:13
[INFO] [stdout]     |
[INFO] [stdout] 400 |     let n = deque.read_to_string(&mut s).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:400:19
[INFO] [stdout]     |
[INFO] [stdout] 400 |     let n = deque.read_to_string(&mut s).unwrap();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:403:19
[INFO] [stdout]     |
[INFO] [stdout] 403 |     assert!(deque.is_empty());
[INFO] [stdout]     |                   ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:403:19
[INFO] [stdout]     |
[INFO] [stdout] 403 |     assert!(deque.is_empty());
[INFO] [stdout]     |                   ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:410:21
[INFO] [stdout]     |
[INFO] [stdout] 410 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:410:50
[INFO] [stdout]     |
[INFO] [stdout] 410 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:410:21
[INFO] [stdout]     |
[INFO] [stdout] 410 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:410:21
[INFO] [stdout]     |
[INFO] [stdout] 410 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:412:13
[INFO] [stdout]     |
[INFO] [stdout] 412 |     let n = Write::write_vectored(&mut deque, &slices).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:412:13
[INFO] [stdout]     |
[INFO] [stdout] 412 |     let n = Write::write_vectored(&mut deque, &slices).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:412:35
[INFO] [stdout]     |
[INFO] [stdout] 412 |     let n = Write::write_vectored(&mut deque, &slices).unwrap();
[INFO] [stdout]     |                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:414:22
[INFO] [stdout]     |
[INFO] [stdout] 414 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:414:22
[INFO] [stdout]     |
[INFO] [stdout] 414 |     assert_eq!(deque.len(), 4);
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:415:22
[INFO] [stdout]     |
[INFO] [stdout] 415 |     assert_eq!(deque.iter().copied().collect::<Vec<_>>(), b"1234");
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:415:22
[INFO] [stdout]     |
[INFO] [stdout] 415 |     assert_eq!(deque.iter().copied().collect::<Vec<_>>(), b"1234");
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:422:21
[INFO] [stdout]     |
[INFO] [stdout] 422 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:422:50
[INFO] [stdout]     |
[INFO] [stdout] 422 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:422:21
[INFO] [stdout]     |
[INFO] [stdout] 422 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:422:21
[INFO] [stdout]     |
[INFO] [stdout] 422 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:424:21
[INFO] [stdout]     |
[INFO] [stdout] 424 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:424:21
[INFO] [stdout]     |
[INFO] [stdout] 424 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Read`
[INFO] [stdout]    --> src/io.rs:427:11
[INFO] [stdout]     |
[INFO] [stdout] 427 |     deque.read_exact(&mut buf).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:427:5
[INFO] [stdout]     |
[INFO] [stdout] 427 |     deque.read_exact(&mut buf).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:427:11
[INFO] [stdout]     |
[INFO] [stdout] 427 |     deque.read_exact(&mut buf).unwrap();
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:429:22
[INFO] [stdout]     |
[INFO] [stdout] 429 |     assert_eq!(deque.iter().copied().collect::<Vec<_>>(), b"cd");
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:429:22
[INFO] [stdout]     |
[INFO] [stdout] 429 |     assert_eq!(deque.iter().copied().collect::<Vec<_>>(), b"cd");
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:435:21
[INFO] [stdout]     |
[INFO] [stdout] 435 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:435:50
[INFO] [stdout]     |
[INFO] [stdout] 435 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:435:21
[INFO] [stdout]     |
[INFO] [stdout] 435 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:435:21
[INFO] [stdout]     |
[INFO] [stdout] 435 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:437:21
[INFO] [stdout]     |
[INFO] [stdout] 437 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:437:21
[INFO] [stdout]     |
[INFO] [stdout] 437 |       assert!(deque.push_back(*byte).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:439:16
[INFO] [stdout]     |
[INFO] [stdout] 439 |     assert_eq!(Write::write(&mut deque, b"xx").unwrap(), 0);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:439:16
[INFO] [stdout]     |
[INFO] [stdout] 439 |     assert_eq!(Write::write(&mut deque, b"xx").unwrap(), 0);
[INFO] [stdout]     |                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:439:29
[INFO] [stdout]     |
[INFO] [stdout] 439 |     assert_eq!(Write::write(&mut deque, b"xx").unwrap(), 0);
[INFO] [stdout]     |                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:442:21
[INFO] [stdout]     |
[INFO] [stdout] 442 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:442:50
[INFO] [stdout]     |
[INFO] [stdout] 442 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:442:21
[INFO] [stdout]     |
[INFO] [stdout] 442 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:442:21
[INFO] [stdout]     |
[INFO] [stdout] 442 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:443:16
[INFO] [stdout]     |
[INFO] [stdout] 443 |     assert_eq!(Write::write(&mut deque, b"").unwrap(), 0);
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:443:16
[INFO] [stdout]     |
[INFO] [stdout] 443 |     assert_eq!(Write::write(&mut deque, b"").unwrap(), 0);
[INFO] [stdout]     |                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:443:29
[INFO] [stdout]     |
[INFO] [stdout] 443 |     assert_eq!(Write::write(&mut deque, b"").unwrap(), 0);
[INFO] [stdout]     |                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:450:21
[INFO] [stdout]     |
[INFO] [stdout] 450 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:450:50
[INFO] [stdout]     |
[INFO] [stdout] 450 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                                                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:450:21
[INFO] [stdout]     |
[INFO] [stdout] 450 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:450:21
[INFO] [stdout]     |
[INFO] [stdout] 450 |     let mut deque = GenericArrayDeque::<u8, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>: std::io::Write`
[INFO] [stdout]    --> src/io.rs:452:13
[INFO] [stdout]     |
[INFO] [stdout] 452 |     let n = Write::write_vectored(&mut deque, &slices).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:452:13
[INFO] [stdout]     |
[INFO] [stdout] 452 |     let n = Write::write_vectored(&mut deque, &slices).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:452:35
[INFO] [stdout]     |
[INFO] [stdout] 452 |     let n = Write::write_vectored(&mut deque, &slices).unwrap();
[INFO] [stdout]     |                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/io.rs:454:22
[INFO] [stdout]     |
[INFO] [stdout] 454 |     assert_eq!(deque.iter().copied().collect::<Vec<_>>(), b"ab");
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<u8, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/io.rs:454:22
[INFO] [stdout]     |
[INFO] [stdout] 454 |     assert_eq!(deque.iter().copied().collect::<Vec<_>>(), b"ab");
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:155:49
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:155:21
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:157:21
[INFO] [stdout]     |
[INFO] [stdout] 157 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:159:22
[INFO] [stdout]     |
[INFO] [stdout] 159 |     assert_eq!(deque.pop_front(), Some(0));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:160:19
[INFO] [stdout]     |
[INFO] [stdout] 160 |     assert!(deque.push_back(4).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:162:26
[INFO] [stdout]     |
[INFO] [stdout] 162 |     let mut iter = deque.iter();
[INFO] [stdout]     |                          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:155:21
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:155:21
[INFO] [stdout]     |
[INFO] [stdout] 155 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:157:21
[INFO] [stdout]     |
[INFO] [stdout] 157 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:159:22
[INFO] [stdout]     |
[INFO] [stdout] 159 |     assert_eq!(deque.pop_front(), Some(0));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:160:19
[INFO] [stdout]     |
[INFO] [stdout] 160 |     assert!(deque.push_back(4).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:162:26
[INFO] [stdout]     |
[INFO] [stdout] 162 |     let mut iter = deque.iter();
[INFO] [stdout]     |                          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:171:49
[INFO] [stdout]     |
[INFO] [stdout] 171 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:171:21
[INFO] [stdout]     |
[INFO] [stdout] 171 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:173:21
[INFO] [stdout]     |
[INFO] [stdout] 173 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:176:26
[INFO] [stdout]     |
[INFO] [stdout] 176 |     let mut iter = deque.iter();
[INFO] [stdout]     |                          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:171:21
[INFO] [stdout]     |
[INFO] [stdout] 171 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:171:21
[INFO] [stdout]     |
[INFO] [stdout] 171 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:173:21
[INFO] [stdout]     |
[INFO] [stdout] 173 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:176:26
[INFO] [stdout]     |
[INFO] [stdout] 176 |     let mut iter = deque.iter();
[INFO] [stdout]     |                          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:189:49
[INFO] [stdout]     |
[INFO] [stdout] 189 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:189:21
[INFO] [stdout]     |
[INFO] [stdout] 189 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:191:21
[INFO] [stdout]     |
[INFO] [stdout] 191 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:193:22
[INFO] [stdout]     |
[INFO] [stdout] 193 |     let iter = deque.iter();
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:189:21
[INFO] [stdout]     |
[INFO] [stdout] 189 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:189:21
[INFO] [stdout]     |
[INFO] [stdout] 189 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:191:21
[INFO] [stdout]     |
[INFO] [stdout] 191 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:193:22
[INFO] [stdout]     |
[INFO] [stdout] 193 |     let iter = deque.iter();
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:202:49
[INFO] [stdout]     |
[INFO] [stdout] 202 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:202:21
[INFO] [stdout]     |
[INFO] [stdout] 202 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:204:21
[INFO] [stdout]     |
[INFO] [stdout] 204 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:206:26
[INFO] [stdout]     |
[INFO] [stdout] 206 |     let mut iter = deque.iter();
[INFO] [stdout]     |                          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:202:21
[INFO] [stdout]     |
[INFO] [stdout] 202 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:202:21
[INFO] [stdout]     |
[INFO] [stdout] 202 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:204:21
[INFO] [stdout]     |
[INFO] [stdout] 204 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:206:26
[INFO] [stdout]     |
[INFO] [stdout] 206 |     let mut iter = deque.iter();
[INFO] [stdout]     |                          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:216:49
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:216:21
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:218:21
[INFO] [stdout]     |
[INFO] [stdout] 218 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter.rs:220:22
[INFO] [stdout]     |
[INFO] [stdout] 220 |     assert_eq!(deque.iter().last(), Some(&3));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:216:21
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:216:21
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let mut deque = GenericArrayDeque::<_, U4>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:218:21
[INFO] [stdout]     |
[INFO] [stdout] 218 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B0>> well-formed`
[INFO] [stdout]    --> src/iter.rs:220:22
[INFO] [stdout]     |
[INFO] [stdout] 220 |     assert_eq!(deque.iter().last(), Some(&3));
[INFO] [stdout]     |                      ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:186:49
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:186:21
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:188:21
[INFO] [stdout]     |
[INFO] [stdout] 188 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:190:22
[INFO] [stdout]     |
[INFO] [stdout] 190 |     assert_eq!(deque.pop_front(), Some(0));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:191:19
[INFO] [stdout]     |
[INFO] [stdout] 191 |     assert!(deque.push_back(5).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:193:26
[INFO] [stdout]     |
[INFO] [stdout] 193 |     let mut iter = deque.iter_mut();
[INFO] [stdout]     |                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:186:21
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:186:21
[INFO] [stdout]     |
[INFO] [stdout] 186 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:188:21
[INFO] [stdout]     |
[INFO] [stdout] 188 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:190:22
[INFO] [stdout]     |
[INFO] [stdout] 190 |     assert_eq!(deque.pop_front(), Some(0));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:191:19
[INFO] [stdout]     |
[INFO] [stdout] 191 |     assert!(deque.push_back(5).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:193:26
[INFO] [stdout]     |
[INFO] [stdout] 193 |     let mut iter = deque.iter_mut();
[INFO] [stdout]     |                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:203:16
[INFO] [stdout]     |
[INFO] [stdout] 203 |     assert_eq!(deque[0], 1);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:204:16
[INFO] [stdout]     |
[INFO] [stdout] 204 |     assert_eq!(deque[1], 10);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:205:16
[INFO] [stdout]     |
[INFO] [stdout] 205 |     assert_eq!(deque[4], 50);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   |
[INFO] [stdout]   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]   = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]   = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]   = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/iter_mut.rs:203:16
[INFO] [stdout]     |
[INFO] [stdout] 203 |     assert_eq!(deque[0], 1);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/iter_mut.rs:204:16
[INFO] [stdout]     |
[INFO] [stdout] 204 |     assert_eq!(deque[1], 10);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/iter_mut.rs:205:16
[INFO] [stdout]     |
[INFO] [stdout] 205 |     assert_eq!(deque[4], 50);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:210:49
[INFO] [stdout]     |
[INFO] [stdout] 210 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:210:21
[INFO] [stdout]     |
[INFO] [stdout] 210 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:212:21
[INFO] [stdout]     |
[INFO] [stdout] 212 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:214:22
[INFO] [stdout]     |
[INFO] [stdout] 214 |     assert_eq!(deque.pop_front(), Some(0));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:215:19
[INFO] [stdout]     |
[INFO] [stdout] 215 |     assert!(deque.push_back(5).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:217:26
[INFO] [stdout]     |
[INFO] [stdout] 217 |     let mut iter = deque.iter_mut();
[INFO] [stdout]     |                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:210:21
[INFO] [stdout]     |
[INFO] [stdout] 210 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:210:21
[INFO] [stdout]     |
[INFO] [stdout] 210 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:212:21
[INFO] [stdout]     |
[INFO] [stdout] 212 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:214:22
[INFO] [stdout]     |
[INFO] [stdout] 214 |     assert_eq!(deque.pop_front(), Some(0));
[INFO] [stdout]     |                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:215:19
[INFO] [stdout]     |
[INFO] [stdout] 215 |     assert!(deque.push_back(5).is_none());
[INFO] [stdout]     |                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:217:26
[INFO] [stdout]     |
[INFO] [stdout] 217 |     let mut iter = deque.iter_mut();
[INFO] [stdout]     |                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:226:49
[INFO] [stdout]     |
[INFO] [stdout] 226 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:228:21
[INFO] [stdout]     |
[INFO] [stdout] 228 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:231:23
[INFO] [stdout]     |
[INFO] [stdout] 231 |       let sum = deque.iter_mut().fold(0, |acc, item| acc + *item);
[INFO] [stdout]     |                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:235:23
[INFO] [stdout]     |
[INFO] [stdout] 235 |       let sum = deque.iter_mut().rfold(0, |acc, item| acc + *item);
[INFO] [stdout]     |                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:228:21
[INFO] [stdout]     |
[INFO] [stdout] 228 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:231:23
[INFO] [stdout]     |
[INFO] [stdout] 231 |       let sum = deque.iter_mut().fold(0, |acc, item| acc + *item);
[INFO] [stdout]     |                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:235:23
[INFO] [stdout]     |
[INFO] [stdout] 235 |       let sum = deque.iter_mut().rfold(0, |acc, item| acc + *item);
[INFO] [stdout]     |                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:242:49
[INFO] [stdout]     |
[INFO] [stdout] 242 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:242:21
[INFO] [stdout]     |
[INFO] [stdout] 242 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:244:21
[INFO] [stdout]     |
[INFO] [stdout] 244 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:246:26
[INFO] [stdout]     |
[INFO] [stdout] 246 |     let mut iter = deque.iter_mut();
[INFO] [stdout]     |                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:242:21
[INFO] [stdout]     |
[INFO] [stdout] 242 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:242:21
[INFO] [stdout]     |
[INFO] [stdout] 242 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:244:21
[INFO] [stdout]     |
[INFO] [stdout] 244 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:246:26
[INFO] [stdout]     |
[INFO] [stdout] 246 |     let mut iter = deque.iter_mut();
[INFO] [stdout]     |                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:256:49
[INFO] [stdout]     |
[INFO] [stdout] 256 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:256:21
[INFO] [stdout]     |
[INFO] [stdout] 256 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:258:21
[INFO] [stdout]     |
[INFO] [stdout] 258 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/iter_mut.rs:260:31
[INFO] [stdout]     |
[INFO] [stdout] 260 |     if let Some(last) = deque.iter_mut().last() {
[INFO] [stdout]     |                               ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:256:21
[INFO] [stdout]     |
[INFO] [stdout] 256 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:256:21
[INFO] [stdout]     |
[INFO] [stdout] 256 |     let mut deque = GenericArrayDeque::<_, U5>::new();
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:258:21
[INFO] [stdout]     |
[INFO] [stdout] 258 |       assert!(deque.push_back(value).is_none());
[INFO] [stdout]     |                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:260:31
[INFO] [stdout]     |
[INFO] [stdout] 260 |     if let Some(last) = deque.iter_mut().last() {
[INFO] [stdout]     |                               ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/iter_mut.rs:263:16
[INFO] [stdout]     |
[INFO] [stdout] 263 |     assert_eq!(deque[4], 99);
[INFO] [stdout]     |                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the type `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]    --> src/iter_mut.rs:263:16
[INFO] [stdout]     |
[INFO] [stdout] 263 |     assert_eq!(deque[4], 99);
[INFO] [stdout]     |                ^^^^^^^^ `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>` cannot be indexed by `i32`
[INFO] [stdout]     |
[INFO] [stdout] help: the trait `Index<i32>` is not implemented for `GenericArrayDeque<i32, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>`
[INFO] [stdout]       but trait `Index<usize>` is implemented for it
[INFO] [stdout]    --> src/lib.rs:311:1
[INFO] [stdout]     |
[INFO] [stdout] 311 | impl<T, N: ArrayLength> Index<usize> for GenericArrayDeque<T, N> {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = help: for that trait implementation, expected `usize`, found `i32`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:22:22
[INFO] [stdout]    |
[INFO] [stdout] 22 |     let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:22:56
[INFO] [stdout]    |
[INFO] [stdout] 22 |     let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                                                        ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:22:22
[INFO] [stdout]    |
[INFO] [stdout] 22 |     let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:22:22
[INFO] [stdout]    |
[INFO] [stdout] 22 |     let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:23:29
[INFO] [stdout]    |
[INFO] [stdout] 23 |     let usable_cap = tester.capacity();
[INFO] [stdout]    |                             ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:23:29
[INFO] [stdout]    |
[INFO] [stdout] 23 |     let usable_cap = tester.capacity();
[INFO] [stdout]    |                             ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:27:21
[INFO] [stdout]    |
[INFO] [stdout] 27 |       let expected: GenericArrayDeque<_, U15> = if back {
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |         GenericArrayDeque::try_from_exact_iter((0..len).map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |         GenericArrayDeque::try_from_exact_iter((0..len).map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |         GenericArrayDeque::try_from_exact_iter((0..len).map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |         GenericArrayDeque::try_from_exact_iter((0..len).map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:28:65
[INFO] [stdout]    |
[INFO] [stdout] 28 |         GenericArrayDeque::try_from_exact_iter((0..len).map(s)).unwrap()
[INFO] [stdout]    |                                                                 ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:28:65
[INFO] [stdout]    |
[INFO] [stdout] 28 |         GenericArrayDeque::try_from_exact_iter((0..len).map(s)).unwrap()
[INFO] [stdout]    |                                                                 ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |         GenericArrayDeque::try_from_exact_iter((0..len).rev().map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |         GenericArrayDeque::try_from_exact_iter((0..len).rev().map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |         GenericArrayDeque::try_from_exact_iter((0..len).rev().map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |         GenericArrayDeque::try_from_exact_iter((0..len).rev().map(s)).unwrap()
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:30:71
[INFO] [stdout]    |
[INFO] [stdout] 30 |         GenericArrayDeque::try_from_exact_iter((0..len).rev().map(s)).unwrap()
[INFO] [stdout]    |                                                                       ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:30:71
[INFO] [stdout]    |
[INFO] [stdout] 30 |         GenericArrayDeque::try_from_exact_iter((0..len).rev().map(s)).unwrap()
[INFO] [stdout]    |                                                                       ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:33:16
[INFO] [stdout]    |
[INFO] [stdout] 33 |         tester.clear();
[INFO] [stdout]    |                ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:33:16
[INFO] [stdout]    |
[INFO] [stdout] 33 |         tester.clear();
[INFO] [stdout]    |                ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:38:20
[INFO] [stdout]    |
[INFO] [stdout] 38 |             tester.push_front(s(i));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:38:20
[INFO] [stdout]    |
[INFO] [stdout] 38 |             tester.push_front(s(i));
[INFO] [stdout]    |                    ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:41:31
[INFO] [stdout]    |
[INFO] [stdout] 41 |             assert_eq!(tester.swap_remove_back(i), Some(s(len * 2 - 1 - i)));
[INFO] [stdout]    |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:41:31
[INFO] [stdout]    |
[INFO] [stdout] 41 |             assert_eq!(tester.swap_remove_back(i), Some(s(len * 2 - 1 - i)));
[INFO] [stdout]    |                               ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:45:20
[INFO] [stdout]    |
[INFO] [stdout] 45 |             tester.push_back(s(i));
[INFO] [stdout]    |                    ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:45:20
[INFO] [stdout]    |
[INFO] [stdout] 45 |             tester.push_back(s(i));
[INFO] [stdout]    |                    ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:48:30
[INFO] [stdout]    |
[INFO] [stdout] 48 |             let idx = tester.len() - 1 - i;
[INFO] [stdout]    |                              ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:48:30
[INFO] [stdout]    |
[INFO] [stdout] 48 |             let idx = tester.len() - 1 - i;
[INFO] [stdout]    |                              ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:49:31
[INFO] [stdout]    |
[INFO] [stdout] 49 |             assert_eq!(tester.swap_remove_front(idx), Some(s(len * 2 - 1 - i)));
[INFO] [stdout]    |                               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:49:31
[INFO] [stdout]    |
[INFO] [stdout] 49 |             assert_eq!(tester.swap_remove_front(idx), Some(s(len * 2 - 1 - i)));
[INFO] [stdout]    |                               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:52:39
[INFO] [stdout]    |
[INFO] [stdout] 52 |         assert!(tester.head <= tester.capacity());
[INFO] [stdout]    |                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:52:39
[INFO] [stdout]    |
[INFO] [stdout] 52 |         assert!(tester.head <= tester.capacity());
[INFO] [stdout]    |                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:53:38
[INFO] [stdout]    |
[INFO] [stdout] 53 |         assert!(tester.len <= tester.capacity());
[INFO] [stdout]    |                                      ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:53:38
[INFO] [stdout]    |
[INFO] [stdout] 53 |         assert!(tester.len <= tester.capacity());
[INFO] [stdout]    |                                      ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:54:9
[INFO] [stdout]    |
[INFO] [stdout] 54 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>: PartialEq`
[INFO] [stdout]   --> src/heap_tests.rs:54:9
[INFO] [stdout]    |
[INFO] [stdout] 54 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>: Debug`
[INFO] [stdout]   --> src/heap_tests.rs:54:9
[INFO] [stdout]    |
[INFO] [stdout] 54 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:54:9
[INFO] [stdout]    |
[INFO] [stdout] 54 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:54:9
[INFO] [stdout]    |
[INFO] [stdout] 54 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:54:9
[INFO] [stdout]    |
[INFO] [stdout] 54 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:64:20
[INFO] [stdout]    |
[INFO] [stdout] 64 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:64:54
[INFO] [stdout]    |
[INFO] [stdout] 64 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                                                      ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:64:20
[INFO] [stdout]    |
[INFO] [stdout] 64 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:64:20
[INFO] [stdout]    |
[INFO] [stdout] 64 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:65:20
[INFO] [stdout]    |
[INFO] [stdout] 65 |   let cap = tester.capacity();
[INFO] [stdout]    |                    ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:65:20
[INFO] [stdout]    |
[INFO] [stdout] 65 |   let cap = tester.capacity();
[INFO] [stdout]    |                    ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:68:20
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:68:54
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                                                      ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:68:20
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:68:92
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                                                                                            ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:68:20
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:71:16
[INFO] [stdout]    |
[INFO] [stdout] 71 |         tester.clear();
[INFO] [stdout]    |                ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:71:16
[INFO] [stdout]    |
[INFO] [stdout] 71 |         tester.clear();
[INFO] [stdout]    |                ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:76:20
[INFO] [stdout]    |
[INFO] [stdout] 76 |             tester.push_back(s(i));
[INFO] [stdout]    |                    ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:76:20
[INFO] [stdout]    |
[INFO] [stdout] 76 |             tester.push_back(s(i));
[INFO] [stdout]    |                    ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:79:16
[INFO] [stdout]    |
[INFO] [stdout] 79 |         tester.insert(to_insert, s(to_insert));
[INFO] [stdout]    |                ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:79:16
[INFO] [stdout]    |
[INFO] [stdout] 79 |         tester.insert(to_insert, s(to_insert));
[INFO] [stdout]    |                ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:80:39
[INFO] [stdout]    |
[INFO] [stdout] 80 |         assert!(tester.head <= tester.capacity());
[INFO] [stdout]    |                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:80:39
[INFO] [stdout]    |
[INFO] [stdout] 80 |         assert!(tester.head <= tester.capacity());
[INFO] [stdout]    |                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:81:38
[INFO] [stdout]    |
[INFO] [stdout] 81 |         assert!(tester.len <= tester.capacity());
[INFO] [stdout]    |                                      ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:81:38
[INFO] [stdout]    |
[INFO] [stdout] 81 |         assert!(tester.len <= tester.capacity());
[INFO] [stdout]    |                                      ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>: PartialEq`
[INFO] [stdout]   --> src/heap_tests.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>: Debug`
[INFO] [stdout]   --> src/heap_tests.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |         assert_eq!(tester, expected);
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:68:20
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _): Debug`
[INFO] [stdout]   --> src/heap_tests.rs:68:92
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                                                                                            ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _) well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:68:20
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:68:92
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let expected = GenericArrayDeque::<String, U15>::try_from_iter((0..).take(len).map(s)).unwrap();
[INFO] [stdout]    |                                                                                            ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:90:20
[INFO] [stdout]    |
[INFO] [stdout] 90 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:90:53
[INFO] [stdout]    |
[INFO] [stdout] 90 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]    |                                                     ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:90:20
[INFO] [stdout]    |
[INFO] [stdout] 90 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:90:20
[INFO] [stdout]    |
[INFO] [stdout] 90 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:91:10
[INFO] [stdout]    |
[INFO] [stdout] 91 |   tester.push_back(s(1));
[INFO] [stdout]    |          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:91:10
[INFO] [stdout]    |
[INFO] [stdout] 91 |   tester.push_back(s(1));
[INFO] [stdout]    |          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:92:10
[INFO] [stdout]    |
[INFO] [stdout] 92 |   tester.push_back(s(2));
[INFO] [stdout]    |          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:92:10
[INFO] [stdout]    |
[INFO] [stdout] 92 |   tester.push_back(s(2));
[INFO] [stdout]    |          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:93:10
[INFO] [stdout]    |
[INFO] [stdout] 93 |   tester.push_back(s(3));
[INFO] [stdout]    |          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:93:10
[INFO] [stdout]    |
[INFO] [stdout] 93 |   tester.push_back(s(3));
[INFO] [stdout]    |          ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]   --> src/heap_tests.rs:95:30
[INFO] [stdout]    |
[INFO] [stdout] 95 |   if let Some(elem) = tester.get_mut(0) {
[INFO] [stdout]    |                              ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]   --> src/heap_tests.rs:95:30
[INFO] [stdout]    |
[INFO] [stdout] 95 |   if let Some(elem) = tester.get_mut(0) {
[INFO] [stdout]    |                              ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]    = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]    = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:100:30
[INFO] [stdout]     |
[INFO] [stdout] 100 |   if let Some(elem) = tester.get_mut(2) {
[INFO] [stdout]     |                              ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:100:30
[INFO] [stdout]     |
[INFO] [stdout] 100 |   if let Some(elem) = tester.get_mut(2) {
[INFO] [stdout]     |                              ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:105:21
[INFO] [stdout]     |
[INFO] [stdout] 105 |   assert_eq!(tester.get(0).map(|v| v.as_str()), Some("10"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:105:21
[INFO] [stdout]     |
[INFO] [stdout] 105 |   assert_eq!(tester.get(0).map(|v| v.as_str()), Some("10"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:106:21
[INFO] [stdout]     |
[INFO] [stdout] 106 |   assert_eq!(tester.get(2).map(|v| v.as_str()), Some("30"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:106:21
[INFO] [stdout]     |
[INFO] [stdout] 106 |   assert_eq!(tester.get(2).map(|v| v.as_str()), Some("30"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:107:21
[INFO] [stdout]     |
[INFO] [stdout] 107 |   assert_eq!(tester.get_mut(3), None);
[INFO] [stdout]     |                     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:107:21
[INFO] [stdout]     |
[INFO] [stdout] 107 |   assert_eq!(tester.get_mut(3), None);
[INFO] [stdout]     |                     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:109:10
[INFO] [stdout]     |
[INFO] [stdout] 109 |   tester.remove(2);
[INFO] [stdout]     |          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:109:10
[INFO] [stdout]     |
[INFO] [stdout] 109 |   tester.remove(2);
[INFO] [stdout]     |          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:110:21
[INFO] [stdout]     |
[INFO] [stdout] 110 |   assert_eq!(tester.len(), 2);
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:110:21
[INFO] [stdout]     |
[INFO] [stdout] 110 |   assert_eq!(tester.len(), 2);
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:111:21
[INFO] [stdout]     |
[INFO] [stdout] 111 |   assert_eq!(tester.get(1).map(|v| v.as_str()), Some("2"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:111:21
[INFO] [stdout]     |
[INFO] [stdout] 111 |   assert_eq!(tester.get(1).map(|v| v.as_str()), Some("2"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:116:20
[INFO] [stdout]     |
[INFO] [stdout] 116 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:116:53
[INFO] [stdout]     |
[INFO] [stdout] 116 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]     |                                                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:116:20
[INFO] [stdout]     |
[INFO] [stdout] 116 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:116:20
[INFO] [stdout]     |
[INFO] [stdout] 116 |   let mut tester = GenericArrayDeque::<String, U5>::new();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:117:10
[INFO] [stdout]     |
[INFO] [stdout] 117 |   tester.push_back(s(1));
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:117:10
[INFO] [stdout]     |
[INFO] [stdout] 117 |   tester.push_back(s(1));
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:118:10
[INFO] [stdout]     |
[INFO] [stdout] 118 |   tester.push_back(s(2));
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:118:10
[INFO] [stdout]     |
[INFO] [stdout] 118 |   tester.push_back(s(2));
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:119:10
[INFO] [stdout]     |
[INFO] [stdout] 119 |   tester.push_back(s(3));
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:119:10
[INFO] [stdout]     |
[INFO] [stdout] 119 |   tester.push_back(s(3));
[INFO] [stdout]     |          ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:121:10
[INFO] [stdout]     |
[INFO] [stdout] 121 |   tester.swap(0, 0);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:121:10
[INFO] [stdout]     |
[INFO] [stdout] 121 |   tester.swap(0, 0);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:122:3
[INFO] [stdout]     |
[INFO] [stdout] 122 |   assert_eq!(tester, sarr![1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: PartialEq<[String; 3]>`
[INFO] [stdout]    --> src/heap_tests.rs:122:3
[INFO] [stdout]     |
[INFO] [stdout] 122 |   assert_eq!(tester, sarr![1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:122:3
[INFO] [stdout]     |
[INFO] [stdout] 122 |   assert_eq!(tester, sarr![1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:122:3
[INFO] [stdout]     |
[INFO] [stdout] 122 |   assert_eq!(tester, sarr![1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:122:3
[INFO] [stdout]     |
[INFO] [stdout] 122 |   assert_eq!(tester, sarr![1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:123:10
[INFO] [stdout]     |
[INFO] [stdout] 123 |   tester.swap(0, 1);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:123:10
[INFO] [stdout]     |
[INFO] [stdout] 123 |   tester.swap(0, 1);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: PartialEq<[String; 3]>`
[INFO] [stdout]    --> src/heap_tests.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:125:10
[INFO] [stdout]     |
[INFO] [stdout] 125 |   tester.swap(2, 1);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:125:10
[INFO] [stdout]     |
[INFO] [stdout] 125 |   tester.swap(2, 1);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:126:3
[INFO] [stdout]     |
[INFO] [stdout] 126 |   assert_eq!(tester, sarr![2, 3, 1]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: PartialEq<[String; 3]>`
[INFO] [stdout]    --> src/heap_tests.rs:126:3
[INFO] [stdout]     |
[INFO] [stdout] 126 |   assert_eq!(tester, sarr![2, 3, 1]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:126:3
[INFO] [stdout]     |
[INFO] [stdout] 126 |   assert_eq!(tester, sarr![2, 3, 1]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:126:3
[INFO] [stdout]     |
[INFO] [stdout] 126 |   assert_eq!(tester, sarr![2, 3, 1]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:126:3
[INFO] [stdout]     |
[INFO] [stdout] 126 |   assert_eq!(tester, sarr![2, 3, 1]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:127:10
[INFO] [stdout]     |
[INFO] [stdout] 127 |   tester.swap(1, 2);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:127:10
[INFO] [stdout]     |
[INFO] [stdout] 127 |   tester.swap(1, 2);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:128:3
[INFO] [stdout]     |
[INFO] [stdout] 128 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: PartialEq<[String; 3]>`
[INFO] [stdout]    --> src/heap_tests.rs:128:3
[INFO] [stdout]     |
[INFO] [stdout] 128 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:128:3
[INFO] [stdout]     |
[INFO] [stdout] 128 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:128:3
[INFO] [stdout]     |
[INFO] [stdout] 128 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:128:3
[INFO] [stdout]     |
[INFO] [stdout] 128 |   assert_eq!(tester, sarr![2, 1, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:129:10
[INFO] [stdout]     |
[INFO] [stdout] 129 |   tester.swap(0, 2);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:129:10
[INFO] [stdout]     |
[INFO] [stdout] 129 |   tester.swap(0, 2);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:130:3
[INFO] [stdout]     |
[INFO] [stdout] 130 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: PartialEq<[String; 3]>`
[INFO] [stdout]    --> src/heap_tests.rs:130:3
[INFO] [stdout]     |
[INFO] [stdout] 130 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:130:3
[INFO] [stdout]     |
[INFO] [stdout] 130 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:130:3
[INFO] [stdout]     |
[INFO] [stdout] 130 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:130:3
[INFO] [stdout]     |
[INFO] [stdout] 130 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B0>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:131:10
[INFO] [stdout]     |
[INFO] [stdout] 131 |   tester.swap(2, 2);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:131:10
[INFO] [stdout]     |
[INFO] [stdout] 131 |   tester.swap(2, 2);
[INFO] [stdout]     |          ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:132:3
[INFO] [stdout]     |
[INFO] [stdout] 132 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: PartialEq<[String; 3]>`
[INFO] [stdout]    --> src/heap_tests.rs:132:3
[INFO] [stdout]     |
[INFO] [stdout] 132 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:132:3
[INFO] [stdout]     |
[INFO] [stdout] 132 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:132:3
[INFO] [stdout]     |
[INFO] [stdout] 132 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B0>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:132:3
[INFO] [stdout]     |
[INFO] [stdout] 132 |   assert_eq!(tester, sarr![3, 1, 2]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:137:19
[INFO] [stdout]     |
[INFO] [stdout] 137 |   let mut tester: GenericArrayDeque<_, U10> =
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:138:55
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |                                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:139:21
[INFO] [stdout]     |
[INFO] [stdout] 139 |   assert_eq!(tester.len(), 10);
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:139:21
[INFO] [stdout]     |
[INFO] [stdout] 139 |   assert_eq!(tester.len(), 10);
[INFO] [stdout]     |                     ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:141:10
[INFO] [stdout]     |
[INFO] [stdout] 141 |   tester.rotate_left(0);
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:141:10
[INFO] [stdout]     |
[INFO] [stdout] 141 |   tester.rotate_left(0);
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:142:3
[INFO] [stdout]     |
[INFO] [stdout] 142 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:142:3
[INFO] [stdout]     |
[INFO] [stdout] 142 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:142:3
[INFO] [stdout]     |
[INFO] [stdout] 142 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:142:3
[INFO] [stdout]     |
[INFO] [stdout] 142 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:142:3
[INFO] [stdout]     |
[INFO] [stdout] 142 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:144:10
[INFO] [stdout]     |
[INFO] [stdout] 144 |   tester.rotate_right(0);
[INFO] [stdout]     |          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:144:10
[INFO] [stdout]     |
[INFO] [stdout] 144 |   tester.rotate_right(0);
[INFO] [stdout]     |          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:145:3
[INFO] [stdout]     |
[INFO] [stdout] 145 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:145:3
[INFO] [stdout]     |
[INFO] [stdout] 145 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:145:3
[INFO] [stdout]     |
[INFO] [stdout] 145 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:145:3
[INFO] [stdout]     |
[INFO] [stdout] 145 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:145:3
[INFO] [stdout]     |
[INFO] [stdout] 145 |   assert_eq!(tester, sarr![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:147:10
[INFO] [stdout]     |
[INFO] [stdout] 147 |   tester.rotate_left(3);
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:147:10
[INFO] [stdout]     |
[INFO] [stdout] 147 |   tester.rotate_left(3);
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:148:3
[INFO] [stdout]     |
[INFO] [stdout] 148 |   assert_eq!(tester, sarr![4, 5, 6, 7, 8, 9, 10, 1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:148:3
[INFO] [stdout]     |
[INFO] [stdout] 148 |   assert_eq!(tester, sarr![4, 5, 6, 7, 8, 9, 10, 1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:148:3
[INFO] [stdout]     |
[INFO] [stdout] 148 |   assert_eq!(tester, sarr![4, 5, 6, 7, 8, 9, 10, 1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:148:3
[INFO] [stdout]     |
[INFO] [stdout] 148 |   assert_eq!(tester, sarr![4, 5, 6, 7, 8, 9, 10, 1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:148:3
[INFO] [stdout]     |
[INFO] [stdout] 148 |   assert_eq!(tester, sarr![4, 5, 6, 7, 8, 9, 10, 1, 2, 3]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:150:10
[INFO] [stdout]     |
[INFO] [stdout] 150 |   tester.rotate_right(5);
[INFO] [stdout]     |          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:150:10
[INFO] [stdout]     |
[INFO] [stdout] 150 |   tester.rotate_right(5);
[INFO] [stdout]     |          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:153:10
[INFO] [stdout]     |
[INFO] [stdout] 153 |   tester.rotate_left(tester.len());
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:153:29
[INFO] [stdout]     |
[INFO] [stdout] 153 |   tester.rotate_left(tester.len());
[INFO] [stdout]     |                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:153:10
[INFO] [stdout]     |
[INFO] [stdout] 153 |   tester.rotate_left(tester.len());
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:153:29
[INFO] [stdout]     |
[INFO] [stdout] 153 |   tester.rotate_left(tester.len());
[INFO] [stdout]     |                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:154:3
[INFO] [stdout]     |
[INFO] [stdout] 154 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:154:3
[INFO] [stdout]     |
[INFO] [stdout] 154 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:154:3
[INFO] [stdout]     |
[INFO] [stdout] 154 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:154:3
[INFO] [stdout]     |
[INFO] [stdout] 154 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:154:3
[INFO] [stdout]     |
[INFO] [stdout] 154 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:156:10
[INFO] [stdout]     |
[INFO] [stdout] 156 |   tester.rotate_right(tester.len());
[INFO] [stdout]     |          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:156:30
[INFO] [stdout]     |
[INFO] [stdout] 156 |   tester.rotate_right(tester.len());
[INFO] [stdout]     |                              ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:156:10
[INFO] [stdout]     |
[INFO] [stdout] 156 |   tester.rotate_right(tester.len());
[INFO] [stdout]     |          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:156:30
[INFO] [stdout]     |
[INFO] [stdout] 156 |   tester.rotate_right(tester.len());
[INFO] [stdout]     |                              ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:157:3
[INFO] [stdout]     |
[INFO] [stdout] 157 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:157:3
[INFO] [stdout]     |
[INFO] [stdout] 157 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:157:3
[INFO] [stdout]     |
[INFO] [stdout] 157 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:157:3
[INFO] [stdout]     |
[INFO] [stdout] 157 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:157:3
[INFO] [stdout]     |
[INFO] [stdout] 157 |   assert_eq!(tester, sarr![9, 10, 1, 2, 3, 4, 5, 6, 7, 8]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:159:10
[INFO] [stdout]     |
[INFO] [stdout] 159 |   tester.rotate_left(1);
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:159:10
[INFO] [stdout]     |
[INFO] [stdout] 159 |   tester.rotate_left(1);
[INFO] [stdout]     |          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:160:3
[INFO] [stdout]     |
[INFO] [stdout] 160 |   assert_eq!(tester, sarr![10, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: PartialEq<[String; 10]>`
[INFO] [stdout]    --> src/heap_tests.rs:160:3
[INFO] [stdout]     |
[INFO] [stdout] 160 |   assert_eq!(tester, sarr![10, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:160:3
[INFO] [stdout]     |
[INFO] [stdout] 160 |   assert_eq!(tester, sarr![10, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:160:3
[INFO] [stdout]     |
[INFO] [stdout] 160 |   assert_eq!(tester, sarr![10, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:160:3
[INFO] [stdout]     |
[INFO] [stdout] 160 |   assert_eq!(tester, sarr![10, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>, _): Debug`
[INFO] [stdout]    --> src/heap_tests.rs:138:55
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |                                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>, _) well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:138:55
[INFO] [stdout]     |
[INFO] [stdout] 138 |     GenericArrayDeque::try_from_iter((1..=10).map(s)).unwrap();
[INFO] [stdout]     |                                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:165:19
[INFO] [stdout]     |
[INFO] [stdout] 165 |   let mut tester: GenericArrayDeque<String, U7> = GenericArrayDeque::new();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:167:20
[INFO] [stdout]     |
[INFO] [stdout] 167 |   let cap = tester.capacity();
[INFO] [stdout]     |                    ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:165:51
[INFO] [stdout]     |
[INFO] [stdout] 165 |   let mut tester: GenericArrayDeque<String, U7> = GenericArrayDeque::new();
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:165:51
[INFO] [stdout]     |
[INFO] [stdout] 165 |   let mut tester: GenericArrayDeque<String, U7> = GenericArrayDeque::new();
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:165:51
[INFO] [stdout]     |
[INFO] [stdout] 165 |   let mut tester: GenericArrayDeque<String, U7> = GenericArrayDeque::new();
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:167:20
[INFO] [stdout]     |
[INFO] [stdout] 167 |   let cap = tester.capacity();
[INFO] [stdout]     |                    ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:172:18
[INFO] [stdout]     |
[INFO] [stdout] 172 |           tester.clear();
[INFO] [stdout]     |                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:172:18
[INFO] [stdout]     |
[INFO] [stdout] 172 |           tester.clear();
[INFO] [stdout]     |                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:176:20
[INFO] [stdout]     |
[INFO] [stdout] 176 |             tester.push_back(s(i));
[INFO] [stdout]     |                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:176:20
[INFO] [stdout]     |
[INFO] [stdout] 176 |             tester.push_back(s(i));
[INFO] [stdout]     |                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:180:53
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:53
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:53
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>: IntoIterator`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> as IntoIterator>::Item == _`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `<drain::Drain<'_, String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> as IntoIterator>::IntoIter == _`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `drain::Drain<'_, String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:46
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:179:24
[INFO] [stdout]     |
[INFO] [stdout] 179 |           let drained: GenericArrayDeque<_, U7> =
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _): Debug`
[INFO] [stdout]    --> src/heap_tests.rs:180:84
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                                                                    ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _) well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:13
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:84
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                                                                    ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:180:84
[INFO] [stdout]     |
[INFO] [stdout] 180 |             GenericArrayDeque::try_from_iter(tester.drain(drain_start..drain_end)).unwrap();
[INFO] [stdout]     |                                                                                    ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:181:33
[INFO] [stdout]     |
[INFO] [stdout] 181 |           let drained_expected: GenericArrayDeque<_, U7> =
[INFO] [stdout]     |                                 ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:182:13
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:182:13
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:182:13
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _): Debug`
[INFO] [stdout]    --> src/heap_tests.rs:182:79
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |                                                                               ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:182:13
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _) well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:182:13
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:182:79
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |                                                                               ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:182:79
[INFO] [stdout]     |
[INFO] [stdout] 182 |             GenericArrayDeque::try_from_iter((drain_start..drain_end).map(s)).unwrap();
[INFO] [stdout]     |                                                                               ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:183:11
[INFO] [stdout]     |
[INFO] [stdout] 183 |           assert_eq!(drained, drained_expected);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>: PartialEq`
[INFO] [stdout]    --> src/heap_tests.rs:183:11
[INFO] [stdout]     |
[INFO] [stdout] 183 |           assert_eq!(drained, drained_expected);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:183:11
[INFO] [stdout]     |
[INFO] [stdout] 183 |           assert_eq!(drained, drained_expected);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:183:11
[INFO] [stdout]     |
[INFO] [stdout] 183 |           assert_eq!(drained, drained_expected);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:183:11
[INFO] [stdout]     |
[INFO] [stdout] 183 |           assert_eq!(drained, drained_expected);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:183:11
[INFO] [stdout]     |
[INFO] [stdout] 183 |           assert_eq!(drained, drained_expected);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:185:29
[INFO] [stdout]     |
[INFO] [stdout] 185 |           assert_eq!(tester.capacity(), cap);
[INFO] [stdout]     |                             ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:185:29
[INFO] [stdout]     |
[INFO] [stdout] 185 |           assert_eq!(tester.capacity(), cap);
[INFO] [stdout]     |                             ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:186:41
[INFO] [stdout]     |
[INFO] [stdout] 186 |           assert!(tester.head <= tester.capacity());
[INFO] [stdout]     |                                         ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:186:41
[INFO] [stdout]     |
[INFO] [stdout] 186 |           assert!(tester.head <= tester.capacity());
[INFO] [stdout]     |                                         ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UTerm, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:187:40
[INFO] [stdout]     |
[INFO] [stdout] 187 |           assert!(tester.len <= tester.capacity());
[INFO] [stdout]     |                                        ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:187:40
[INFO] [stdout]     |
[INFO] [stdout] 187 |           assert!(tester.len <= tester.capacity());
[INFO] [stdout]     |                                        ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:189:25
[INFO] [stdout]     |
[INFO] [stdout] 189 |           let expected: GenericArrayDeque<_, U14> =
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:190:13
[INFO] [stdout]     |
[INFO] [stdout] 190 |             GenericArrayDeque::try_from_iter((0..drain_start).chain(drain_end..len).map(s))
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:190:13
[INFO] [stdout]     |
[INFO] [stdout] 190 |             GenericArrayDeque::try_from_iter((0..drain_start).chain(drain_end..len).map(s))
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:190:13
[INFO] [stdout]     |
[INFO] [stdout] 190 |             GenericArrayDeque::try_from_iter((0..drain_start).chain(drain_end..len).map(s))
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>, _): Debug`
[INFO] [stdout]    --> src/heap_tests.rs:191:16
[INFO] [stdout]     |
[INFO] [stdout] 191 |               .unwrap();
[INFO] [stdout]     |                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:190:13
[INFO] [stdout]     |
[INFO] [stdout] 190 | /             GenericArrayDeque::try_from_iter((0..drain_start).chain(drain_end..len).map(s))
[INFO] [stdout] 191 | |               .unwrap();
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>, _) well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:190:13
[INFO] [stdout]     |
[INFO] [stdout] 190 | /             GenericArrayDeque::try_from_iter((0..drain_start).chain(drain_end..len).map(s))
[INFO] [stdout] 191 | |               .unwrap();
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:191:16
[INFO] [stdout]     |
[INFO] [stdout] 191 |               .unwrap();
[INFO] [stdout]     |                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:191:16
[INFO] [stdout]     |
[INFO] [stdout] 191 |               .unwrap();
[INFO] [stdout]     |                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>: PartialEq<_>`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UTerm, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:192:11
[INFO] [stdout]     |
[INFO] [stdout] 192 |           assert_eq!(expected, tester);
[INFO] [stdout]     |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:201:20
[INFO] [stdout]     |
[INFO] [stdout] 201 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:201:54
[INFO] [stdout]     |
[INFO] [stdout] 201 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]     |                                                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:201:20
[INFO] [stdout]     |
[INFO] [stdout] 201 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:201:20
[INFO] [stdout]     |
[INFO] [stdout] 201 |   let mut tester = GenericArrayDeque::<String, U15>::new();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:202:20
[INFO] [stdout]     |
[INFO] [stdout] 202 |   let cap = tester.capacity();
[INFO] [stdout]     |                    ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:202:20
[INFO] [stdout]     |
[INFO] [stdout] 202 |   let cap = tester.capacity();
[INFO] [stdout]     |                    ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:208:9
[INFO] [stdout]     |
[INFO] [stdout] 208 |         GenericArrayDeque::<String, U15>::try_from_iter((0..).take(at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:208:43
[INFO] [stdout]     |
[INFO] [stdout] 208 |         GenericArrayDeque::<String, U15>::try_from_iter((0..).take(at).map(s)).unwrap();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:208:9
[INFO] [stdout]     |
[INFO] [stdout] 208 |         GenericArrayDeque::<String, U15>::try_from_iter((0..).take(at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:208:80
[INFO] [stdout]     |
[INFO] [stdout] 208 |         GenericArrayDeque::<String, U15>::try_from_iter((0..).take(at).map(s)).unwrap();
[INFO] [stdout]     |                                                                                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:208:9
[INFO] [stdout]     |
[INFO] [stdout] 208 |         GenericArrayDeque::<String, U15>::try_from_iter((0..).take(at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:210:9
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:210:43
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:210:9
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:210:87
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |                                                                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:210:9
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _): Debug`
[INFO] [stdout]    --> src/heap_tests.rs:210:87
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |                                                                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:210:9
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `(GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _) well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:210:9
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `Result<GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>, _> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:210:87
[INFO] [stdout]     |
[INFO] [stdout] 210 |         GenericArrayDeque::<String, U15>::try_from_iter((at..).take(len - at).map(s)).unwrap();
[INFO] [stdout]     |                                                                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:213:16
[INFO] [stdout]     |
[INFO] [stdout] 213 |         tester.clear();
[INFO] [stdout]     |                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:213:16
[INFO] [stdout]     |
[INFO] [stdout] 213 |         tester.clear();
[INFO] [stdout]     |                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:217:18
[INFO] [stdout]     |
[INFO] [stdout] 217 |           tester.push_back(s(i));
[INFO] [stdout]     |                  ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:217:18
[INFO] [stdout]     |
[INFO] [stdout] 217 |           tester.push_back(s(i));
[INFO] [stdout]     |                  ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:219:29
[INFO] [stdout]     |
[INFO] [stdout] 219 |         let result = tester.split_off(at);
[INFO] [stdout]     |                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:219:29
[INFO] [stdout]     |
[INFO] [stdout] 219 |         let result = tester.split_off(at);
[INFO] [stdout]     |                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&mut GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:219:29
[INFO] [stdout]     |
[INFO] [stdout] 219 |         let result = tester.split_off(at);
[INFO] [stdout]     |                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:220:39
[INFO] [stdout]     |
[INFO] [stdout] 220 |         assert!(tester.head <= tester.capacity());
[INFO] [stdout]     |                                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:220:39
[INFO] [stdout]     |
[INFO] [stdout] 220 |         assert!(tester.head <= tester.capacity());
[INFO] [stdout]     |                                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:221:38
[INFO] [stdout]     |
[INFO] [stdout] 221 |         assert!(tester.len <= tester.capacity());
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:221:38
[INFO] [stdout]     |
[INFO] [stdout] 221 |         assert!(tester.len <= tester.capacity());
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:222:39
[INFO] [stdout]     |
[INFO] [stdout] 222 |         assert!(result.head <= result.capacity());
[INFO] [stdout]     |                                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:222:39
[INFO] [stdout]     |
[INFO] [stdout] 222 |         assert!(result.head <= result.capacity());
[INFO] [stdout]     |                                       ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>: generic_array::ArrayLength`
[INFO] [stdout]    --> src/heap_tests.rs:223:38
[INFO] [stdout]     |
[INFO] [stdout] 223 |         assert!(result.len <= result.capacity());
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:223:38
[INFO] [stdout]     |
[INFO] [stdout] 223 |         assert!(result.len <= result.capacity());
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:224:9
[INFO] [stdout]     |
[INFO] [stdout] 224 |         assert_eq!(tester, expected_self);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>: PartialEq`
[INFO] [stdout]    --> src/heap_tests.rs:224:9
[INFO] [stdout]     |
[INFO] [stdout] 224 |         assert_eq!(tester, expected_self);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>: Debug`
[INFO] [stdout]    --> src/heap_tests.rs:224:9
[INFO] [stdout]     |
[INFO] [stdout] 224 |         assert_eq!(tester, expected_self);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:224:9
[INFO] [stdout]     |
[INFO] [stdout] 224 |         assert_eq!(tester, expected_self);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: overflow evaluating the requirement `&GenericArrayDeque<String, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>> well-formed`
[INFO] [stdout]    --> src/heap_tests.rs:224:9
[INFO] [stdout]     |
[INFO] [stdout] 224 |         assert_eq!(tester, expected_self);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`generic_arraydeque`)
[INFO] [stdout]     = help: or consider adding a manual `impl` of auto traits like `Send` for intermediate types, if auto traits are involved
[INFO] [stdout]     = note: this lint is attached to the whole crate and can't be disabled on a per-function basis
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #159228 <https://github.com/rust-lang/rust/issues/159228>
[WARN] too many lines in the log, truncating it
