[INFO] fetching crate word_sensitive 0.1.2...
[INFO] testing word_sensitive-0.1.2 against 1.99.0-beta.8 for beta-1.100-2
[INFO] extracting crate word_sensitive 0.1.2 into /workspace/builds/worker-5-tc1/source
[INFO] started tweaking crates.io crate word_sensitive 0.1.2
[INFO] finished tweaking crates.io crate word_sensitive 0.1.2
[INFO] tweaked toml for crates.io crate word_sensitive 0.1.2 written to /workspace/builds/worker-5-tc1/source/Cargo.toml
[INFO] validating manifest of crates.io crate word_sensitive 0.1.2 on toolchain 1.99.0-beta.8
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.99.0-beta.8" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.99.0-beta.8" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.99.0-beta.8" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/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:3111399a4047eeb3a02b7a90e478d715f38a8c6669b5c4b49d30a17385265909" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc
[INFO] running `Command { std: "docker" "start" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", 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" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc" "/opt/rustwide/cargo-home/bin/cargo" "+1.99.0-beta.8" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", 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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc" "/opt/rustwide/cargo-home/bin/cargo" "+1.99.0-beta.8" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling word_sensitive v0.1.2 (/opt/rustwide/workdir)
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
[INFO] running `Command { std: "docker" "inspect" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", 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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc" "/opt/rustwide/cargo-home/bin/cargo" "+1.99.0-beta.8" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling word_sensitive v0.1.2 (/opt/rustwide/workdir)
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:39:15
[INFO] [stdout]    |
[INFO] [stdout] 39 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:39:15
[INFO] [stdout]    |
[INFO] [stdout] 39 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    = note: `#[warn(dangerous_implicit_autorefs)]` on by default
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 39 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).val,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:43:15
[INFO] [stdout]    |
[INFO] [stdout] 43 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:43:15
[INFO] [stdout]    |
[INFO] [stdout] 43 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 43 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:51:15
[INFO] [stdout]    |
[INFO] [stdout] 51 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:51:15
[INFO] [stdout]    |
[INFO] [stdout] 51 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 51 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).val,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:55:15
[INFO] [stdout]    |
[INFO] [stdout] 55 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:55:15
[INFO] [stdout]    |
[INFO] [stdout] 55 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 55 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:61:15
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:61:15
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).val,
[INFO] [stdout]    |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 61 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stdout]    |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:66:15
[INFO] [stdout]    |
[INFO] [stdout] 66 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:66:15
[INFO] [stdout]    |
[INFO] [stdout] 66 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 66 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:70:15
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:70:15
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]    |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:70:17
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:70:17
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 70 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:84:15
[INFO] [stdout]    |
[INFO] [stdout] 84 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:84:15
[INFO] [stdout]    |
[INFO] [stdout] 84 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 84 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stdout]    |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:88:15
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                 |
[INFO] [stdout]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:88:15
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]    |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 88 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]    |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:92:15
[INFO] [stdout]    |
[INFO] [stdout] 92 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |  _______________|
[INFO] [stdout]    | |
[INFO] [stdout] 93 | |                 .children[&2]
[INFO] [stdout]    | |_____________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:92:15
[INFO] [stdout]    |
[INFO] [stdout] 92 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |  _______________^
[INFO] [stdout] 93 | |                 .children[&2]
[INFO] [stdout]    | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 92 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout] 93 ~                 .children)[&2]
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:92:17
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                   |
[INFO] [stdout]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:92:17
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]    |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]   --> tests/trie_test.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]    |
[INFO] [stdout]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]   --> tests/trie_test.rs:92:19
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]    |
[INFO] [stdout] 92 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]    |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:100:15
[INFO] [stdout]     |
[INFO] [stdout] 100 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:100:15
[INFO] [stdout]     |
[INFO] [stdout] 100 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 100 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:104:15
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:104:15
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:104:17
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:104:17
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 104 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:108:15
[INFO] [stdout]     |
[INFO] [stdout] 108 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 109 | |                 .children[&3]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:108:15
[INFO] [stdout]     |
[INFO] [stdout] 108 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 109 | |                 .children[&3]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 108 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout] 109 ~                 .children)[&3]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:108:19
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:108:19
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 108 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:116:15
[INFO] [stdout]     |
[INFO] [stdout] 116 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:116:15
[INFO] [stdout]     |
[INFO] [stdout] 116 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 116 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:120:15
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:120:15
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 120 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:124:15
[INFO] [stdout]     |
[INFO] [stdout] 124 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 125 | |                 .children[&5]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:124:15
[INFO] [stdout]     |
[INFO] [stdout] 124 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 125 | |                 .children[&5]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 124 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout] 125 ~                 .children)[&5]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:124:17
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:124:17
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:124:19
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:124:19
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 124 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:134:15
[INFO] [stdout]     |
[INFO] [stdout] 134 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:134:15
[INFO] [stdout]     |
[INFO] [stdout] 134 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 134 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:138:15
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:138:15
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:138:17
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:138:17
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 138 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:142:15
[INFO] [stdout]     |
[INFO] [stdout] 142 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 143 | |                 .children[&2]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:142:15
[INFO] [stdout]     |
[INFO] [stdout] 142 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 143 | |                 .children[&2]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 142 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout] 143 ~                 .children)[&2]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:142:17
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:142:17
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:142:19
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:142:19
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 142 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:150:15
[INFO] [stdout]     |
[INFO] [stdout] 150 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:150:15
[INFO] [stdout]     |
[INFO] [stdout] 150 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 150 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:154:15
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:154:15
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:154:17
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 154 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:158:15
[INFO] [stdout]     |
[INFO] [stdout] 158 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 159 | |                 .children[&3]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:158:15
[INFO] [stdout]     |
[INFO] [stdout] 158 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 159 | |                 .children[&3]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 158 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout] 159 ~                 .children)[&3]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:158:17
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:158:17
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:158:19
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:158:19
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 158 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:166:15
[INFO] [stdout]     |
[INFO] [stdout] 166 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:166:15
[INFO] [stdout]     |
[INFO] [stdout] 166 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 166 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).ext,
[INFO] [stdout]     |               ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:170:15
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                 |
[INFO] [stdout]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:170:15
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr()).ext,
[INFO] [stdout]     |               ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:170:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:170:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 170 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:174:15
[INFO] [stdout]     |
[INFO] [stdout] 174 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _______________|
[INFO] [stdout]     | |
[INFO] [stdout] 175 | |                 .children[&5]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:174:15
[INFO] [stdout]     |
[INFO] [stdout] 174 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |  _______________^
[INFO] [stdout] 175 | |                 .children[&5]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 174 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout] 175 ~                 .children)[&5]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:174:17
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:174:17
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:174:19
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:174:19
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 174 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:183:17
[INFO] [stdout]     |
[INFO] [stdout] 183 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:183:17
[INFO] [stdout]     |
[INFO] [stdout] 183 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 183 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:191:17
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:191:17
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:191:19
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:191:19
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 191 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:199:17
[INFO] [stdout]     |
[INFO] [stdout] 199 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _________________|
[INFO] [stdout]     | |
[INFO] [stdout] 200 | |                 .children[&2]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:199:17
[INFO] [stdout]     |
[INFO] [stdout] 199 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 200 | |                 .children[&2]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 199 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout] 200 ~                 .children)[&2]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:199:19
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:199:19
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                   ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:199:21
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                       |
[INFO] [stdout]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:199:21
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 199 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                     ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:210:17
[INFO] [stdout]     |
[INFO] [stdout] 210 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:210:17
[INFO] [stdout]     |
[INFO] [stdout] 210 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 210 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr())
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:218:17
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:218:17
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:218:19
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:218:19
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 218 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:226:17
[INFO] [stdout]     |
[INFO] [stdout] 226 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _________________|
[INFO] [stdout]     | |
[INFO] [stdout] 227 | |                 .children[&3]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:226:17
[INFO] [stdout]     |
[INFO] [stdout] 226 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 227 | |                 .children[&3]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 226 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout] 227 ~                 .children)[&3]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:226:19
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:226:19
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stdout]     |                   ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                       |
[INFO] [stdout]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:226:21
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 226 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stdout]     |                     ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:237:17
[INFO] [stdout]     |
[INFO] [stdout] 237 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr())
[INFO] [stdout]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:237:17
[INFO] [stdout]     |
[INFO] [stdout] 237 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 237 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr())
[INFO] [stdout]     |                 ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:245:17
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                   |
[INFO] [stdout]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:245:17
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                 ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:245:19
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:245:19
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 245 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:253:17
[INFO] [stdout]     |
[INFO] [stdout] 253 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |  _________________|
[INFO] [stdout]     | |
[INFO] [stdout] 254 | |                 .children[&5]
[INFO] [stdout]     | |_____________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:253:17
[INFO] [stdout]     |
[INFO] [stdout] 253 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 254 | |                 .children[&5]
[INFO] [stdout]     | |_________________________^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 253 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout] 254 ~                 .children)[&5]
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:253:19
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:253:19
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stdout]     |                   ++                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stdout]    --> tests/trie_test.rs:253:21
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stdout]     |                       |
[INFO] [stdout]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stdout]     |
[INFO] [stdout]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stdout] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stdout]    --> tests/trie_test.rs:253:21
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stdout]     |
[INFO] [stdout] 253 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stdout]     |                     ++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 0.67s
[INFO] running `Command { std: "docker" "inspect" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", 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=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc" "/opt/rustwide/cargo-home/bin/cargo" "+1.99.0-beta.8" "test" "--frozen", kill_on_drop: false }`
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:39:15
[INFO] [stderr]    |
[INFO] [stderr] 39 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stderr]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:39:15
[INFO] [stderr]    |
[INFO] [stderr] 39 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]    = note: `#[warn(dangerous_implicit_autorefs)]` on by default
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 39 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).val,
[INFO] [stderr]    |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:43:15
[INFO] [stderr]    |
[INFO] [stderr] 43 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stderr]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:43:15
[INFO] [stderr]    |
[INFO] [stderr] 43 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 43 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stderr]    |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:51:15
[INFO] [stderr]    |
[INFO] [stderr] 51 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stderr]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:51:15
[INFO] [stderr]    |
[INFO] [stderr] 51 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).val,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 51 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).val,
[INFO] [stderr]    |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:55:15
[INFO] [stderr]    |
[INFO] [stderr] 55 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stderr]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:55:15
[INFO] [stderr]    |
[INFO] [stderr] 55 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 55 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stderr]    |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:61:15
[INFO] [stderr]    |
[INFO] [stderr] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stderr]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:61:15
[INFO] [stderr]    |
[INFO] [stderr] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 61 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).val,
[INFO] [stderr]    |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:61:17
[INFO] [stderr]    |
[INFO] [stderr] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stderr]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                   |
[INFO] [stderr]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:61:17
[INFO] [stderr]    |
[INFO] [stderr] 61 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 61 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).val,
[INFO] [stderr]    |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:66:15
[INFO] [stderr]    |
[INFO] [stderr] 66 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stderr]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:66:15
[INFO] [stderr]    |
[INFO] [stderr] 66 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 66 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stderr]    |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:70:15
[INFO] [stderr]    |
[INFO] [stderr] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:70:15
[INFO] [stderr]    |
[INFO] [stderr] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 70 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stderr]    |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:70:17
[INFO] [stderr]    |
[INFO] [stderr] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                   |
[INFO] [stderr]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:70:17
[INFO] [stderr]    |
[INFO] [stderr] 70 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 70 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:84:15
[INFO] [stderr]    |
[INFO] [stderr] 84 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stderr]    |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:84:15
[INFO] [stderr]    |
[INFO] [stderr] 84 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 84 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stderr]    |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:88:15
[INFO] [stderr]    |
[INFO] [stderr] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                 |
[INFO] [stderr]    |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:88:15
[INFO] [stderr]    |
[INFO] [stderr] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 88 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stderr]    |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:88:17
[INFO] [stderr]    |
[INFO] [stderr] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                   |
[INFO] [stderr]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:88:17
[INFO] [stderr]    |
[INFO] [stderr] 88 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 88 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]    |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:92:15
[INFO] [stderr]    |
[INFO] [stderr] 92 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |  _______________|
[INFO] [stderr]    | |
[INFO] [stderr] 93 | |                 .children[&2]
[INFO] [stderr]    | |_____________________________^
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:92:15
[INFO] [stderr]    |
[INFO] [stderr] 92 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |  _______________^
[INFO] [stderr] 93 | |                 .children[&2]
[INFO] [stderr]    | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 92 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr] 93 ~                 .children)[&2]
[INFO] [stderr]    |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:92:17
[INFO] [stderr]    |
[INFO] [stderr] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                   |
[INFO] [stderr]    |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:92:17
[INFO] [stderr]    |
[INFO] [stderr] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 92 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stderr]    |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]   --> tests/trie_test.rs:92:19
[INFO] [stderr]    |
[INFO] [stderr] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]    |                     |
[INFO] [stderr]    |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]    |
[INFO] [stderr]    = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]   --> tests/trie_test.rs:92:19
[INFO] [stderr]    |
[INFO] [stderr] 92 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]    |
[INFO] [stderr] 92 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]    |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:100:15
[INFO] [stderr]     |
[INFO] [stderr] 100 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:100:15
[INFO] [stderr]     |
[INFO] [stderr] 100 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 100 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stderr]     |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:104:15
[INFO] [stderr]     |
[INFO] [stderr] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:104:15
[INFO] [stderr]     |
[INFO] [stderr] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 104 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr()).ext,
[INFO] [stderr]     |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:104:17
[INFO] [stderr]     |
[INFO] [stderr] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:104:17
[INFO] [stderr]     |
[INFO] [stderr] 104 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 104 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:108:15
[INFO] [stderr]     |
[INFO] [stderr] 108 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _______________|
[INFO] [stderr]     | |
[INFO] [stderr] 109 | |                 .children[&3]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:108:15
[INFO] [stderr]     |
[INFO] [stderr] 108 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |  _______________^
[INFO] [stderr] 109 | |                 .children[&3]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 108 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr] 109 ~                 .children)[&3]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:108:17
[INFO] [stderr]     |
[INFO] [stderr] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:108:17
[INFO] [stderr]     |
[INFO] [stderr] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 108 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:108:19
[INFO] [stderr]     |
[INFO] [stderr] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:108:19
[INFO] [stderr]     |
[INFO] [stderr] 108 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 108 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:116:15
[INFO] [stderr]     |
[INFO] [stderr] 116 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stderr]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:116:15
[INFO] [stderr]     |
[INFO] [stderr] 116 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 116 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).ext,
[INFO] [stderr]     |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:120:15
[INFO] [stderr]     |
[INFO] [stderr] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:120:15
[INFO] [stderr]     |
[INFO] [stderr] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 120 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr()).ext,
[INFO] [stderr]     |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:120:17
[INFO] [stderr]     |
[INFO] [stderr] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:120:17
[INFO] [stderr]     |
[INFO] [stderr] 120 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 120 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:124:15
[INFO] [stderr]     |
[INFO] [stderr] 124 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _______________|
[INFO] [stderr]     | |
[INFO] [stderr] 125 | |                 .children[&5]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:124:15
[INFO] [stderr]     |
[INFO] [stderr] 124 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |  _______________^
[INFO] [stderr] 125 | |                 .children[&5]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 124 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr] 125 ~                 .children)[&5]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:124:17
[INFO] [stderr]     |
[INFO] [stderr] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:124:17
[INFO] [stderr]     |
[INFO] [stderr] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 124 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:124:19
[INFO] [stderr]     |
[INFO] [stderr] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:124:19
[INFO] [stderr]     |
[INFO] [stderr] 124 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 124 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:134:15
[INFO] [stderr]     |
[INFO] [stderr] 134 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stderr]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:134:15
[INFO] [stderr]     |
[INFO] [stderr] 134 |             (*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 134 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).ext,
[INFO] [stderr]     |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:138:15
[INFO] [stderr]     |
[INFO] [stderr] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:138:15
[INFO] [stderr]     |
[INFO] [stderr] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 138 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stderr]     |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:138:17
[INFO] [stderr]     |
[INFO] [stderr] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:138:17
[INFO] [stderr]     |
[INFO] [stderr] 138 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 138 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:142:15
[INFO] [stderr]     |
[INFO] [stderr] 142 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _______________|
[INFO] [stderr]     | |
[INFO] [stderr] 143 | |                 .children[&2]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:142:15
[INFO] [stderr]     |
[INFO] [stderr] 142 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |  _______________^
[INFO] [stderr] 143 | |                 .children[&2]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 142 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr] 143 ~                 .children)[&2]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:142:17
[INFO] [stderr]     |
[INFO] [stderr] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:142:17
[INFO] [stderr]     |
[INFO] [stderr] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 142 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:142:19
[INFO] [stderr]     |
[INFO] [stderr] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:142:19
[INFO] [stderr]     |
[INFO] [stderr] 142 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 142 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:150:15
[INFO] [stderr]     |
[INFO] [stderr] 150 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:150:15
[INFO] [stderr]     |
[INFO] [stderr] 150 |             (*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 150 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).ext,
[INFO] [stderr]     |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:154:15
[INFO] [stderr]     |
[INFO] [stderr] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:154:15
[INFO] [stderr]     |
[INFO] [stderr] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 154 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr()).ext,
[INFO] [stderr]     |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:154:17
[INFO] [stderr]     |
[INFO] [stderr] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:154:17
[INFO] [stderr]     |
[INFO] [stderr] 154 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 154 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr()).ext,
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:158:15
[INFO] [stderr]     |
[INFO] [stderr] 158 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _______________|
[INFO] [stderr]     | |
[INFO] [stderr] 159 | |                 .children[&3]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:158:15
[INFO] [stderr]     |
[INFO] [stderr] 158 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |  _______________^
[INFO] [stderr] 159 | |                 .children[&3]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 158 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr] 159 ~                 .children)[&3]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:158:17
[INFO] [stderr]     |
[INFO] [stderr] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:158:17
[INFO] [stderr]     |
[INFO] [stderr] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 158 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:158:19
[INFO] [stderr]     |
[INFO] [stderr] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:158:19
[INFO] [stderr]     |
[INFO] [stderr] 158 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 158 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:166:15
[INFO] [stderr]     |
[INFO] [stderr] 166 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stderr]     |               ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:166:15
[INFO] [stderr]     |
[INFO] [stderr] 166 |             (*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 166 |             (*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).ext,
[INFO] [stderr]     |               ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:170:15
[INFO] [stderr]     |
[INFO] [stderr] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |               ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                 |
[INFO] [stderr]     |                 this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:170:15
[INFO] [stderr]     |
[INFO] [stderr] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 170 |             (*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr()).ext,
[INFO] [stderr]     |               ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:170:17
[INFO] [stderr]     |
[INFO] [stderr] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:170:17
[INFO] [stderr]     |
[INFO] [stderr] 170 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 170 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr()).ext,
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:174:15
[INFO] [stderr]     |
[INFO] [stderr] 174 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _______________|
[INFO] [stderr]     | |
[INFO] [stderr] 175 | |                 .children[&5]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:174:15
[INFO] [stderr]     |
[INFO] [stderr] 174 |               (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |  _______________^
[INFO] [stderr] 175 | |                 .children[&5]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 174 ~             (*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr] 175 ~                 .children)[&5]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:174:17
[INFO] [stderr]     |
[INFO] [stderr] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:174:17
[INFO] [stderr]     |
[INFO] [stderr] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 174 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:174:19
[INFO] [stderr]     |
[INFO] [stderr] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:174:19
[INFO] [stderr]     |
[INFO] [stderr] 174 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 174 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:183:17
[INFO] [stderr]     |
[INFO] [stderr] 183 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:183:17
[INFO] [stderr]     |
[INFO] [stderr] 183 |             (*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 183 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr())
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:191:17
[INFO] [stderr]     |
[INFO] [stderr] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:191:17
[INFO] [stderr]     |
[INFO] [stderr] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 191 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:191:19
[INFO] [stderr]     |
[INFO] [stderr] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:191:19
[INFO] [stderr]     |
[INFO] [stderr] 191 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 191 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:199:17
[INFO] [stderr]     |
[INFO] [stderr] 199 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _________________|
[INFO] [stderr]     | |
[INFO] [stderr] 200 | |                 .children[&2]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:199:17
[INFO] [stderr]     |
[INFO] [stderr] 199 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |  _________________^
[INFO] [stderr] 200 | |                 .children[&2]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 199 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr] 200 ~                 .children)[&2]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:199:19
[INFO] [stderr]     |
[INFO] [stderr] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:199:19
[INFO] [stderr]     |
[INFO] [stderr] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 199 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children)[&1].as_ptr())
[INFO] [stderr]     |                   ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:199:21
[INFO] [stderr]     |
[INFO] [stderr] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                       |
[INFO] [stderr]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:199:21
[INFO] [stderr]     |
[INFO] [stderr] 199 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 199 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&0].as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                     ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:210:17
[INFO] [stderr]     |
[INFO] [stderr] 210 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:210:17
[INFO] [stderr]     |
[INFO] [stderr] 210 |             (*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 210 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr())
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:218:17
[INFO] [stderr]     |
[INFO] [stderr] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:218:17
[INFO] [stderr]     |
[INFO] [stderr] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 218 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:218:19
[INFO] [stderr]     |
[INFO] [stderr] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:218:19
[INFO] [stderr]     |
[INFO] [stderr] 218 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 218 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:226:17
[INFO] [stderr]     |
[INFO] [stderr] 226 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _________________|
[INFO] [stderr]     | |
[INFO] [stderr] 227 | |                 .children[&3]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:226:17
[INFO] [stderr]     |
[INFO] [stderr] 226 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |  _________________^
[INFO] [stderr] 227 | |                 .children[&3]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 226 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr] 227 ~                 .children)[&3]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:226:19
[INFO] [stderr]     |
[INFO] [stderr] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:226:19
[INFO] [stderr]     |
[INFO] [stderr] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 226 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children)[&2].as_ptr())
[INFO] [stderr]     |                   ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:226:21
[INFO] [stderr]     |
[INFO] [stderr] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                       |
[INFO] [stderr]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:226:21
[INFO] [stderr]     |
[INFO] [stderr] 226 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 226 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&1].as_ptr()).children[&2].as_ptr())
[INFO] [stderr]     |                     ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:237:17
[INFO] [stderr]     |
[INFO] [stderr] 237 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr())
[INFO] [stderr]     |                 ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:237:17
[INFO] [stderr]     |
[INFO] [stderr] 237 |             (*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 237 |             (*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr())
[INFO] [stderr]     |                 ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:245:17
[INFO] [stderr]     |
[INFO] [stderr] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                   |
[INFO] [stderr]     |                   this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:245:17
[INFO] [stderr]     |
[INFO] [stderr] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 245 |             (*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stderr]     |                 ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:245:19
[INFO] [stderr]     |
[INFO] [stderr] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:245:19
[INFO] [stderr]     |
[INFO] [stderr] 245 |             (*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 245 |             (*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:253:17
[INFO] [stderr]     |
[INFO] [stderr] 253 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^ ----------------------------------------------------------------------------- this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |  _________________|
[INFO] [stderr]     | |
[INFO] [stderr] 254 | |                 .children[&5]
[INFO] [stderr]     | |_____________________________^
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:253:17
[INFO] [stderr]     |
[INFO] [stderr] 253 |               (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |  _________________^
[INFO] [stderr] 254 | |                 .children[&5]
[INFO] [stderr]     | |_________________________^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 253 ~             (*(*(&(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr] 254 ~                 .children)[&5]
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:253:19
[INFO] [stderr]     |
[INFO] [stderr] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^----------------------------------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                     |
[INFO] [stderr]     |                     this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:253:19
[INFO] [stderr]     |
[INFO] [stderr] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 253 |             (*(*(*(&(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children)[&4].as_ptr())
[INFO] [stderr]     |                   ++                                                                +
[INFO] [stderr] 
[INFO] [stderr] warning: implicit autoref creates a reference to the dereference of a raw pointer
[INFO] [stderr]    --> tests/trie_test.rs:253:21
[INFO] [stderr]     |
[INFO] [stderr] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                     ^^---------------------------^^^^^^^^^^^^^^
[INFO] [stderr]     |                       |
[INFO] [stderr]     |                       this raw pointer has type `*mut Node<usize>`
[INFO] [stderr]     |
[INFO] [stderr]     = note: creating a reference requires the pointer target to be valid and imposes aliasing requirements
[INFO] [stderr] note: autoref is being applied to this expression, resulting in: `&HashMap<u8, NonNull<Node<usize>>>`
[INFO] [stderr]    --> tests/trie_test.rs:253:21
[INFO] [stderr]     |
[INFO] [stderr] 253 |             (*(*(*(*(*tree.root.unwrap().as_ptr()).children[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] help: try using a raw pointer method instead; or if this reference is intentional, make it explicit
[INFO] [stderr]     |
[INFO] [stderr] 253 |             (*(*(*(*(&(*tree.root.unwrap().as_ptr()).children)[&3].as_ptr()).children[&4].as_ptr())
[INFO] [stderr]     |                     ++                                       +
[INFO] [stderr] 
[INFO] [stderr] warning: `word_sensitive` (test "trie_test") generated 63 warnings
[INFO] [stderr]     Finished `test` profile [unoptimized + debuginfo] target(s) in 0.04s
[INFO] [stderr]      Running unittests src/lib.rs (/opt/rustwide/target/debug/deps/word_sensitive-12cceccae3b333dc)
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stderr]      Running tests/trie_test.rs (/opt/rustwide/target/debug/deps/trie_test-562137dcea86f0e2)
[INFO] [stdout] 
[INFO] [stdout] running 8 tests
[INFO] [stdout] test leak ... ok
[INFO] [stdout] test add ... ok
[INFO] [stdout] test query ... ok
[INFO] [stdout] test thread_safe ... ok
[INFO] [stdout] test specail_build ... ok
[INFO] [stdout] test query_cate_weight ... ok
[INFO] [stdout] test query_total_weight ... ok
[INFO] [stdout] test key_words_from_file ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.60s
[INFO] [stdout] 
[INFO] [stderr]    Doc-tests word_sensitive
[INFO] [stdout] 
[INFO] [stdout] running 6 tests
[INFO] [stdout] test src/trie.rs - trie::Trie<T>::query_cate_weight (line 338) ... ok
[INFO] [stdout] test src/trie.rs - trie::Trie<T>::query (line 228) ... ok
[INFO] [stdout] test src/trie.rs - trie::Trie<T>::build (line 172) ... ok
[INFO] [stdout] test src/trie.rs - trie::Trie<usize>::add_key_word (line 132) ... ok
[INFO] [stdout] test src/trie.rs - trie::Trie<T>::query_total_weight (line 279) ... ok
[INFO] [stdout] test src/trie.rs - trie::Trie<usize>::add_key_word_from_file (line 109) ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 1.36s
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc", kill_on_drop: false }`
[INFO] [stdout] b17fb2d572f8a2ff8b7b731f962476e56b381c28ab6685a5e6e1cce458bf8efc
