[INFO] fetching crate celox-backend-arm64 0.10.1...
[INFO] checking celox-backend-arm64-0.10.1 against c60b92c03ca8a3b101eb9d57f51e2232690638c7 for pr-164148-crater-rollup
[INFO] extracting crate celox-backend-arm64 0.10.1 into /workspace/builds/worker-6-tc2/source
[INFO] started tweaking crates.io crate celox-backend-arm64 0.10.1
[INFO] finished tweaking crates.io crate celox-backend-arm64 0.10.1
[INFO] tweaked toml for crates.io crate celox-backend-arm64 0.10.1 written to /workspace/builds/worker-6-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate celox-backend-arm64 0.10.1 on toolchain c60b92c03ca8a3b101eb9d57f51e2232690638c7
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate celox-backend-arm64 0.10.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d
[INFO] running `Command { std: "docker" "start" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d", 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" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d" "/opt/rustwide/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-w" "/opt/rustwide/workdir" "--user" "0:0" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d" "/opt/rustwide/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling syn v3.0.6
[INFO] [stderr]    Compiling proc-macro-error-attr3 v3.1.0
[INFO] [stderr]    Compiling bitflags v2.13.0
[INFO] [stderr]    Compiling byteorder v1.5.0
[INFO] [stderr]     Checking celox-analysis v0.10.1
[INFO] [stderr]     Checking celox-backend-common v0.10.1
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]     Checking memmap2 v0.9.11
[INFO] [stderr]    Compiling proc-macro-error3 v3.1.0
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling dynasm v5.1.0
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking num-bigint v0.5.1
[INFO] [stderr]     Checking celox-design v0.10.1
[INFO] [stderr]     Checking celox-state-layout v0.10.1
[INFO] [stderr]     Checking celox-sir v0.10.1
[INFO] [stderr]     Checking dynasmrt v5.1.0
[INFO] [stderr]     Checking celox-backend-arm64 v0.10.1 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:419:48
[INFO] [stdout]     |
[INFO] [stdout] 419 |         dynasm!(ops ; .arch aarch64 ; stp x30, X(first), [sp, #-16]!);
[INFO] [stdout]     |                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 419 |         dynasm!(ops ; .arch aarch64 ; stp x30, X(<u8 as Into<_>>::into(first)), [sp, #-16]!);
[INFO] [stdout]     |                                                  ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:424:23
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(callee_saved[index]), X(callee_saved[index + 1]), [sp, #-16]!
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(<u8 as Into<_>>::into(callee_saved[index])), X(callee_saved[index + 1]), [sp, #-16]!
[INFO] [stdout]     |                         ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:424:47
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(callee_saved[index]), X(callee_saved[index + 1]), [sp, #-16]!
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(callee_saved[index]), X(<u8 as Into<_>>::into(callee_saved[index + 1])), [sp, #-16]!
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:429:47
[INFO] [stdout]     |
[INFO] [stdout] 429 |             dynasm!(ops ; .arch aarch64 ; str X(callee_saved[index]), [sp, #-16]!);
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 |             dynasm!(ops ; .arch aarch64 ; str X(<u8 as Into<_>>::into(callee_saved[index])), [sp, #-16]!);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:545:47
[INFO] [stdout]     |
[INFO] [stdout] 545 |             dynasm!(ops ; .arch aarch64 ; ldr X(callee_saved[index]), [sp], #16);
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 545 |             dynasm!(ops ; .arch aarch64 ; ldr X(<u8 as Into<_>>::into(callee_saved[index])), [sp], #16);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:551:23
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(callee_saved[index]), X(callee_saved[index + 1]), [sp], #16
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(<u8 as Into<_>>::into(callee_saved[index])), X(callee_saved[index + 1]), [sp], #16
[INFO] [stdout]     |                         ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:551:47
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(callee_saved[index]), X(callee_saved[index + 1]), [sp], #16
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(callee_saved[index]), X(<u8 as Into<_>>::into(callee_saved[index + 1])), [sp], #16
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:554:48
[INFO] [stdout]     |
[INFO] [stdout] 554 |         dynasm!(ops ; .arch aarch64 ; ldp x30, X(callee_saved[0]), [sp], #16);
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 |         dynasm!(ops ; .arch aarch64 ; ldp x30, X(<u8 as Into<_>>::into(callee_saved[0])), [sp], #16);
[INFO] [stdout]     |                                                  ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:608:51
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), X(src));
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), X(src));
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:608:59
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), X(src));
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:613:47
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(dst), W(src));
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(<u8 as Into<_>>::into(dst)), W(src));
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:613:55
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(dst), W(src));
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(dst), W(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:624:48
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(dst), X(src), lsb, width);
[INFO] [stdout]     |                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(<u8 as Into<_>>::into(dst)), X(src), lsb, width);
[INFO] [stdout]     |                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:624:56
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(dst), X(src), lsb, width);
[INFO] [stdout]     |                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(dst), X(<u8 as Into<_>>::into(src)), lsb, width);
[INFO] [stdout]     |                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:652:47
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:652:55
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:652:63
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs)), LSL #shift);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:660:47
[INFO] [stdout]     |
[INFO] [stdout] 660 |             dynasm!(ops ; .arch aarch64 ; adr X(dst), =>label);
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 660 |             dynasm!(ops ; .arch aarch64 ; adr X(<u8 as Into<_>>::into(dst)), =>label);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:766:65
[INFO] [stdout]     |
[INFO] [stdout] 766 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(src));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 766 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:769:60
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index));
[INFO] [stdout]     |                                                            ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(base)), X(index));
[INFO] [stdout]     |                                                              ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:769:69
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index));
[INFO] [stdout]     |                                                                     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(<u8 as Into<_>>::into(index)));
[INFO] [stdout]     |                                                                       ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:772:65
[INFO] [stdout]     |
[INFO] [stdout] 772 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(src));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 772 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:817:56
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(ptr), X(index));
[INFO] [stdout]     |                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(ptr)), X(index));
[INFO] [stdout]     |                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:817:64
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(ptr), X(index));
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(ptr), X(<u8 as Into<_>>::into(index)));
[INFO] [stdout]     |                                                                  ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:839:72
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:839:80
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:839:88
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:840:72
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:840:80
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:840:88
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:841:72
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:841:80
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:841:88
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:842:72
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:842:80
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:842:88
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:843:71
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:843:79
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:843:87
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:844:72
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:844:80
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:844:88
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:845:73
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:845:81
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:845:89
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:846:73
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:846:81
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:846:89
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:847:73
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:847:81
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:847:89
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:863:74
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:863:82
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:863:90
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:864:74
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:864:82
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:864:90
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:865:74
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:865:82
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:865:90
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:866:74
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:866:82
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:866:90
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:867:73
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:867:81
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:867:89
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:868:74
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:868:82
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:868:90
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:878:49
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(rhs));
[INFO] [stdout]     |                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs));
[INFO] [stdout]     |                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:878:57
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(rhs));
[INFO] [stdout]     |                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:878:65
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(rhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:886:55
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:886:63
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:888:55
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:888:63
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:896:51
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(dst), W(src), w16);
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(<u8 as Into<_>>::into(dst)), W(src), w16);
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:896:59
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(dst), W(src), w16);
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(dst), W(<u8 as Into<_>>::into(src)), w16);
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:908:75
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(<u8 as Into<_>>::into(dst)), X(src), #imm),
[INFO] [stdout]     |                                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:908:83
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(dst), X(<u8 as Into<_>>::into(src)), #imm),
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:909:75
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(<u8 as Into<_>>::into(dst)), X(src), #imm),
[INFO] [stdout]     |                                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:909:83
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(dst), X(<u8 as Into<_>>::into(src)), #imm),
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:910:75
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(<u8 as Into<_>>::into(dst)), X(src), #imm),
[INFO] [stdout]     |                                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:910:83
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(dst), X(<u8 as Into<_>>::into(src)), #imm),
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:924:55
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:924:63
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:926:55
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:926:63
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:941:47
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:941:55
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:953:51
[INFO] [stdout]     |
[INFO] [stdout] 953 |                 dynasm!(ops ; .arch aarch64 ; cmp X(lhs), x16);
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 953 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), x16);
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:967:57
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:967:65
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:969:57
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:969:65
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:972:52
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(<u8 as Into<_>>::into(dst)), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                      ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:972:65
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(<u8 as Into<_>>::into(rhs)), X(lhs));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:972:73
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(<u8 as Into<_>>::into(lhs)));
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:974:51
[INFO] [stdout]     |
[INFO] [stdout] 974 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), x16);
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 974 |                 dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), x16);
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:980:51
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(dst), X(src));
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(<u8 as Into<_>>::into(dst)), X(src));
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:980:59
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(dst), X(src));
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(dst), X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:982:51
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(dst), X(src));
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(<u8 as Into<_>>::into(dst)), X(src));
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:982:59
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(dst), X(src));
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(dst), X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:989:28
[INFO] [stdout]     |
[INFO] [stdout] 989 |                 ; fmov d0, X(src)
[INFO] [stdout]     |                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 989 |                 ; fmov d0, X(<u8 as Into<_>>::into(src))
[INFO] [stdout]     |                              ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:992:24
[INFO] [stdout]     |
[INFO] [stdout] 992 |                 ; umov W(dst), v0.b[0]
[INFO] [stdout]     |                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 992 |                 ; umov W(<u8 as Into<_>>::into(dst)), v0.b[0]
[INFO] [stdout]     |                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:997:53
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(src) ; clz X(dst), x16);
[INFO] [stdout]     |                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(<u8 as Into<_>>::into(src)) ; clz X(dst), x16);
[INFO] [stdout]     |                                                       ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:997:66
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(src) ; clz X(dst), x16);
[INFO] [stdout]     |                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(src) ; clz X(<u8 as Into<_>>::into(dst)), x16);
[INFO] [stdout]     |                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1001:52
[INFO] [stdout]      |
[INFO] [stdout] 1001 |             dynasm!(ops ; .arch aarch64 ; clz x16, X(src));
[INFO] [stdout]      |                                                    ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1001 |             dynasm!(ops ; .arch aarch64 ; clz x16, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]      |                                                      ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1004:47
[INFO] [stdout]      |
[INFO] [stdout] 1004 |             dynasm!(ops ; .arch aarch64 ; mov X(dst), x16);
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1004 |             dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), x16);
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1020:23
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 ; cmp XSP(cond), #0
[INFO] [stdout]      |                       ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 ; cmp XSP(<u8 as Into<_>>::into(cond)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1021:24
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                        ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(<u8 as Into<_>>::into(dst)), X(true_val), X(false_val), ne
[INFO] [stdout]      |                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1021:32
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(<u8 as Into<_>>::into(true_val)), X(false_val), ne
[INFO] [stdout]      |                                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1021:45
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(<u8 as Into<_>>::into(false_val)), ne
[INFO] [stdout]      |                                               ++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1039:47
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1039:55
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]      |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1058:51
[INFO] [stdout]      |
[INFO] [stdout] 1058 |                 dynasm!(ops ; .arch aarch64 ; cmp X(lhs), x16);
[INFO] [stdout]      |                                                   ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1058 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), x16);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1073:51
[INFO] [stdout]      |
[INFO] [stdout] 1073 |                 dynasm!(ops ; .arch aarch64 ; cmp X(index), x16 ; b.eq =>path);
[INFO] [stdout]      |                                                   ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1073 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(index)), x16 ; b.eq =>path);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1109:56
[INFO] [stdout]      |
[INFO] [stdout] 1109 |                     dynasm!(ops ; .arch aarch64 ; cbnz X(cond), =>target_label);
[INFO] [stdout]      |                                                        ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1109 |                     dynasm!(ops ; .arch aarch64 ; cbnz X(<u8 as Into<_>>::into(cond)), =>target_label);
[INFO] [stdout]      |                                                          ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1111:55
[INFO] [stdout]      |
[INFO] [stdout] 1111 |                     dynasm!(ops ; .arch aarch64 ; cbz X(cond), =>target_label);
[INFO] [stdout]      |                                                       ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1111 |                     dynasm!(ops ; .arch aarch64 ; cbz X(<u8 as Into<_>>::into(cond)), =>target_label);
[INFO] [stdout]      |                                                         ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1132:51
[INFO] [stdout]      |
[INFO] [stdout] 1132 |                 dynasm!(ops ; .arch aarch64 ; cbz X(cond), =>true_path);
[INFO] [stdout]      |                                                   ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1132 |                 dynasm!(ops ; .arch aarch64 ; cbz X(<u8 as Into<_>>::into(cond)), =>true_path);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1134:52
[INFO] [stdout]      |
[INFO] [stdout] 1134 |                 dynasm!(ops ; .arch aarch64 ; cbnz X(cond), =>true_path);
[INFO] [stdout]      |                                                    ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1134 |                 dynasm!(ops ; .arch aarch64 ; cbnz X(<u8 as Into<_>>::into(cond)), =>true_path);
[INFO] [stdout]      |                                                      ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1400:47
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1400:55
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]      |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1404:23
[INFO] [stdout]      |
[INFO] [stdout] 1404 |                 ; cmp XSP(guard), #0
[INFO] [stdout]      |                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1404 |                 ; cmp XSP(<u8 as Into<_>>::into(guard)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1407:24
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                        ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(<u8 as Into<_>>::into(dst)), X(true_val), X(false_val), ne
[INFO] [stdout]      |                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1407:32
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(<u8 as Into<_>>::into(true_val)), X(false_val), ne
[INFO] [stdout]      |                                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1407:45
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(<u8 as Into<_>>::into(false_val)), ne
[INFO] [stdout]      |                                               ++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1424:52
[INFO] [stdout]      |
[INFO] [stdout] 1424 |             dynasm!(ops ; .arch aarch64 ; mov x16, X(src));
[INFO] [stdout]      |                                                    ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1424 |             dynasm!(ops ; .arch aarch64 ; mov x16, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]      |                                                      ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1427:43
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(dst), X(base));
[INFO] [stdout]      |                                           ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), X(base));
[INFO] [stdout]      |                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1427:51
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(dst), X(base));
[INFO] [stdout]      |                                                   ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(dst), X(<u8 as Into<_>>::into(base)));
[INFO] [stdout]      |                                                     ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1430:39
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(dst), X(src), lsb, width);
[INFO] [stdout]      |                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(<u8 as Into<_>>::into(dst)), X(src), lsb, width);
[INFO] [stdout]      |                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1430:47
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(dst), X(src), lsb, width);
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(dst), X(<u8 as Into<_>>::into(src)), lsb, width);
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1646:56
[INFO] [stdout]      |
[INFO] [stdout] 1646 |                 dynasm!(ops ; .arch aarch64 ; mov x17, X(scalar_rhs.unwrap()));
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1646 |                 dynasm!(ops ; .arch aarch64 ; mov x17, X(<u8 as Into<_>>::into(scalar_rhs.unwrap())));
[INFO] [stdout]      |                                                          ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1714:39
[INFO] [stdout]      |
[INFO] [stdout] 1714 |     dynasm!(ops ; .arch aarch64 ; mov X(destination), x30);
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1714 |     dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(destination)), x30);
[INFO] [stdout]      |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1748:60
[INFO] [stdout]      |
[INFO] [stdout] 1748 |             1 => dynasm!(ops ; .arch aarch64 ; dup v4.b16, W(SCRATCH1)),
[INFO] [stdout]      |                                                            ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1748 |             1 => dynasm!(ops ; .arch aarch64 ; dup v4.b16, W(<u8 as Into<_>>::into(SCRATCH1))),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1749:59
[INFO] [stdout]      |
[INFO] [stdout] 1749 |             2 => dynasm!(ops ; .arch aarch64 ; dup v4.h8, W(SCRATCH1)),
[INFO] [stdout]      |                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1749 |             2 => dynasm!(ops ; .arch aarch64 ; dup v4.h8, W(<u8 as Into<_>>::into(SCRATCH1))),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1750:59
[INFO] [stdout]      |
[INFO] [stdout] 1750 |             4 => dynasm!(ops ; .arch aarch64 ; dup v4.s4, W(SCRATCH1)),
[INFO] [stdout]      |                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1750 |             4 => dynasm!(ops ; .arch aarch64 ; dup v4.s4, W(<u8 as Into<_>>::into(SCRATCH1))),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1778:64
[INFO] [stdout]      |
[INFO] [stdout] 1778 |                 1 => dynasm!(ops ; .arch aarch64 ; dup v1.b16, W(rhs)),
[INFO] [stdout]      |                                                                ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1778 |                 1 => dynasm!(ops ; .arch aarch64 ; dup v1.b16, W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1779:63
[INFO] [stdout]      |
[INFO] [stdout] 1779 |                 2 => dynasm!(ops ; .arch aarch64 ; dup v1.h8, W(rhs)),
[INFO] [stdout]      |                                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1779 |                 2 => dynasm!(ops ; .arch aarch64 ; dup v1.h8, W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1780:63
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                 4 => dynasm!(ops ; .arch aarch64 ; dup v1.s4, W(rhs)),
[INFO] [stdout]      |                                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                 4 => dynasm!(ops ; .arch aarch64 ; dup v1.s4, W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1830:39
[INFO] [stdout]      |
[INFO] [stdout] 1830 |     dynasm!(ops ; .arch aarch64 ; mov X(destination), x30);
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1830 |     dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(destination)), x30);
[INFO] [stdout]      |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1967:24
[INFO] [stdout]      |
[INFO] [stdout] 1967 |                 ; umov W(SCRATCH0), v5.b[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1967 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.b[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1970:24
[INFO] [stdout]      |
[INFO] [stdout] 1970 |                 ; umov W(SCRATCH1), v5.b[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1970 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH1)), v5.b[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1986:24
[INFO] [stdout]      |
[INFO] [stdout] 1986 |                 ; umov W(SCRATCH0), v5.h[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1986 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.h[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2000:24
[INFO] [stdout]      |
[INFO] [stdout] 2000 |                 ; umov W(SCRATCH0), v5.s[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2000 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.s[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2025:23
[INFO] [stdout]      |
[INFO] [stdout] 2025 |         ; dup v4.b16, W(base)
[INFO] [stdout]      |                       ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2025 |         ; dup v4.b16, W(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |                         ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2026:23
[INFO] [stdout]      |
[INFO] [stdout] 2026 |         ; dup v1.b16, W(rhs)
[INFO] [stdout]      |                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2026 |         ; dup v1.b16, W(<u8 as Into<_>>::into(rhs))
[INFO] [stdout]      |                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2082:16
[INFO] [stdout]      |
[INFO] [stdout] 2082 |         ; umov W(SCRATCH0), v5.b[0]
[INFO] [stdout]      |                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2082 |         ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.b[0]
[INFO] [stdout]      |                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2085:16
[INFO] [stdout]      |
[INFO] [stdout] 2085 |         ; umov W(SCRATCH1), v5.b[0]
[INFO] [stdout]      |                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2085 |         ; umov W(<u8 as Into<_>>::into(SCRATCH1)), v5.b[0]
[INFO] [stdout]      |                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2088:15
[INFO] [stdout]      |
[INFO] [stdout] 2088 |         ; mov X(destination), x30
[INFO] [stdout]      |               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2088 |         ; mov X(<u8 as Into<_>>::into(destination)), x30
[INFO] [stdout]      |                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2456:43
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(base), x17);
[INFO] [stdout]      |                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2456:59
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                                           ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(base)), x17);
[INFO] [stdout]      |                                                             ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2465:47
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(destination));
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(base), X(destination));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2465:63
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(destination));
[INFO] [stdout]      |                                                               ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(base)), X(destination));
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2465:72
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(destination));
[INFO] [stdout]      |                                                                        ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(<u8 as Into<_>>::into(destination)));
[INFO] [stdout]      |                                                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2468:39
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(destination), X(destination), x17);
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(destination), x17);
[INFO] [stdout]      |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2468:55
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(destination), X(destination), x17);
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(destination)), x17);
[INFO] [stdout]      |                                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2970:43
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(destination), X(base));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(destination)), X(base));
[INFO] [stdout]      |                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2970:59
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(destination), X(base));
[INFO] [stdout]      |                                                           ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(destination), X(<u8 as Into<_>>::into(base)));
[INFO] [stdout]      |                                                             ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2977:47
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(base), x17);
[INFO] [stdout]      |                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2977:63
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                                               ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(base)), x17);
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3072:52
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3072:68
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3072:68
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3075:52
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3075:68
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3075:68
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3078:51
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3078:67
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3078:67
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3081:51
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3081:67
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3081:67
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3086:48
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(base)), X(index), LSL #shift);
[INFO] [stdout]      |                                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3086:57
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                         ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(<u8 as Into<_>>::into(index)), LSL #shift);
[INFO] [stdout]      |                                                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3123:52
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3123:63
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3123:63
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3126:52
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3126:63
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3126:63
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3129:51
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3129:62
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3129:62
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3132:51
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3132:62
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3132:62
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3137:48
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(base)), X(index), LSL #shift);
[INFO] [stdout]      |                                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3137:57
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                         ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(<u8 as Into<_>>::into(index)), LSL #shift);
[INFO] [stdout]      |                                                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3419:58
[INFO] [stdout]      |
[INFO] [stdout] 3419 |         (false, 0) => dynasm!(ops ; .arch aarch64 ; movz X(register), half),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3419 |         (false, 0) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3420:58
[INFO] [stdout]      |
[INFO] [stdout] 3420 |         (false, 1) => dynasm!(ops ; .arch aarch64 ; movz X(register), half, LSL #16),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3420 |         (false, 1) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half, LSL #16),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3421:58
[INFO] [stdout]      |
[INFO] [stdout] 3421 |         (false, 2) => dynasm!(ops ; .arch aarch64 ; movz X(register), half, LSL #32),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3421 |         (false, 2) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half, LSL #32),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3422:58
[INFO] [stdout]      |
[INFO] [stdout] 3422 |         (false, 3) => dynasm!(ops ; .arch aarch64 ; movz X(register), half, LSL #48),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3422 |         (false, 3) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half, LSL #48),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3423:57
[INFO] [stdout]      |
[INFO] [stdout] 3423 |         (true, 0) => dynasm!(ops ; .arch aarch64 ; movn X(register), half),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3423 |         (true, 0) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3424:57
[INFO] [stdout]      |
[INFO] [stdout] 3424 |         (true, 1) => dynasm!(ops ; .arch aarch64 ; movn X(register), half, LSL #16),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3424 |         (true, 1) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half, LSL #16),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3425:57
[INFO] [stdout]      |
[INFO] [stdout] 3425 |         (true, 2) => dynasm!(ops ; .arch aarch64 ; movn X(register), half, LSL #32),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3425 |         (true, 2) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half, LSL #32),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3426:57
[INFO] [stdout]      |
[INFO] [stdout] 3426 |         (true, 3) => dynasm!(ops ; .arch aarch64 ; movn X(register), half, LSL #48),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3426 |         (true, 3) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half, LSL #48),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3435:53
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             0 => dynasm!(ops ; .arch aarch64 ; movk X(register), half),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             0 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3436:53
[INFO] [stdout]      |
[INFO] [stdout] 3436 |             1 => dynasm!(ops ; .arch aarch64 ; movk X(register), half, LSL #16),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3436 |             1 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half, LSL #16),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3437:53
[INFO] [stdout]      |
[INFO] [stdout] 3437 |             2 => dynasm!(ops ; .arch aarch64 ; movk X(register), half, LSL #32),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3437 |             2 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half, LSL #32),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3438:53
[INFO] [stdout]      |
[INFO] [stdout] 3438 |             3 => dynasm!(ops ; .arch aarch64 ; movk X(register), half, LSL #48),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3438 |             3 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half, LSL #48),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3451:58
[INFO] [stdout]      |
[INFO] [stdout] 3451 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3451 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3451:74
[INFO] [stdout]      |
[INFO] [stdout] 3451 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout]      |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3451 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3451 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3451 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3451 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3452:59
[INFO] [stdout]      |
[INFO] [stdout] 3452 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3452 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3452:75
[INFO] [stdout]      |
[INFO] [stdout] 3452 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout]      |                                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3452 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3452 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3452 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3452 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3453:58
[INFO] [stdout]      |
[INFO] [stdout] 3453 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3453 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3453:74
[INFO] [stdout]      |
[INFO] [stdout] 3453 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout]      |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3453 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3453 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3453 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3453 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3454:58
[INFO] [stdout]      |
[INFO] [stdout] 3454 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3454 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3454:74
[INFO] [stdout]      |
[INFO] [stdout] 3454 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout]      |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3454 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3454 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3454 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3454 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3460:58
[INFO] [stdout]      |
[INFO] [stdout] 3460 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3460 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3460:69
[INFO] [stdout]      |
[INFO] [stdout] 3460 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout]      |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3460 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3460 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3460 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3460 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3461:59
[INFO] [stdout]      |
[INFO] [stdout] 3461 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3461 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3461:70
[INFO] [stdout]      |
[INFO] [stdout] 3461 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3461 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3461 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3461 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3461 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3462:58
[INFO] [stdout]      |
[INFO] [stdout] 3462 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3462 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3462:69
[INFO] [stdout]      |
[INFO] [stdout] 3462 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout]      |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3462 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3462 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3462 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3462 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3463:58
[INFO] [stdout]      |
[INFO] [stdout] 3463 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3463 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3463:69
[INFO] [stdout]      |
[INFO] [stdout] 3463 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout]      |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3463 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3463 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3463 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3463 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3474:59
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3474:70
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3474 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3474 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3475:60
[INFO] [stdout]      |
[INFO] [stdout] 3475 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout]      |                                                            ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3475 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3475:71
[INFO] [stdout]      |
[INFO] [stdout] 3475 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout]      |                                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3475 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3475 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3475 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3475 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3476:59
[INFO] [stdout]      |
[INFO] [stdout] 3476 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3476 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3476:70
[INFO] [stdout]      |
[INFO] [stdout] 3476 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3476 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3476 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3476 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3476 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3477:59
[INFO] [stdout]      |
[INFO] [stdout] 3477 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3477 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3477:70
[INFO] [stdout]      |
[INFO] [stdout] 3477 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3477 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3477 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3477 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3477 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3483:59
[INFO] [stdout]      |
[INFO] [stdout] 3483 |         CmpKind::Eq => dynasm!(ops ; .arch aarch64 ; cset X(destination), eq),
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3483 |         CmpKind::Eq => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), eq),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3484:59
[INFO] [stdout]      |
[INFO] [stdout] 3484 |         CmpKind::Ne => dynasm!(ops ; .arch aarch64 ; cset X(destination), ne),
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3484 |         CmpKind::Ne => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), ne),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3485:60
[INFO] [stdout]      |
[INFO] [stdout] 3485 |         CmpKind::LtU => dynasm!(ops ; .arch aarch64 ; cset X(destination), lo),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3485 |         CmpKind::LtU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), lo),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3486:60
[INFO] [stdout]      |
[INFO] [stdout] 3486 |         CmpKind::LtS => dynasm!(ops ; .arch aarch64 ; cset X(destination), lt),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3486 |         CmpKind::LtS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), lt),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3487:60
[INFO] [stdout]      |
[INFO] [stdout] 3487 |         CmpKind::LeU => dynasm!(ops ; .arch aarch64 ; cset X(destination), ls),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3487 |         CmpKind::LeU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), ls),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3488:60
[INFO] [stdout]      |
[INFO] [stdout] 3488 |         CmpKind::LeS => dynasm!(ops ; .arch aarch64 ; cset X(destination), le),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3488 |         CmpKind::LeS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), le),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3489:60
[INFO] [stdout]      |
[INFO] [stdout] 3489 |         CmpKind::GtU => dynasm!(ops ; .arch aarch64 ; cset X(destination), hi),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3489 |         CmpKind::GtU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), hi),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3490:60
[INFO] [stdout]      |
[INFO] [stdout] 3490 |         CmpKind::GtS => dynasm!(ops ; .arch aarch64 ; cset X(destination), gt),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3490 |         CmpKind::GtS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), gt),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3491:60
[INFO] [stdout]      |
[INFO] [stdout] 3491 |         CmpKind::GeU => dynasm!(ops ; .arch aarch64 ; cset X(destination), hs),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3491 |         CmpKind::GeU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), hs),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3492:60
[INFO] [stdout]      |
[INFO] [stdout] 3492 |         CmpKind::GeS => dynasm!(ops ; .arch aarch64 ; cset X(destination), ge),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3492 |         CmpKind::GeS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), ge),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3505:48
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3505:64
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), eq)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3505:79
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), eq)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3508:48
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3508:64
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), ne)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3508:79
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), ne)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3511:48
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3511:64
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), lo)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3511:79
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), lo)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3514:48
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3514:64
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), lt)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3514:79
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), lt)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3517:48
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3517:64
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), ls)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3517:79
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), ls)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3520:48
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3520:64
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), le)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3520:79
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), le)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3523:48
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3523:64
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), hi)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3523:79
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), hi)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3526:48
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3526:64
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), gt)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3526:79
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), gt)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3529:48
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3529:64
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), hs)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3529:79
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), hs)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3532:48
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3532:64
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), ge)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3532:79
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), ge)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3546:47
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3546:55
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]      |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3552:51
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                 dynasm!(ops ; .arch aarch64 ; cmp X(lhs), x16);
[INFO] [stdout]      |                                                   ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), x16);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3643:32
[INFO] [stdout]      |
[INFO] [stdout] 3643 |                     ; mov x16, X(left)
[INFO] [stdout]      |                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3643 |                     ; mov x16, X(<u8 as Into<_>>::into(left))
[INFO] [stdout]      |                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3644:27
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(left), X(right)
[INFO] [stdout]      |                           ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(<u8 as Into<_>>::into(left)), X(right)
[INFO] [stdout]      |                             ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3644:36
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(left), X(right)
[INFO] [stdout]      |                                    ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(left), X(<u8 as Into<_>>::into(right))
[INFO] [stdout]      |                                      ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3645:27
[INFO] [stdout]      |
[INFO] [stdout] 3645 |                     ; mov X(right), x16
[INFO] [stdout]      |                           ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3645 |                     ; mov X(<u8 as Into<_>>::into(right)), x16
[INFO] [stdout]      |                             ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3712:47
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(output), X(register));
[INFO] [stdout]      |                                               ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(output)), X(register));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3712:58
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(output), X(register));
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(output), X(<u8 as Into<_>>::into(register)));
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3729:47
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(source));
[INFO] [stdout]      |                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(register)), X(source));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3729:60
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(source));
[INFO] [stdout]      |                                                            ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(<u8 as Into<_>>::into(source)));
[INFO] [stdout]      |                                                              ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `celox-backend-arm64` (lib) due to 276 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:419:48
[INFO] [stdout]     |
[INFO] [stdout] 419 |         dynasm!(ops ; .arch aarch64 ; stp x30, X(first), [sp, #-16]!);
[INFO] [stdout]     |                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 419 |         dynasm!(ops ; .arch aarch64 ; stp x30, X(<u8 as Into<_>>::into(first)), [sp, #-16]!);
[INFO] [stdout]     |                                                  ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:424:23
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(callee_saved[index]), X(callee_saved[index + 1]), [sp, #-16]!
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(<u8 as Into<_>>::into(callee_saved[index])), X(callee_saved[index + 1]), [sp, #-16]!
[INFO] [stdout]     |                         ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:424:47
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(callee_saved[index]), X(callee_saved[index + 1]), [sp, #-16]!
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 |                 ; stp X(callee_saved[index]), X(<u8 as Into<_>>::into(callee_saved[index + 1])), [sp, #-16]!
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:429:47
[INFO] [stdout]     |
[INFO] [stdout] 429 |             dynasm!(ops ; .arch aarch64 ; str X(callee_saved[index]), [sp, #-16]!);
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 |             dynasm!(ops ; .arch aarch64 ; str X(<u8 as Into<_>>::into(callee_saved[index])), [sp, #-16]!);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:545:47
[INFO] [stdout]     |
[INFO] [stdout] 545 |             dynasm!(ops ; .arch aarch64 ; ldr X(callee_saved[index]), [sp], #16);
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 545 |             dynasm!(ops ; .arch aarch64 ; ldr X(<u8 as Into<_>>::into(callee_saved[index])), [sp], #16);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:551:23
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(callee_saved[index]), X(callee_saved[index + 1]), [sp], #16
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(<u8 as Into<_>>::into(callee_saved[index])), X(callee_saved[index + 1]), [sp], #16
[INFO] [stdout]     |                         ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:551:47
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(callee_saved[index]), X(callee_saved[index + 1]), [sp], #16
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 |                 ; ldp X(callee_saved[index]), X(<u8 as Into<_>>::into(callee_saved[index + 1])), [sp], #16
[INFO] [stdout]     |                                                 ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:554:48
[INFO] [stdout]     |
[INFO] [stdout] 554 |         dynasm!(ops ; .arch aarch64 ; ldp x30, X(callee_saved[0]), [sp], #16);
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 |         dynasm!(ops ; .arch aarch64 ; ldp x30, X(<u8 as Into<_>>::into(callee_saved[0])), [sp], #16);
[INFO] [stdout]     |                                                  ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:608:51
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), X(src));
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), X(src));
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:608:59
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), X(src));
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:613:47
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(dst), W(src));
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(<u8 as Into<_>>::into(dst)), W(src));
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:613:55
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(dst), W(src));
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 613 |             dynasm!(ops ; .arch aarch64 ; mov W(dst), W(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:624:48
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(dst), X(src), lsb, width);
[INFO] [stdout]     |                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(<u8 as Into<_>>::into(dst)), X(src), lsb, width);
[INFO] [stdout]     |                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:624:56
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(dst), X(src), lsb, width);
[INFO] [stdout]     |                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 624 |             dynasm!(ops ; .arch aarch64 ; ubfx X(dst), X(<u8 as Into<_>>::into(src)), lsb, width);
[INFO] [stdout]     |                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:652:47
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:652:55
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:652:63
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs), LSL #shift);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 |             dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs)), LSL #shift);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:660:47
[INFO] [stdout]     |
[INFO] [stdout] 660 |             dynasm!(ops ; .arch aarch64 ; adr X(dst), =>label);
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 660 |             dynasm!(ops ; .arch aarch64 ; adr X(<u8 as Into<_>>::into(dst)), =>label);
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:766:65
[INFO] [stdout]     |
[INFO] [stdout] 766 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(src));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 766 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:769:60
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index));
[INFO] [stdout]     |                                                            ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(base)), X(index));
[INFO] [stdout]     |                                                              ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:769:69
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index));
[INFO] [stdout]     |                                                                     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 |                     dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(<u8 as Into<_>>::into(index)));
[INFO] [stdout]     |                                                                       ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:772:65
[INFO] [stdout]     |
[INFO] [stdout] 772 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(src));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 772 |                     dynasm!(ops ; .arch aarch64 ; orr x17, x17, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:817:56
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(ptr), X(index));
[INFO] [stdout]     |                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(ptr)), X(index));
[INFO] [stdout]     |                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:817:64
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(ptr), X(index));
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 817 |                 dynasm!(ops ; .arch aarch64 ; add x16, X(ptr), X(<u8 as Into<_>>::into(index)));
[INFO] [stdout]     |                                                                  ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:839:72
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:839:80
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:839:88
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 |                 MInst::Add { .. } => dynasm!(ops ; .arch aarch64 ; add X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:840:72
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:840:80
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:840:88
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 MInst::Sub { .. } => dynasm!(ops ; .arch aarch64 ; sub X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:841:72
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:841:80
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:841:88
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |                 MInst::Mul { .. } => dynasm!(ops ; .arch aarch64 ; mul X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:842:72
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:842:80
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:842:88
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 MInst::And { .. } => dynasm!(ops ; .arch aarch64 ; and X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:843:71
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:843:79
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:843:87
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 |                 MInst::Or { .. } => dynasm!(ops ; .arch aarch64 ; orr X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:844:72
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:844:80
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:844:88
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 844 |                 MInst::Xor { .. } => dynasm!(ops ; .arch aarch64 ; eor X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:845:73
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:845:81
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:845:89
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 845 |                 MInst::Shr { .. } => dynasm!(ops ; .arch aarch64 ; lsrv X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:846:73
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:846:81
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:846:89
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 |                 MInst::Shl { .. } => dynasm!(ops ; .arch aarch64 ; lslv X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:847:73
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:847:81
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:847:89
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |                 MInst::Sar { .. } => dynasm!(ops ; .arch aarch64 ; asrv X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:863:74
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:863:82
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:863:90
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 |                 MInst::Add32 { .. } => dynasm!(ops ; .arch aarch64 ; add W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:864:74
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:864:82
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:864:90
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 864 |                 MInst::Sub32 { .. } => dynasm!(ops ; .arch aarch64 ; sub W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:865:74
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:865:82
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:865:90
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 MInst::Mul32 { .. } => dynasm!(ops ; .arch aarch64 ; mul W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:866:74
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:866:82
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:866:90
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 866 |                 MInst::And32 { .. } => dynasm!(ops ; .arch aarch64 ; and W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:867:73
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:867:81
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:867:89
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 867 |                 MInst::Or32 { .. } => dynasm!(ops ; .arch aarch64 ; orr W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:868:74
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(<u8 as Into<_>>::into(dst)), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:868:82
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(<u8 as Into<_>>::into(lhs)), W(rhs)),
[INFO] [stdout]     |                                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:868:90
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(rhs)),
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 868 |                 MInst::Xor32 { .. } => dynasm!(ops ; .arch aarch64 ; eor W(dst), W(lhs), W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]     |                                                                                            ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:878:49
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(rhs));
[INFO] [stdout]     |                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(<u8 as Into<_>>::into(dst)), X(lhs), X(rhs));
[INFO] [stdout]     |                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:878:57
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(rhs));
[INFO] [stdout]     |                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:878:65
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(rhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 |             dynasm!(ops ; .arch aarch64 ; umulh X(dst), X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:886:55
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:886:63
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |                     dynasm!(ops ; .arch aarch64 ; and X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:888:55
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:888:63
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 |                     dynasm!(ops ; .arch aarch64 ; orr X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:896:51
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(dst), W(src), w16);
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(<u8 as Into<_>>::into(dst)), W(src), w16);
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:896:59
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(dst), W(src), w16);
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 |                 dynasm!(ops ; .arch aarch64 ; and W(dst), W(<u8 as Into<_>>::into(src)), w16);
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:908:75
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(<u8 as Into<_>>::into(dst)), X(src), #imm),
[INFO] [stdout]     |                                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:908:83
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 908 |                 MInst::ShrImm { .. } => dynasm!(ops ; .arch aarch64 ; lsr X(dst), X(<u8 as Into<_>>::into(src)), #imm),
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:909:75
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(<u8 as Into<_>>::into(dst)), X(src), #imm),
[INFO] [stdout]     |                                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:909:83
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 909 |                 MInst::ShlImm { .. } => dynasm!(ops ; .arch aarch64 ; lsl X(dst), X(<u8 as Into<_>>::into(src)), #imm),
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:910:75
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(<u8 as Into<_>>::into(dst)), X(src), #imm),
[INFO] [stdout]     |                                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:910:83
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(dst), X(src), #imm),
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 910 |                 MInst::SarImm { .. } => dynasm!(ops ; .arch aarch64 ; asr X(dst), X(<u8 as Into<_>>::into(src)), #imm),
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:924:55
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:924:63
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |                     dynasm!(ops ; .arch aarch64 ; sub X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:926:55
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(dst), X(src), x16);
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(dst)), X(src), x16);
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:926:63
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(dst), X(src), x16);
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 926 |                     dynasm!(ops ; .arch aarch64 ; add X(dst), X(<u8 as Into<_>>::into(src)), x16);
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:941:47
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:941:55
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:953:51
[INFO] [stdout]     |
[INFO] [stdout] 953 |                 dynasm!(ops ; .arch aarch64 ; cmp X(lhs), x16);
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 953 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), x16);
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:967:57
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:967:65
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 967 |                 dynasm!(ops ; .arch aarch64 ; udiv x16, X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:969:57
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]     |                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:969:65
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(lhs), X(rhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 969 |                 dynasm!(ops ; .arch aarch64 ; sdiv x16, X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:972:52
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(<u8 as Into<_>>::into(dst)), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                      ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:972:65
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(<u8 as Into<_>>::into(rhs)), X(lhs));
[INFO] [stdout]     |                                                                   ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:972:73
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(lhs));
[INFO] [stdout]     |                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |                 dynasm!(ops ; .arch aarch64 ; msub X(dst), x16, X(rhs), X(<u8 as Into<_>>::into(lhs)));
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:974:51
[INFO] [stdout]     |
[INFO] [stdout] 974 |                 dynasm!(ops ; .arch aarch64 ; mov X(dst), x16);
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 974 |                 dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), x16);
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:980:51
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(dst), X(src));
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(<u8 as Into<_>>::into(dst)), X(src));
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:980:59
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(dst), X(src));
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 |                 dynasm!(ops ; .arch aarch64 ; mvn X(dst), X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:982:51
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(dst), X(src));
[INFO] [stdout]     |                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(<u8 as Into<_>>::into(dst)), X(src));
[INFO] [stdout]     |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:982:59
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(dst), X(src));
[INFO] [stdout]     |                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 |                 dynasm!(ops ; .arch aarch64 ; neg X(dst), X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]     |                                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:989:28
[INFO] [stdout]     |
[INFO] [stdout] 989 |                 ; fmov d0, X(src)
[INFO] [stdout]     |                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 989 |                 ; fmov d0, X(<u8 as Into<_>>::into(src))
[INFO] [stdout]     |                              ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:992:24
[INFO] [stdout]     |
[INFO] [stdout] 992 |                 ; umov W(dst), v0.b[0]
[INFO] [stdout]     |                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 992 |                 ; umov W(<u8 as Into<_>>::into(dst)), v0.b[0]
[INFO] [stdout]     |                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:997:53
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(src) ; clz X(dst), x16);
[INFO] [stdout]     |                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(<u8 as Into<_>>::into(src)) ; clz X(dst), x16);
[INFO] [stdout]     |                                                       ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]    --> src/scalar.rs:997:66
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(src) ; clz X(dst), x16);
[INFO] [stdout]     |                                                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 997 |             dynasm!(ops ; .arch aarch64 ; rbit x16, X(src) ; clz X(<u8 as Into<_>>::into(dst)), x16);
[INFO] [stdout]     |                                                                    ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1001:52
[INFO] [stdout]      |
[INFO] [stdout] 1001 |             dynasm!(ops ; .arch aarch64 ; clz x16, X(src));
[INFO] [stdout]      |                                                    ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1001 |             dynasm!(ops ; .arch aarch64 ; clz x16, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]      |                                                      ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1004:47
[INFO] [stdout]      |
[INFO] [stdout] 1004 |             dynasm!(ops ; .arch aarch64 ; mov X(dst), x16);
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1004 |             dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), x16);
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1020:23
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 ; cmp XSP(cond), #0
[INFO] [stdout]      |                       ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 ; cmp XSP(<u8 as Into<_>>::into(cond)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1021:24
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                        ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(<u8 as Into<_>>::into(dst)), X(true_val), X(false_val), ne
[INFO] [stdout]      |                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1021:32
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(<u8 as Into<_>>::into(true_val)), X(false_val), ne
[INFO] [stdout]      |                                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1021:45
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 |                 ; csel X(dst), X(true_val), X(<u8 as Into<_>>::into(false_val)), ne
[INFO] [stdout]      |                                               ++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1039:47
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1039:55
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1039 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]      |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1058:51
[INFO] [stdout]      |
[INFO] [stdout] 1058 |                 dynasm!(ops ; .arch aarch64 ; cmp X(lhs), x16);
[INFO] [stdout]      |                                                   ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1058 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), x16);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1073:51
[INFO] [stdout]      |
[INFO] [stdout] 1073 |                 dynasm!(ops ; .arch aarch64 ; cmp X(index), x16 ; b.eq =>path);
[INFO] [stdout]      |                                                   ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1073 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(index)), x16 ; b.eq =>path);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1109:56
[INFO] [stdout]      |
[INFO] [stdout] 1109 |                     dynasm!(ops ; .arch aarch64 ; cbnz X(cond), =>target_label);
[INFO] [stdout]      |                                                        ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1109 |                     dynasm!(ops ; .arch aarch64 ; cbnz X(<u8 as Into<_>>::into(cond)), =>target_label);
[INFO] [stdout]      |                                                          ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1111:55
[INFO] [stdout]      |
[INFO] [stdout] 1111 |                     dynasm!(ops ; .arch aarch64 ; cbz X(cond), =>target_label);
[INFO] [stdout]      |                                                       ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1111 |                     dynasm!(ops ; .arch aarch64 ; cbz X(<u8 as Into<_>>::into(cond)), =>target_label);
[INFO] [stdout]      |                                                         ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1132:51
[INFO] [stdout]      |
[INFO] [stdout] 1132 |                 dynasm!(ops ; .arch aarch64 ; cbz X(cond), =>true_path);
[INFO] [stdout]      |                                                   ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1132 |                 dynasm!(ops ; .arch aarch64 ; cbz X(<u8 as Into<_>>::into(cond)), =>true_path);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1134:52
[INFO] [stdout]      |
[INFO] [stdout] 1134 |                 dynasm!(ops ; .arch aarch64 ; cbnz X(cond), =>true_path);
[INFO] [stdout]      |                                                    ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1134 |                 dynasm!(ops ; .arch aarch64 ; cbnz X(<u8 as Into<_>>::into(cond)), =>true_path);
[INFO] [stdout]      |                                                      ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1400:47
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1400:55
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1400 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]      |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1404:23
[INFO] [stdout]      |
[INFO] [stdout] 1404 |                 ; cmp XSP(guard), #0
[INFO] [stdout]      |                       ^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1404 |                 ; cmp XSP(<u8 as Into<_>>::into(guard)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1407:24
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                        ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(<u8 as Into<_>>::into(dst)), X(true_val), X(false_val), ne
[INFO] [stdout]      |                          ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1407:32
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(<u8 as Into<_>>::into(true_val)), X(false_val), ne
[INFO] [stdout]      |                                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1407:45
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(false_val), ne
[INFO] [stdout]      |                                             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1407 |                 ; csel X(dst), X(true_val), X(<u8 as Into<_>>::into(false_val)), ne
[INFO] [stdout]      |                                               ++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1424:52
[INFO] [stdout]      |
[INFO] [stdout] 1424 |             dynasm!(ops ; .arch aarch64 ; mov x16, X(src));
[INFO] [stdout]      |                                                    ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1424 |             dynasm!(ops ; .arch aarch64 ; mov x16, X(<u8 as Into<_>>::into(src)));
[INFO] [stdout]      |                                                      ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1427:43
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(dst), X(base));
[INFO] [stdout]      |                                           ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(dst)), X(base));
[INFO] [stdout]      |                                             ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1427:51
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(dst), X(base));
[INFO] [stdout]      |                                                   ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1427 |         dynasm!(ops ; .arch aarch64 ; mov X(dst), X(<u8 as Into<_>>::into(base)));
[INFO] [stdout]      |                                                     ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1430:39
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(dst), X(src), lsb, width);
[INFO] [stdout]      |                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(<u8 as Into<_>>::into(dst)), X(src), lsb, width);
[INFO] [stdout]      |                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1430:47
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(dst), X(src), lsb, width);
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1430 |     dynasm!(ops ; .arch aarch64 ; bfi X(dst), X(<u8 as Into<_>>::into(src)), lsb, width);
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1646:56
[INFO] [stdout]      |
[INFO] [stdout] 1646 |                 dynasm!(ops ; .arch aarch64 ; mov x17, X(scalar_rhs.unwrap()));
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1646 |                 dynasm!(ops ; .arch aarch64 ; mov x17, X(<u8 as Into<_>>::into(scalar_rhs.unwrap())));
[INFO] [stdout]      |                                                          ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1714:39
[INFO] [stdout]      |
[INFO] [stdout] 1714 |     dynasm!(ops ; .arch aarch64 ; mov X(destination), x30);
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1714 |     dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(destination)), x30);
[INFO] [stdout]      |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1748:60
[INFO] [stdout]      |
[INFO] [stdout] 1748 |             1 => dynasm!(ops ; .arch aarch64 ; dup v4.b16, W(SCRATCH1)),
[INFO] [stdout]      |                                                            ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1748 |             1 => dynasm!(ops ; .arch aarch64 ; dup v4.b16, W(<u8 as Into<_>>::into(SCRATCH1))),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1749:59
[INFO] [stdout]      |
[INFO] [stdout] 1749 |             2 => dynasm!(ops ; .arch aarch64 ; dup v4.h8, W(SCRATCH1)),
[INFO] [stdout]      |                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1749 |             2 => dynasm!(ops ; .arch aarch64 ; dup v4.h8, W(<u8 as Into<_>>::into(SCRATCH1))),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1750:59
[INFO] [stdout]      |
[INFO] [stdout] 1750 |             4 => dynasm!(ops ; .arch aarch64 ; dup v4.s4, W(SCRATCH1)),
[INFO] [stdout]      |                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1750 |             4 => dynasm!(ops ; .arch aarch64 ; dup v4.s4, W(<u8 as Into<_>>::into(SCRATCH1))),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1778:64
[INFO] [stdout]      |
[INFO] [stdout] 1778 |                 1 => dynasm!(ops ; .arch aarch64 ; dup v1.b16, W(rhs)),
[INFO] [stdout]      |                                                                ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1778 |                 1 => dynasm!(ops ; .arch aarch64 ; dup v1.b16, W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1779:63
[INFO] [stdout]      |
[INFO] [stdout] 1779 |                 2 => dynasm!(ops ; .arch aarch64 ; dup v1.h8, W(rhs)),
[INFO] [stdout]      |                                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1779 |                 2 => dynasm!(ops ; .arch aarch64 ; dup v1.h8, W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1780:63
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                 4 => dynasm!(ops ; .arch aarch64 ; dup v1.s4, W(rhs)),
[INFO] [stdout]      |                                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1780 |                 4 => dynasm!(ops ; .arch aarch64 ; dup v1.s4, W(<u8 as Into<_>>::into(rhs))),
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1830:39
[INFO] [stdout]      |
[INFO] [stdout] 1830 |     dynasm!(ops ; .arch aarch64 ; mov X(destination), x30);
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1830 |     dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(destination)), x30);
[INFO] [stdout]      |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1967:24
[INFO] [stdout]      |
[INFO] [stdout] 1967 |                 ; umov W(SCRATCH0), v5.b[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1967 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.b[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1970:24
[INFO] [stdout]      |
[INFO] [stdout] 1970 |                 ; umov W(SCRATCH1), v5.b[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1970 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH1)), v5.b[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:1986:24
[INFO] [stdout]      |
[INFO] [stdout] 1986 |                 ; umov W(SCRATCH0), v5.h[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1986 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.h[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2000:24
[INFO] [stdout]      |
[INFO] [stdout] 2000 |                 ; umov W(SCRATCH0), v5.s[0]
[INFO] [stdout]      |                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2000 |                 ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.s[0]
[INFO] [stdout]      |                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2025:23
[INFO] [stdout]      |
[INFO] [stdout] 2025 |         ; dup v4.b16, W(base)
[INFO] [stdout]      |                       ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2025 |         ; dup v4.b16, W(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |                         ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2026:23
[INFO] [stdout]      |
[INFO] [stdout] 2026 |         ; dup v1.b16, W(rhs)
[INFO] [stdout]      |                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2026 |         ; dup v1.b16, W(<u8 as Into<_>>::into(rhs))
[INFO] [stdout]      |                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2082:16
[INFO] [stdout]      |
[INFO] [stdout] 2082 |         ; umov W(SCRATCH0), v5.b[0]
[INFO] [stdout]      |                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2082 |         ; umov W(<u8 as Into<_>>::into(SCRATCH0)), v5.b[0]
[INFO] [stdout]      |                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2085:16
[INFO] [stdout]      |
[INFO] [stdout] 2085 |         ; umov W(SCRATCH1), v5.b[0]
[INFO] [stdout]      |                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2085 |         ; umov W(<u8 as Into<_>>::into(SCRATCH1)), v5.b[0]
[INFO] [stdout]      |                  ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2088:15
[INFO] [stdout]      |
[INFO] [stdout] 2088 |         ; mov X(destination), x30
[INFO] [stdout]      |               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2088 |         ; mov X(<u8 as Into<_>>::into(destination)), x30
[INFO] [stdout]      |                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2456:43
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(base), x17);
[INFO] [stdout]      |                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2456:59
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                                           ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2456 |         dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(base)), x17);
[INFO] [stdout]      |                                                             ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2465:47
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(destination));
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(base), X(destination));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2465:63
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(destination));
[INFO] [stdout]      |                                                               ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(base)), X(destination));
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2465:72
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(destination));
[INFO] [stdout]      |                                                                        ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), X(<u8 as Into<_>>::into(destination)));
[INFO] [stdout]      |                                                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2468:39
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(destination), X(destination), x17);
[INFO] [stdout]      |                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(destination), x17);
[INFO] [stdout]      |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2468:55
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(destination), X(destination), x17);
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2468 |     dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(destination)), x17);
[INFO] [stdout]      |                                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2970:43
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(destination), X(base));
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(destination)), X(base));
[INFO] [stdout]      |                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2970:59
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(destination), X(base));
[INFO] [stdout]      |                                                           ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2970 |         dynasm!(ops ; .arch aarch64 ; mov X(destination), X(<u8 as Into<_>>::into(base)));
[INFO] [stdout]      |                                                             ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2977:47
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(<u8 as Into<_>>::into(destination)), X(base), x17);
[INFO] [stdout]      |                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:2977:63
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(base), x17);
[INFO] [stdout]      |                                                               ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2977 |             dynasm!(ops ; .arch aarch64 ; add X(destination), X(<u8 as Into<_>>::into(base)), x17);
[INFO] [stdout]      |                                                                 ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3072:52
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3072:68
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3072:68
[INFO] [stdout]      |
[INFO] [stdout] 3072 |                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3072 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3072 +                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3075:52
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3075:68
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3075:68
[INFO] [stdout]      |
[INFO] [stdout] 3075 |                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3075 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3075 +                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3078:51
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3078:67
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3078:67
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3078 +                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3081:51
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(<u8 as Into<_>>::into(destination)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3081:67
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3081:67
[INFO] [stdout]      |
[INFO] [stdout] 3081 |                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3081 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3081 +                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3086:48
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(base)), X(index), LSL #shift);
[INFO] [stdout]      |                                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3086:57
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                         ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3086 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(<u8 as Into<_>>::into(index)), LSL #shift);
[INFO] [stdout]      |                                                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3123:52
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3123:63
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3123:63
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3123 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3126:52
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                    ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                      ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3126:63
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3126:63
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3126 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3129:51
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3129:62
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3129:62
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3129 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3132:51
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                   ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(<u8 as Into<_>>::into(source)), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                     ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3132:62
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(<u8 as Into<_>>::into(base))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3132:62
[INFO] [stdout]      |
[INFO] [stdout] 3132 |                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index)
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3132 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3132 +                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(<u8 as Into<_>>::into(index))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3137:48
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(<u8 as Into<_>>::into(base)), X(index), LSL #shift);
[INFO] [stdout]      |                                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3137:57
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(index), LSL #shift);
[INFO] [stdout]      |                                                         ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3137 |         dynasm!(ops ; .arch aarch64 ; add x16, X(base), X(<u8 as Into<_>>::into(index)), LSL #shift);
[INFO] [stdout]      |                                                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3419:58
[INFO] [stdout]      |
[INFO] [stdout] 3419 |         (false, 0) => dynasm!(ops ; .arch aarch64 ; movz X(register), half),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3419 |         (false, 0) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3420:58
[INFO] [stdout]      |
[INFO] [stdout] 3420 |         (false, 1) => dynasm!(ops ; .arch aarch64 ; movz X(register), half, LSL #16),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3420 |         (false, 1) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half, LSL #16),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3421:58
[INFO] [stdout]      |
[INFO] [stdout] 3421 |         (false, 2) => dynasm!(ops ; .arch aarch64 ; movz X(register), half, LSL #32),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3421 |         (false, 2) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half, LSL #32),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3422:58
[INFO] [stdout]      |
[INFO] [stdout] 3422 |         (false, 3) => dynasm!(ops ; .arch aarch64 ; movz X(register), half, LSL #48),
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3422 |         (false, 3) => dynasm!(ops ; .arch aarch64 ; movz X(<u8 as Into<_>>::into(register)), half, LSL #48),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3423:57
[INFO] [stdout]      |
[INFO] [stdout] 3423 |         (true, 0) => dynasm!(ops ; .arch aarch64 ; movn X(register), half),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3423 |         (true, 0) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3424:57
[INFO] [stdout]      |
[INFO] [stdout] 3424 |         (true, 1) => dynasm!(ops ; .arch aarch64 ; movn X(register), half, LSL #16),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3424 |         (true, 1) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half, LSL #16),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3425:57
[INFO] [stdout]      |
[INFO] [stdout] 3425 |         (true, 2) => dynasm!(ops ; .arch aarch64 ; movn X(register), half, LSL #32),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3425 |         (true, 2) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half, LSL #32),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3426:57
[INFO] [stdout]      |
[INFO] [stdout] 3426 |         (true, 3) => dynasm!(ops ; .arch aarch64 ; movn X(register), half, LSL #48),
[INFO] [stdout]      |                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3426 |         (true, 3) => dynasm!(ops ; .arch aarch64 ; movn X(<u8 as Into<_>>::into(register)), half, LSL #48),
[INFO] [stdout]      |                                                           ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3435:53
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             0 => dynasm!(ops ; .arch aarch64 ; movk X(register), half),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             0 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3436:53
[INFO] [stdout]      |
[INFO] [stdout] 3436 |             1 => dynasm!(ops ; .arch aarch64 ; movk X(register), half, LSL #16),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3436 |             1 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half, LSL #16),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3437:53
[INFO] [stdout]      |
[INFO] [stdout] 3437 |             2 => dynasm!(ops ; .arch aarch64 ; movk X(register), half, LSL #32),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3437 |             2 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half, LSL #32),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3438:53
[INFO] [stdout]      |
[INFO] [stdout] 3438 |             3 => dynasm!(ops ; .arch aarch64 ; movk X(register), half, LSL #48),
[INFO] [stdout]      |                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3438 |             3 => dynasm!(ops ; .arch aarch64 ; movk X(<u8 as Into<_>>::into(register)), half, LSL #48),
[INFO] [stdout]      |                                                       ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3451:58
[INFO] [stdout]      |
[INFO] [stdout] 3451 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3451 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3451:74
[INFO] [stdout]      |
[INFO] [stdout] 3451 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout]      |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3451 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3451 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3451 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3451 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3452:59
[INFO] [stdout]      |
[INFO] [stdout] 3452 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3452 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3452:75
[INFO] [stdout]      |
[INFO] [stdout] 3452 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout]      |                                                                           ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3452 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3452 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3452 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3452 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3453:58
[INFO] [stdout]      |
[INFO] [stdout] 3453 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3453 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3453:74
[INFO] [stdout]      |
[INFO] [stdout] 3453 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout]      |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3453 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3453 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3453 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3453 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3454:58
[INFO] [stdout]      |
[INFO] [stdout] 3454 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3454 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(<u8 as Into<_>>::into(destination)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3454:74
[INFO] [stdout]      |
[INFO] [stdout] 3454 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout]      |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3454 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3454 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3454 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3454 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3460:58
[INFO] [stdout]      |
[INFO] [stdout] 3460 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3460 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3460:69
[INFO] [stdout]      |
[INFO] [stdout] 3460 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout]      |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3460 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3460 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3460 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3460 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3461:59
[INFO] [stdout]      |
[INFO] [stdout] 3461 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3461 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3461:70
[INFO] [stdout]      |
[INFO] [stdout] 3461 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3461 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3461 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3461 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3461 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3462:58
[INFO] [stdout]      |
[INFO] [stdout] 3462 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3462 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3462:69
[INFO] [stdout]      |
[INFO] [stdout] 3462 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout]      |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3462 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3462 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3462 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3462 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3463:58
[INFO] [stdout]      |
[INFO] [stdout] 3463 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout]      |                                                          ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3463 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                            ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3463:69
[INFO] [stdout]      |
[INFO] [stdout] 3463 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout]      |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3463 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3463 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3463 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3463 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3474:59
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3474:70
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3474 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3474 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3474 +         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3475:60
[INFO] [stdout]      |
[INFO] [stdout] 3475 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout]      |                                                            ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3475 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3475:71
[INFO] [stdout]      |
[INFO] [stdout] 3475 |         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout]      |                                                                       ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3475 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3475 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3475 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3475 +         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3476:59
[INFO] [stdout]      |
[INFO] [stdout] 3476 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3476 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3476:70
[INFO] [stdout]      |
[INFO] [stdout] 3476 |         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3476 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3476 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3476 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3476 +         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3477:59
[INFO] [stdout]      |
[INFO] [stdout] 3477 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout]      |                                                           ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3477 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(<u8 as Into<_>>::into(source)), [X(address)]),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3477:70
[INFO] [stdout]      |
[INFO] [stdout] 3477 |         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout]      |                                                                      ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3477 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3477 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3477 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3477 +         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(<u8 as Into<_>>::into(address)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3483:59
[INFO] [stdout]      |
[INFO] [stdout] 3483 |         CmpKind::Eq => dynasm!(ops ; .arch aarch64 ; cset X(destination), eq),
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3483 |         CmpKind::Eq => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), eq),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3484:59
[INFO] [stdout]      |
[INFO] [stdout] 3484 |         CmpKind::Ne => dynasm!(ops ; .arch aarch64 ; cset X(destination), ne),
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3484 |         CmpKind::Ne => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), ne),
[INFO] [stdout]      |                                                             ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3485:60
[INFO] [stdout]      |
[INFO] [stdout] 3485 |         CmpKind::LtU => dynasm!(ops ; .arch aarch64 ; cset X(destination), lo),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3485 |         CmpKind::LtU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), lo),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3486:60
[INFO] [stdout]      |
[INFO] [stdout] 3486 |         CmpKind::LtS => dynasm!(ops ; .arch aarch64 ; cset X(destination), lt),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3486 |         CmpKind::LtS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), lt),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3487:60
[INFO] [stdout]      |
[INFO] [stdout] 3487 |         CmpKind::LeU => dynasm!(ops ; .arch aarch64 ; cset X(destination), ls),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3487 |         CmpKind::LeU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), ls),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3488:60
[INFO] [stdout]      |
[INFO] [stdout] 3488 |         CmpKind::LeS => dynasm!(ops ; .arch aarch64 ; cset X(destination), le),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3488 |         CmpKind::LeS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), le),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3489:60
[INFO] [stdout]      |
[INFO] [stdout] 3489 |         CmpKind::GtU => dynasm!(ops ; .arch aarch64 ; cset X(destination), hi),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3489 |         CmpKind::GtU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), hi),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3490:60
[INFO] [stdout]      |
[INFO] [stdout] 3490 |         CmpKind::GtS => dynasm!(ops ; .arch aarch64 ; cset X(destination), gt),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3490 |         CmpKind::GtS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), gt),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3491:60
[INFO] [stdout]      |
[INFO] [stdout] 3491 |         CmpKind::GeU => dynasm!(ops ; .arch aarch64 ; cset X(destination), hs),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3491 |         CmpKind::GeU => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), hs),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3492:60
[INFO] [stdout]      |
[INFO] [stdout] 3492 |         CmpKind::GeS => dynasm!(ops ; .arch aarch64 ; cset X(destination), ge),
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3492 |         CmpKind::GeS => dynasm!(ops ; .arch aarch64 ; cset X(<u8 as Into<_>>::into(destination)), ge),
[INFO] [stdout]      |                                                              ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3505:48
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3505:64
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), eq)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3505:79
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), eq)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3505 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), eq)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3508:48
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3508:64
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), ne)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3508:79
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ne)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3508 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), ne)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3511:48
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3511:64
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), lo)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3511:79
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lo)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3511 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), lo)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3514:48
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3514:64
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), lt)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3514:79
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), lt)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3514 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), lt)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3517:48
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3517:64
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), ls)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3517:79
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ls)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3517 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), ls)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3520:48
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3520:64
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), le)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3520:79
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), le)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3520 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), le)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3523:48
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3523:64
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), hi)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3523:79
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hi)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3523 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), hi)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3526:48
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3526:64
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), gt)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3526:79
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), gt)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3526 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), gt)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3529:48
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3529:64
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), hs)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3529:79
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), hs)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3529 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), hs)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3532:48
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(<u8 as Into<_>>::into(destination)), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                  ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3532:64
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(<u8 as Into<_>>::into(true_value)), X(false_value), ge)
[INFO] [stdout]      |                                                                  ++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3532:79
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(false_value), ge)
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3532 |             dynasm!(ops ; .arch aarch64 ; csel X(destination), X(true_value), X(<u8 as Into<_>>::into(false_value)), ge)
[INFO] [stdout]      |                                                                                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3546:47
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                               ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), X(rhs));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3546:55
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(rhs));
[INFO] [stdout]      |                                                       ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3546 |             dynasm!(ops ; .arch aarch64 ; cmp X(lhs), X(<u8 as Into<_>>::into(rhs)));
[INFO] [stdout]      |                                                         ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3552:51
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                 dynasm!(ops ; .arch aarch64 ; cmp X(lhs), x16);
[INFO] [stdout]      |                                                   ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                 dynasm!(ops ; .arch aarch64 ; cmp X(<u8 as Into<_>>::into(lhs)), x16);
[INFO] [stdout]      |                                                     ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3643:32
[INFO] [stdout]      |
[INFO] [stdout] 3643 |                     ; mov x16, X(left)
[INFO] [stdout]      |                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3643 |                     ; mov x16, X(<u8 as Into<_>>::into(left))
[INFO] [stdout]      |                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3644:27
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(left), X(right)
[INFO] [stdout]      |                           ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(<u8 as Into<_>>::into(left)), X(right)
[INFO] [stdout]      |                             ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3644:36
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(left), X(right)
[INFO] [stdout]      |                                    ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3644 |                     ; mov X(left), X(<u8 as Into<_>>::into(right))
[INFO] [stdout]      |                                      ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3645:27
[INFO] [stdout]      |
[INFO] [stdout] 3645 |                     ; mov X(right), x16
[INFO] [stdout]      |                           ^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3645 |                     ; mov X(<u8 as Into<_>>::into(right)), x16
[INFO] [stdout]      |                             ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3712:47
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(output), X(register));
[INFO] [stdout]      |                                               ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(output)), X(register));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3712:58
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(output), X(register));
[INFO] [stdout]      |                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3712 |             dynasm!(ops ; .arch aarch64 ; mov X(output), X(<u8 as Into<_>>::into(register)));
[INFO] [stdout]      |                                                            ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3729:47
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(source));
[INFO] [stdout]      |                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(register)), X(source));
[INFO] [stdout]      |                                                 ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8` celox_backend_arm64
[INFO] [stdout]     --> src/scalar.rs:3729:60
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(source));
[INFO] [stdout]      |                                                            ^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3729 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(<u8 as Into<_>>::into(source)));
[INFO] [stdout]      |                                                              ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `celox-backend-arm64` (lib test) due to 276 previous errors
[INFO] running `Command { std: "docker" "inspect" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d", kill_on_drop: false }`
[INFO] [stdout] 7503f5c99d58e494bee93de57415e2cff02474563f9fa31fbaef99d715d5306d
