[INFO] fetching crate celox-backend-arm64 0.11.0...
[INFO] checking celox-backend-arm64-0.11.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate celox-backend-arm64 0.11.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate celox-backend-arm64 0.11.0
[INFO] finished tweaking crates.io crate celox-backend-arm64 0.11.0
[INFO] tweaked toml for crates.io crate celox-backend-arm64 0.11.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate celox-backend-arm64 0.11.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate celox-backend-arm64 0.11.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d
[INFO] running `Command { std: "docker" "start" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d", 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" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d", 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" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.190
[INFO] [stderr]    Compiling bitflags v2.13.0
[INFO] [stderr]    Compiling byteorder v1.5.0
[INFO] [stderr]    Compiling lazy_static v1.5.0
[INFO] [stderr]     Checking fxhash v0.2.1
[INFO] [stderr]    Compiling syn v3.0.8
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]    Compiling proc-macro-error-attr3 v3.1.0
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]     Checking celox-analysis v0.11.0
[INFO] [stderr]     Checking celox-backend-common v0.11.0
[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]     Checking serde v1.0.229
[INFO] [stderr]    Compiling dynasm v5.1.0
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]     Checking num-bigint v0.5.1
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]     Checking celox-design v0.11.0
[INFO] [stderr]     Checking celox-state-layout v0.11.0
[INFO] [stderr]     Checking celox-sir v0.11.0
[INFO] [stderr]     Checking dynasmrt v5.1.0
[INFO] [stderr]     Checking celox-backend-arm64 v0.11.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/scalar/extern_call.rs:77:43
[INFO] [stdout]    |
[INFO] [stdout] 77 |         dynasm!(ops ; .arch aarch64 ; str D(register), [sp, offset]);
[INFO] [stdout]    |                                           ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 77 |         dynasm!(ops ; .arch aarch64 ; str D(<u8 as Into<_>>::into(register)), [sp, offset]);
[INFO] [stdout]    |                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar/extern_call.rs:122:43
[INFO] [stdout]     |
[INFO] [stdout] 122 |         dynasm!(ops ; .arch aarch64 ; mov X(register), x0);
[INFO] [stdout]     |                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 122 |         dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(register)), x0);
[INFO] [stdout]     |                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar/extern_call.rs:126:43
[INFO] [stdout]     |
[INFO] [stdout] 126 |         dynasm!(ops ; .arch aarch64 ; ldr D(register), [sp, offset]);
[INFO] [stdout]     |                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 126 |         dynasm!(ops ; .arch aarch64 ; ldr D(<u8 as Into<_>>::into(register)), [sp, offset]);
[INFO] [stdout]     |                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar.rs:447:48
[INFO] [stdout]     |
[INFO] [stdout] 447 |         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] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 447 |         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`
[INFO] [stdout]    --> src/scalar.rs:452:23
[INFO] [stdout]     |
[INFO] [stdout] 452 |                 ; 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] 452 |                 ; 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`
[INFO] [stdout]    --> src/scalar.rs:452:47
[INFO] [stdout]     |
[INFO] [stdout] 452 |                 ; 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] 452 |                 ; 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`
[INFO] [stdout]    --> src/scalar.rs:457:47
[INFO] [stdout]     |
[INFO] [stdout] 457 |             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] 457 |             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`
[INFO] [stdout]    --> src/scalar.rs:592:47
[INFO] [stdout]     |
[INFO] [stdout] 592 |             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] 592 |             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`
[INFO] [stdout]    --> src/scalar.rs:598:23
[INFO] [stdout]     |
[INFO] [stdout] 598 |                 ; 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] 598 |                 ; 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`
[INFO] [stdout]    --> src/scalar.rs:598:47
[INFO] [stdout]     |
[INFO] [stdout] 598 |                 ; 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] 598 |                 ; 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`
[INFO] [stdout]    --> src/scalar.rs:601:48
[INFO] [stdout]     |
[INFO] [stdout] 601 |         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] 601 |         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`
[INFO] [stdout]    --> src/scalar.rs:656:51
[INFO] [stdout]     |
[INFO] [stdout] 656 |                 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] 656 |                 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`
[INFO] [stdout]    --> src/scalar.rs:656:59
[INFO] [stdout]     |
[INFO] [stdout] 656 |                 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] 656 |                 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`
[INFO] [stdout]    --> src/scalar.rs:661:47
[INFO] [stdout]     |
[INFO] [stdout] 661 |             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] 661 |             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`
[INFO] [stdout]    --> src/scalar.rs:661:55
[INFO] [stdout]     |
[INFO] [stdout] 661 |             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] 661 |             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`
[INFO] [stdout]    --> src/scalar.rs:672:48
[INFO] [stdout]     |
[INFO] [stdout] 672 |             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] 672 |             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`
[INFO] [stdout]    --> src/scalar.rs:672:56
[INFO] [stdout]     |
[INFO] [stdout] 672 |             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] 672 |             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`
[INFO] [stdout]    --> src/scalar.rs:700:47
[INFO] [stdout]     |
[INFO] [stdout] 700 |             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] 700 |             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`
[INFO] [stdout]    --> src/scalar.rs:700:55
[INFO] [stdout]     |
[INFO] [stdout] 700 |             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] 700 |             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`
[INFO] [stdout]    --> src/scalar.rs:700:63
[INFO] [stdout]     |
[INFO] [stdout] 700 |             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] 700 |             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`
[INFO] [stdout]    --> src/scalar.rs:708:47
[INFO] [stdout]     |
[INFO] [stdout] 708 |             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] 708 |             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`
[INFO] [stdout]    --> src/scalar.rs:814:65
[INFO] [stdout]     |
[INFO] [stdout] 814 |                     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] 814 |                     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`
[INFO] [stdout]    --> src/scalar.rs:817:60
[INFO] [stdout]     |
[INFO] [stdout] 817 |                     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] 817 |                     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`
[INFO] [stdout]    --> src/scalar.rs:817:69
[INFO] [stdout]     |
[INFO] [stdout] 817 |                     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] 817 |                     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`
[INFO] [stdout]    --> src/scalar.rs:820:65
[INFO] [stdout]     |
[INFO] [stdout] 820 |                     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] 820 |                     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`
[INFO] [stdout]    --> src/scalar.rs:865:56
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 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] 865 |                 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`
[INFO] [stdout]    --> src/scalar.rs:865:64
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 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] 865 |                 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`
[INFO] [stdout]    --> src/scalar.rs:887:72
[INFO] [stdout]     |
[INFO] [stdout] 887 |                 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] 887 |                 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`
[INFO] [stdout]    --> src/scalar.rs:887:80
[INFO] [stdout]     |
[INFO] [stdout] 887 |                 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] 887 |                 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`
[INFO] [stdout]    --> src/scalar.rs:887:88
[INFO] [stdout]     |
[INFO] [stdout] 887 |                 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] 887 |                 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`
[INFO] [stdout]    --> src/scalar.rs:888:72
[INFO] [stdout]     |
[INFO] [stdout] 888 |                 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] 888 |                 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`
[INFO] [stdout]    --> src/scalar.rs:888:80
[INFO] [stdout]     |
[INFO] [stdout] 888 |                 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] 888 |                 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`
[INFO] [stdout]    --> src/scalar.rs:888:88
[INFO] [stdout]     |
[INFO] [stdout] 888 |                 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] 888 |                 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`
[INFO] [stdout]    --> src/scalar.rs:889:72
[INFO] [stdout]     |
[INFO] [stdout] 889 |                 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] 889 |                 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`
[INFO] [stdout]    --> src/scalar.rs:889:80
[INFO] [stdout]     |
[INFO] [stdout] 889 |                 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] 889 |                 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`
[INFO] [stdout]    --> src/scalar.rs:889:88
[INFO] [stdout]     |
[INFO] [stdout] 889 |                 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] 889 |                 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`
[INFO] [stdout]    --> src/scalar.rs:890:72
[INFO] [stdout]     |
[INFO] [stdout] 890 |                 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] 890 |                 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`
[INFO] [stdout]    --> src/scalar.rs:890:80
[INFO] [stdout]     |
[INFO] [stdout] 890 |                 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] 890 |                 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`
[INFO] [stdout]    --> src/scalar.rs:890:88
[INFO] [stdout]     |
[INFO] [stdout] 890 |                 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] 890 |                 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`
[INFO] [stdout]    --> src/scalar.rs:891:71
[INFO] [stdout]     |
[INFO] [stdout] 891 |                 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] 891 |                 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`
[INFO] [stdout]    --> src/scalar.rs:891:79
[INFO] [stdout]     |
[INFO] [stdout] 891 |                 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] 891 |                 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`
[INFO] [stdout]    --> src/scalar.rs:891:87
[INFO] [stdout]     |
[INFO] [stdout] 891 |                 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] 891 |                 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`
[INFO] [stdout]    --> src/scalar.rs:892:72
[INFO] [stdout]     |
[INFO] [stdout] 892 |                 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] 892 |                 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`
[INFO] [stdout]    --> src/scalar.rs:892:80
[INFO] [stdout]     |
[INFO] [stdout] 892 |                 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] 892 |                 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`
[INFO] [stdout]    --> src/scalar.rs:892:88
[INFO] [stdout]     |
[INFO] [stdout] 892 |                 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] 892 |                 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`
[INFO] [stdout]    --> src/scalar.rs:893:73
[INFO] [stdout]     |
[INFO] [stdout] 893 |                 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] 893 |                 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`
[INFO] [stdout]    --> src/scalar.rs:893:81
[INFO] [stdout]     |
[INFO] [stdout] 893 |                 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] 893 |                 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`
[INFO] [stdout]    --> src/scalar.rs:893:89
[INFO] [stdout]     |
[INFO] [stdout] 893 |                 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] 893 |                 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`
[INFO] [stdout]    --> src/scalar.rs:894:73
[INFO] [stdout]     |
[INFO] [stdout] 894 |                 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] 894 |                 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`
[INFO] [stdout]    --> src/scalar.rs:894:81
[INFO] [stdout]     |
[INFO] [stdout] 894 |                 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] 894 |                 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`
[INFO] [stdout]    --> src/scalar.rs:894:89
[INFO] [stdout]     |
[INFO] [stdout] 894 |                 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] 894 |                 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`
[INFO] [stdout]    --> src/scalar.rs:895:73
[INFO] [stdout]     |
[INFO] [stdout] 895 |                 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] 895 |                 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`
[INFO] [stdout]    --> src/scalar.rs:895:81
[INFO] [stdout]     |
[INFO] [stdout] 895 |                 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] 895 |                 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`
[INFO] [stdout]    --> src/scalar.rs:895:89
[INFO] [stdout]     |
[INFO] [stdout] 895 |                 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] 895 |                 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`
[INFO] [stdout]    --> src/scalar.rs:911:74
[INFO] [stdout]     |
[INFO] [stdout] 911 |                 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] 911 |                 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`
[INFO] [stdout]    --> src/scalar.rs:911:82
[INFO] [stdout]     |
[INFO] [stdout] 911 |                 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] 911 |                 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`
[INFO] [stdout]    --> src/scalar.rs:911:90
[INFO] [stdout]     |
[INFO] [stdout] 911 |                 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] 911 |                 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`
[INFO] [stdout]    --> src/scalar.rs:912:74
[INFO] [stdout]     |
[INFO] [stdout] 912 |                 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] 912 |                 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`
[INFO] [stdout]    --> src/scalar.rs:912:82
[INFO] [stdout]     |
[INFO] [stdout] 912 |                 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] 912 |                 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`
[INFO] [stdout]    --> src/scalar.rs:912:90
[INFO] [stdout]     |
[INFO] [stdout] 912 |                 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] 912 |                 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`
[INFO] [stdout]    --> src/scalar.rs:913:74
[INFO] [stdout]     |
[INFO] [stdout] 913 |                 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] 913 |                 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`
[INFO] [stdout]    --> src/scalar.rs:913:82
[INFO] [stdout]     |
[INFO] [stdout] 913 |                 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] 913 |                 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`
[INFO] [stdout]    --> src/scalar.rs:913:90
[INFO] [stdout]     |
[INFO] [stdout] 913 |                 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] 913 |                 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`
[INFO] [stdout]    --> src/scalar.rs:914:74
[INFO] [stdout]     |
[INFO] [stdout] 914 |                 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] 914 |                 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`
[INFO] [stdout]    --> src/scalar.rs:914:82
[INFO] [stdout]     |
[INFO] [stdout] 914 |                 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] 914 |                 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`
[INFO] [stdout]    --> src/scalar.rs:914:90
[INFO] [stdout]     |
[INFO] [stdout] 914 |                 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] 914 |                 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`
[INFO] [stdout]    --> src/scalar.rs:915:73
[INFO] [stdout]     |
[INFO] [stdout] 915 |                 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] 915 |                 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`
[INFO] [stdout]    --> src/scalar.rs:915:81
[INFO] [stdout]     |
[INFO] [stdout] 915 |                 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] 915 |                 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`
[INFO] [stdout]    --> src/scalar.rs:915:89
[INFO] [stdout]     |
[INFO] [stdout] 915 |                 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] 915 |                 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`
[INFO] [stdout]    --> src/scalar.rs:916:74
[INFO] [stdout]     |
[INFO] [stdout] 916 |                 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] 916 |                 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`
[INFO] [stdout]    --> src/scalar.rs:916:82
[INFO] [stdout]     |
[INFO] [stdout] 916 |                 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] 916 |                 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`
[INFO] [stdout]    --> src/scalar.rs:916:90
[INFO] [stdout]     |
[INFO] [stdout] 916 |                 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] 916 |                 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`
[INFO] [stdout]    --> src/scalar.rs:926:49
[INFO] [stdout]     |
[INFO] [stdout] 926 |             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] 926 |             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`
[INFO] [stdout]    --> src/scalar.rs:926:57
[INFO] [stdout]     |
[INFO] [stdout] 926 |             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] 926 |             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`
[INFO] [stdout]    --> src/scalar.rs:926:65
[INFO] [stdout]     |
[INFO] [stdout] 926 |             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] 926 |             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`
[INFO] [stdout]    --> src/scalar.rs:934:55
[INFO] [stdout]     |
[INFO] [stdout] 934 |                     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] 934 |                     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`
[INFO] [stdout]    --> src/scalar.rs:934:63
[INFO] [stdout]     |
[INFO] [stdout] 934 |                     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] 934 |                     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`
[INFO] [stdout]    --> src/scalar.rs:936:55
[INFO] [stdout]     |
[INFO] [stdout] 936 |                     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] 936 |                     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`
[INFO] [stdout]    --> src/scalar.rs:936:63
[INFO] [stdout]     |
[INFO] [stdout] 936 |                     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] 936 |                     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`
[INFO] [stdout]    --> src/scalar.rs:944:51
[INFO] [stdout]     |
[INFO] [stdout] 944 |                 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] 944 |                 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`
[INFO] [stdout]    --> src/scalar.rs:944:59
[INFO] [stdout]     |
[INFO] [stdout] 944 |                 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] 944 |                 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`
[INFO] [stdout]    --> src/scalar.rs:956:75
[INFO] [stdout]     |
[INFO] [stdout] 956 |                 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] 956 |                 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`
[INFO] [stdout]    --> src/scalar.rs:956:83
[INFO] [stdout]     |
[INFO] [stdout] 956 |                 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] 956 |                 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`
[INFO] [stdout]    --> src/scalar.rs:957:75
[INFO] [stdout]     |
[INFO] [stdout] 957 |                 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] 957 |                 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`
[INFO] [stdout]    --> src/scalar.rs:957:83
[INFO] [stdout]     |
[INFO] [stdout] 957 |                 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] 957 |                 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`
[INFO] [stdout]    --> src/scalar.rs:958:75
[INFO] [stdout]     |
[INFO] [stdout] 958 |                 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] 958 |                 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`
[INFO] [stdout]    --> src/scalar.rs:958:83
[INFO] [stdout]     |
[INFO] [stdout] 958 |                 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] 958 |                 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`
[INFO] [stdout]    --> src/scalar.rs:972:55
[INFO] [stdout]     |
[INFO] [stdout] 972 |                     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] 972 |                     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`
[INFO] [stdout]    --> src/scalar.rs:972:63
[INFO] [stdout]     |
[INFO] [stdout] 972 |                     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] 972 |                     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`
[INFO] [stdout]    --> src/scalar.rs:974:55
[INFO] [stdout]     |
[INFO] [stdout] 974 |                     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] 974 |                     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`
[INFO] [stdout]    --> src/scalar.rs:974:63
[INFO] [stdout]     |
[INFO] [stdout] 974 |                     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] 974 |                     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`
[INFO] [stdout]    --> src/scalar.rs:989:47
[INFO] [stdout]     |
[INFO] [stdout] 989 |             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] 989 |             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`
[INFO] [stdout]    --> src/scalar.rs:989:55
[INFO] [stdout]     |
[INFO] [stdout] 989 |             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] 989 |             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`
[INFO] [stdout]     --> src/scalar.rs:1001:51
[INFO] [stdout]      |
[INFO] [stdout] 1001 |                 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] 1001 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1015:57
[INFO] [stdout]      |
[INFO] [stdout] 1015 |                 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] 1015 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1015:65
[INFO] [stdout]      |
[INFO] [stdout] 1015 |                 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] 1015 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1017:57
[INFO] [stdout]      |
[INFO] [stdout] 1017 |                 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] 1017 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1017:65
[INFO] [stdout]      |
[INFO] [stdout] 1017 |                 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] 1017 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1020:52
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 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] 1020 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1020:65
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 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] 1020 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1020:73
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 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] 1020 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1022:51
[INFO] [stdout]      |
[INFO] [stdout] 1022 |                 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] 1022 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1028:51
[INFO] [stdout]      |
[INFO] [stdout] 1028 |                 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] 1028 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1028:59
[INFO] [stdout]      |
[INFO] [stdout] 1028 |                 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] 1028 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1030:51
[INFO] [stdout]      |
[INFO] [stdout] 1030 |                 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] 1030 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1030:59
[INFO] [stdout]      |
[INFO] [stdout] 1030 |                 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] 1030 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1037:28
[INFO] [stdout]      |
[INFO] [stdout] 1037 |                 ; 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] 1037 |                 ; fmov d0, X(<u8 as Into<_>>::into(src))
[INFO] [stdout]      |                              ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1040:24
[INFO] [stdout]      |
[INFO] [stdout] 1040 |                 ; 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] 1040 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1045:53
[INFO] [stdout]      |
[INFO] [stdout] 1045 |             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] 1045 |             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`
[INFO] [stdout]     --> src/scalar.rs:1045:66
[INFO] [stdout]      |
[INFO] [stdout] 1045 |             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] 1045 |             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`
[INFO] [stdout]     --> src/scalar.rs:1049:52
[INFO] [stdout]      |
[INFO] [stdout] 1049 |             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] 1049 |             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`
[INFO] [stdout]     --> src/scalar.rs:1052:47
[INFO] [stdout]      |
[INFO] [stdout] 1052 |             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] 1052 |             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`
[INFO] [stdout]     --> src/scalar.rs:1068:23
[INFO] [stdout]      |
[INFO] [stdout] 1068 |                 ; 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] 1068 |                 ; cmp XSP(<u8 as Into<_>>::into(cond)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1069:24
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                 ; 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] 1069 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1069:32
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                 ; 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] 1069 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1069:45
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                 ; 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] 1069 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1087:47
[INFO] [stdout]      |
[INFO] [stdout] 1087 |             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] 1087 |             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`
[INFO] [stdout]     --> src/scalar.rs:1087:55
[INFO] [stdout]      |
[INFO] [stdout] 1087 |             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] 1087 |             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`
[INFO] [stdout]     --> src/scalar.rs:1106:51
[INFO] [stdout]      |
[INFO] [stdout] 1106 |                 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] 1106 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1121:51
[INFO] [stdout]      |
[INFO] [stdout] 1121 |                 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] 1121 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1157:56
[INFO] [stdout]      |
[INFO] [stdout] 1157 |                     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] 1157 |                     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`
[INFO] [stdout]     --> src/scalar.rs:1159:55
[INFO] [stdout]      |
[INFO] [stdout] 1159 |                     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] 1159 |                     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`
[INFO] [stdout]     --> src/scalar.rs:1180:51
[INFO] [stdout]      |
[INFO] [stdout] 1180 |                 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] 1180 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1182:52
[INFO] [stdout]      |
[INFO] [stdout] 1182 |                 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] 1182 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1448:47
[INFO] [stdout]      |
[INFO] [stdout] 1448 |             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] 1448 |             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`
[INFO] [stdout]     --> src/scalar.rs:1448:55
[INFO] [stdout]      |
[INFO] [stdout] 1448 |             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] 1448 |             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`
[INFO] [stdout]     --> src/scalar.rs:1452:23
[INFO] [stdout]      |
[INFO] [stdout] 1452 |                 ; 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] 1452 |                 ; cmp XSP(<u8 as Into<_>>::into(guard)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1455:24
[INFO] [stdout]      |
[INFO] [stdout] 1455 |                 ; 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] 1455 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1455:32
[INFO] [stdout]      |
[INFO] [stdout] 1455 |                 ; 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] 1455 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1455:45
[INFO] [stdout]      |
[INFO] [stdout] 1455 |                 ; 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] 1455 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1472:52
[INFO] [stdout]      |
[INFO] [stdout] 1472 |             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] 1472 |             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`
[INFO] [stdout]     --> src/scalar.rs:1475:43
[INFO] [stdout]      |
[INFO] [stdout] 1475 |         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] 1475 |         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`
[INFO] [stdout]     --> src/scalar.rs:1475:51
[INFO] [stdout]      |
[INFO] [stdout] 1475 |         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] 1475 |         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`
[INFO] [stdout]     --> src/scalar.rs:1478:39
[INFO] [stdout]      |
[INFO] [stdout] 1478 |     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] 1478 |     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`
[INFO] [stdout]     --> src/scalar.rs:1478:47
[INFO] [stdout]      |
[INFO] [stdout] 1478 |     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] 1478 |     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`
[INFO] [stdout]   --> src/scalar/extern_call.rs:77:43
[INFO] [stdout]    |
[INFO] [stdout] 77 |         dynasm!(ops ; .arch aarch64 ; str D(register), [sp, offset]);
[INFO] [stdout]    |                                           ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 77 |         dynasm!(ops ; .arch aarch64 ; str D(<u8 as Into<_>>::into(register)), [sp, offset]);
[INFO] [stdout]    |                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar/extern_call.rs:122:43
[INFO] [stdout]     |
[INFO] [stdout] 122 |         dynasm!(ops ; .arch aarch64 ; mov X(register), x0);
[INFO] [stdout]     |                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 122 |         dynasm!(ops ; .arch aarch64 ; mov X(<u8 as Into<_>>::into(register)), x0);
[INFO] [stdout]     |                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar/extern_call.rs:126:43
[INFO] [stdout]     |
[INFO] [stdout] 126 |         dynasm!(ops ; .arch aarch64 ; ldr D(register), [sp, offset]);
[INFO] [stdout]     |                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 126 |         dynasm!(ops ; .arch aarch64 ; ldr D(<u8 as Into<_>>::into(register)), [sp, offset]);
[INFO] [stdout]     |                                             ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar.rs:447:48
[INFO] [stdout]     |
[INFO] [stdout] 447 |         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] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 447 |         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`
[INFO] [stdout]    --> src/scalar.rs:452:23
[INFO] [stdout]     |
[INFO] [stdout] 452 |                 ; 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] 452 |                 ; 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`
[INFO] [stdout]    --> src/scalar.rs:452:47
[INFO] [stdout]     |
[INFO] [stdout] 452 |                 ; 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] 452 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1694:56
[INFO] [stdout]      |
[INFO] [stdout] 1694 |                 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] 1694 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1762:39
[INFO] [stdout]      |
[INFO] [stdout] 1762 |     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] 1762 |     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`
[INFO] [stdout]    --> src/scalar.rs:457:47
[INFO] [stdout]     |
[INFO] [stdout] 457 |             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] 457 |             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`
[INFO] [stdout]     --> src/scalar.rs:1796:60
[INFO] [stdout]      |
[INFO] [stdout] 1796 |             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] 1796 |             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`
[INFO] [stdout]     --> src/scalar.rs:1797:59
[INFO] [stdout]      |
[INFO] [stdout] 1797 |             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] 1797 |             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`
[INFO] [stdout]    --> src/scalar.rs:592:47
[INFO] [stdout]     |
[INFO] [stdout] 592 |             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] 592 |             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`
[INFO] [stdout]     --> src/scalar.rs:1798:59
[INFO] [stdout]      |
[INFO] [stdout] 1798 |             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] 1798 |             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`
[INFO] [stdout]    --> src/scalar.rs:598:23
[INFO] [stdout]     |
[INFO] [stdout] 598 |                 ; 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] 598 |                 ; 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`
[INFO] [stdout]    --> src/scalar.rs:598:47
[INFO] [stdout]     |
[INFO] [stdout] 598 |                 ; 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] 598 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1826:64
[INFO] [stdout]      |
[INFO] [stdout] 1826 |                 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] 1826 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1827:63
[INFO] [stdout]      |
[INFO] [stdout] 1827 |                 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] 1827 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1828:63
[INFO] [stdout]      |
[INFO] [stdout] 1828 |                 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] 1828 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1878:39
[INFO] [stdout]      |
[INFO] [stdout] 1878 |     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] 1878 |     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`
[INFO] [stdout]     --> src/scalar.rs:2015:24
[INFO] [stdout]      |
[INFO] [stdout] 2015 |                 ; 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] 2015 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2018:24
[INFO] [stdout]      |
[INFO] [stdout] 2018 |                 ; 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] 2018 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2034:24
[INFO] [stdout]      |
[INFO] [stdout] 2034 |                 ; 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] 2034 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2048:24
[INFO] [stdout]      |
[INFO] [stdout] 2048 |                 ; 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] 2048 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2073:23
[INFO] [stdout]      |
[INFO] [stdout] 2073 |         ; 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] 2073 |         ; 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`
[INFO] [stdout]     --> src/scalar.rs:2074:23
[INFO] [stdout]      |
[INFO] [stdout] 2074 |         ; 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] 2074 |         ; 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`
[INFO] [stdout]    --> src/scalar.rs:601:48
[INFO] [stdout]     |
[INFO] [stdout] 601 |         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] 601 |         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`
[INFO] [stdout]    --> src/scalar.rs:656:51
[INFO] [stdout]     |
[INFO] [stdout] 656 |                 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] 656 |                 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`
[INFO] [stdout]    --> src/scalar.rs:656:59
[INFO] [stdout]     |
[INFO] [stdout] 656 |                 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] 656 |                 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`
[INFO] [stdout]    --> src/scalar.rs:661:47
[INFO] [stdout]     |
[INFO] [stdout] 661 |             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] 661 |             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`
[INFO] [stdout]    --> src/scalar.rs:661:55
[INFO] [stdout]     |
[INFO] [stdout] 661 |             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] 661 |             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`
[INFO] [stdout]    --> src/scalar.rs:672:48
[INFO] [stdout]     |
[INFO] [stdout] 672 |             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] 672 |             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`
[INFO] [stdout]    --> src/scalar.rs:672:56
[INFO] [stdout]     |
[INFO] [stdout] 672 |             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] 672 |             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`
[INFO] [stdout]    --> src/scalar.rs:700:47
[INFO] [stdout]     |
[INFO] [stdout] 700 |             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] 700 |             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`
[INFO] [stdout]    --> src/scalar.rs:700:55
[INFO] [stdout]     |
[INFO] [stdout] 700 |             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] 700 |             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`
[INFO] [stdout]    --> src/scalar.rs:700:63
[INFO] [stdout]     |
[INFO] [stdout] 700 |             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] 700 |             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`
[INFO] [stdout]     --> src/scalar.rs:2130:16
[INFO] [stdout]      |
[INFO] [stdout] 2130 |         ; 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] 2130 |         ; 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`
[INFO] [stdout]    --> src/scalar.rs:708:47
[INFO] [stdout]     |
[INFO] [stdout] 708 |             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] 708 |             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`
[INFO] [stdout]    --> src/scalar.rs:814:65
[INFO] [stdout]     |
[INFO] [stdout] 814 |                     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] 814 |                     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`
[INFO] [stdout]     --> src/scalar.rs:2133:16
[INFO] [stdout]      |
[INFO] [stdout] 2133 |         ; 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] 2133 |         ; 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`
[INFO] [stdout]     --> src/scalar.rs:2136:15
[INFO] [stdout]      |
[INFO] [stdout] 2136 |         ; 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] 2136 |         ; mov X(<u8 as Into<_>>::into(destination)), x30
[INFO] [stdout]      |                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/scalar.rs:817:60
[INFO] [stdout]     |
[INFO] [stdout] 817 |                     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] 817 |                     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`
[INFO] [stdout]     --> src/scalar.rs:2504:43
[INFO] [stdout]      |
[INFO] [stdout] 2504 |         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] 2504 |         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`
[INFO] [stdout]     --> src/scalar.rs:2504:59
[INFO] [stdout]      |
[INFO] [stdout] 2504 |         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] 2504 |         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`
[INFO] [stdout]    --> src/scalar.rs:817:69
[INFO] [stdout]     |
[INFO] [stdout] 817 |                     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] 817 |                     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`
[INFO] [stdout]     --> src/scalar.rs:2513:47
[INFO] [stdout]      |
[INFO] [stdout] 2513 |             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] 2513 |             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`
[INFO] [stdout]     --> src/scalar.rs:2513:63
[INFO] [stdout]      |
[INFO] [stdout] 2513 |             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] 2513 |             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`
[INFO] [stdout]    --> src/scalar.rs:820:65
[INFO] [stdout]     |
[INFO] [stdout] 820 |                     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] 820 |                     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`
[INFO] [stdout]     --> src/scalar.rs:2513:72
[INFO] [stdout]      |
[INFO] [stdout] 2513 |             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] 2513 |             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`
[INFO] [stdout]     --> src/scalar.rs:2516:39
[INFO] [stdout]      |
[INFO] [stdout] 2516 |     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] 2516 |     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`
[INFO] [stdout]    --> src/scalar.rs:865:56
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 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] 865 |                 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`
[INFO] [stdout]    --> src/scalar.rs:865:64
[INFO] [stdout]     |
[INFO] [stdout] 865 |                 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] 865 |                 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`
[INFO] [stdout]    --> src/scalar.rs:887:72
[INFO] [stdout]     |
[INFO] [stdout] 887 |                 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] 887 |                 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`
[INFO] [stdout]    --> src/scalar.rs:887:80
[INFO] [stdout]     |
[INFO] [stdout] 887 |                 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] 887 |                 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`
[INFO] [stdout]     --> src/scalar.rs:2516:55
[INFO] [stdout]      |
[INFO] [stdout] 2516 |     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] 2516 |     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`
[INFO] [stdout]    --> src/scalar.rs:887:88
[INFO] [stdout]     |
[INFO] [stdout] 887 |                 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] 887 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3018:43
[INFO] [stdout]      |
[INFO] [stdout] 3018 |         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] 3018 |         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`
[INFO] [stdout]     --> src/scalar.rs:3018:59
[INFO] [stdout]      |
[INFO] [stdout] 3018 |         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] 3018 |         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`
[INFO] [stdout]    --> src/scalar.rs:888:72
[INFO] [stdout]     |
[INFO] [stdout] 888 |                 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] 888 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3025:47
[INFO] [stdout]      |
[INFO] [stdout] 3025 |             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] 3025 |             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`
[INFO] [stdout]     --> src/scalar.rs:3025:63
[INFO] [stdout]      |
[INFO] [stdout] 3025 |             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] 3025 |             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`
[INFO] [stdout]     --> src/scalar.rs:3120:52
[INFO] [stdout]      |
[INFO] [stdout] 3120 |                 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] 3120 |                 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`
[INFO] [stdout]    --> src/scalar.rs:888:80
[INFO] [stdout]     |
[INFO] [stdout] 888 |                 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] 888 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3120:68
[INFO] [stdout]      |
[INFO] [stdout] 3120 |                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3120:68
[INFO] [stdout]      |
[INFO] [stdout] 3120 |                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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`
[INFO] [stdout]    --> src/scalar.rs:888:88
[INFO] [stdout]     |
[INFO] [stdout] 888 |                 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] 888 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3123:52
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 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] 3123 |                 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`
[INFO] [stdout]    --> src/scalar.rs:889:72
[INFO] [stdout]     |
[INFO] [stdout] 889 |                 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] 889 |                 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`
[INFO] [stdout]    --> src/scalar.rs:889:80
[INFO] [stdout]     |
[INFO] [stdout] 889 |                 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] 889 |                 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`
[INFO] [stdout]    --> src/scalar.rs:889:88
[INFO] [stdout]     |
[INFO] [stdout] 889 |                 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] 889 |                 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`
[INFO] [stdout]    --> src/scalar.rs:890:72
[INFO] [stdout]     |
[INFO] [stdout] 890 |                 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] 890 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3123:68
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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`
[INFO] [stdout]    --> src/scalar.rs:890:80
[INFO] [stdout]     |
[INFO] [stdout] 890 |                 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] 890 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3123:68
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3126:51
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 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] 3126 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3126:67
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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`
[INFO] [stdout]    --> src/scalar.rs:890:88
[INFO] [stdout]     |
[INFO] [stdout] 890 |                 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] 890 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3126:67
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3129:51
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 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] 3129 |                 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`
[INFO] [stdout]    --> src/scalar.rs:891:71
[INFO] [stdout]     |
[INFO] [stdout] 891 |                 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] 891 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3129:67
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3129:67
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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`
[INFO] [stdout]    --> src/scalar.rs:891:79
[INFO] [stdout]     |
[INFO] [stdout] 891 |                 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] 891 |                 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`
[INFO] [stdout]    --> src/scalar.rs:891:87
[INFO] [stdout]     |
[INFO] [stdout] 891 |                 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] 891 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3134:48
[INFO] [stdout]      |
[INFO] [stdout] 3134 |         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] 3134 |         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`
[INFO] [stdout]     --> src/scalar.rs:3134:57
[INFO] [stdout]      |
[INFO] [stdout] 3134 |         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] 3134 |         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`
[INFO] [stdout]     --> src/scalar.rs:3171:52
[INFO] [stdout]      |
[INFO] [stdout] 3171 |                 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] 3171 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3171:63
[INFO] [stdout]      |
[INFO] [stdout] 3171 |                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3171:63
[INFO] [stdout]      |
[INFO] [stdout] 3171 |                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3174:52
[INFO] [stdout]      |
[INFO] [stdout] 3174 |                 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] 3174 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3174:63
[INFO] [stdout]      |
[INFO] [stdout] 3174 |                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3174:63
[INFO] [stdout]      |
[INFO] [stdout] 3174 |                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3177:51
[INFO] [stdout]      |
[INFO] [stdout] 3177 |                 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] 3177 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3177:62
[INFO] [stdout]      |
[INFO] [stdout] 3177 |                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3177:62
[INFO] [stdout]      |
[INFO] [stdout] 3177 |                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3180:51
[INFO] [stdout]      |
[INFO] [stdout] 3180 |                 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] 3180 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3180:62
[INFO] [stdout]      |
[INFO] [stdout] 3180 |                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3180:62
[INFO] [stdout]      |
[INFO] [stdout] 3180 |                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3185:48
[INFO] [stdout]      |
[INFO] [stdout] 3185 |         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] 3185 |         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`
[INFO] [stdout]     --> src/scalar.rs:3185:57
[INFO] [stdout]      |
[INFO] [stdout] 3185 |         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] 3185 |         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`
[INFO] [stdout]     --> src/scalar.rs:3467:58
[INFO] [stdout]      |
[INFO] [stdout] 3467 |         (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] 3467 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3468:58
[INFO] [stdout]      |
[INFO] [stdout] 3468 |         (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] 3468 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3469:58
[INFO] [stdout]      |
[INFO] [stdout] 3469 |         (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] 3469 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3470:58
[INFO] [stdout]      |
[INFO] [stdout] 3470 |         (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] 3470 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3471:57
[INFO] [stdout]      |
[INFO] [stdout] 3471 |         (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] 3471 |         (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`
[INFO] [stdout]    --> src/scalar.rs:892:72
[INFO] [stdout]     |
[INFO] [stdout] 892 |                 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] 892 |                 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`
[INFO] [stdout]    --> src/scalar.rs:892:80
[INFO] [stdout]     |
[INFO] [stdout] 892 |                 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] 892 |                 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`
[INFO] [stdout]    --> src/scalar.rs:892:88
[INFO] [stdout]     |
[INFO] [stdout] 892 |                 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] 892 |                 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`
[INFO] [stdout]    --> src/scalar.rs:893:73
[INFO] [stdout]     |
[INFO] [stdout] 893 |                 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] 893 |                 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`
[INFO] [stdout]    --> src/scalar.rs:893:81
[INFO] [stdout]     |
[INFO] [stdout] 893 |                 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] 893 |                 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`
[INFO] [stdout]    --> src/scalar.rs:893:89
[INFO] [stdout]     |
[INFO] [stdout] 893 |                 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] 893 |                 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`
[INFO] [stdout]    --> src/scalar.rs:894:73
[INFO] [stdout]     |
[INFO] [stdout] 894 |                 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] 894 |                 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`
[INFO] [stdout]    --> src/scalar.rs:894:81
[INFO] [stdout]     |
[INFO] [stdout] 894 |                 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] 894 |                 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`
[INFO] [stdout]    --> src/scalar.rs:894:89
[INFO] [stdout]     |
[INFO] [stdout] 894 |                 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] 894 |                 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`
[INFO] [stdout]    --> src/scalar.rs:895:73
[INFO] [stdout]     |
[INFO] [stdout] 895 |                 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] 895 |                 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`
[INFO] [stdout]    --> src/scalar.rs:895:81
[INFO] [stdout]     |
[INFO] [stdout] 895 |                 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] 895 |                 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`
[INFO] [stdout]    --> src/scalar.rs:895:89
[INFO] [stdout]     |
[INFO] [stdout] 895 |                 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] 895 |                 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`
[INFO] [stdout]    --> src/scalar.rs:911:74
[INFO] [stdout]     |
[INFO] [stdout] 911 |                 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] 911 |                 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`
[INFO] [stdout]    --> src/scalar.rs:911:82
[INFO] [stdout]     |
[INFO] [stdout] 911 |                 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] 911 |                 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`
[INFO] [stdout]    --> src/scalar.rs:911:90
[INFO] [stdout]     |
[INFO] [stdout] 911 |                 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] 911 |                 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`
[INFO] [stdout]    --> src/scalar.rs:912:74
[INFO] [stdout]     |
[INFO] [stdout] 912 |                 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] 912 |                 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`
[INFO] [stdout]    --> src/scalar.rs:912:82
[INFO] [stdout]     |
[INFO] [stdout] 912 |                 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] 912 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3472:57
[INFO] [stdout]      |
[INFO] [stdout] 3472 |         (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] 3472 |         (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`
[INFO] [stdout]    --> src/scalar.rs:912:90
[INFO] [stdout]     |
[INFO] [stdout] 912 |                 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] 912 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3473:57
[INFO] [stdout]      |
[INFO] [stdout] 3473 |         (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] 3473 |         (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`
[INFO] [stdout]    --> src/scalar.rs:913:74
[INFO] [stdout]     |
[INFO] [stdout] 913 |                 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] 913 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3474:57
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         (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] 3474 |         (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`
[INFO] [stdout]    --> src/scalar.rs:913:82
[INFO] [stdout]     |
[INFO] [stdout] 913 |                 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] 913 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3483:53
[INFO] [stdout]      |
[INFO] [stdout] 3483 |             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] 3483 |             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`
[INFO] [stdout]     --> src/scalar.rs:3484:53
[INFO] [stdout]      |
[INFO] [stdout] 3484 |             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] 3484 |             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`
[INFO] [stdout]    --> src/scalar.rs:913:90
[INFO] [stdout]     |
[INFO] [stdout] 913 |                 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] 913 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3485:53
[INFO] [stdout]      |
[INFO] [stdout] 3485 |             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] 3485 |             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`
[INFO] [stdout]    --> src/scalar.rs:914:74
[INFO] [stdout]     |
[INFO] [stdout] 914 |                 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] 914 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3486:53
[INFO] [stdout]      |
[INFO] [stdout] 3486 |             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] 3486 |             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`
[INFO] [stdout]     --> src/scalar.rs:3499:58
[INFO] [stdout]      |
[INFO] [stdout] 3499 |         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] 3499 |         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`
[INFO] [stdout]    --> src/scalar.rs:914:82
[INFO] [stdout]     |
[INFO] [stdout] 914 |                 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] 914 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3499:74
[INFO] [stdout]      |
[INFO] [stdout] 3499 |         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] 3499 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3499 +         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] 3499 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3499 +         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`
[INFO] [stdout]    --> src/scalar.rs:914:90
[INFO] [stdout]     |
[INFO] [stdout] 914 |                 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] 914 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3500:59
[INFO] [stdout]      |
[INFO] [stdout] 3500 |         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] 3500 |         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`
[INFO] [stdout]    --> src/scalar.rs:915:73
[INFO] [stdout]     |
[INFO] [stdout] 915 |                 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] 915 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3500:75
[INFO] [stdout]      |
[INFO] [stdout] 3500 |         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] 3500 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3500 +         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] 3500 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3500 +         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`
[INFO] [stdout]    --> src/scalar.rs:915:81
[INFO] [stdout]     |
[INFO] [stdout] 915 |                 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] 915 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3501:58
[INFO] [stdout]      |
[INFO] [stdout] 3501 |         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] 3501 |         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`
[INFO] [stdout]     --> src/scalar.rs:3501:74
[INFO] [stdout]      |
[INFO] [stdout] 3501 |         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] 3501 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3501 +         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] 3501 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3501 +         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`
[INFO] [stdout]     --> src/scalar.rs:3502:58
[INFO] [stdout]      |
[INFO] [stdout] 3502 |         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] 3502 |         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`
[INFO] [stdout]     --> src/scalar.rs:3502:74
[INFO] [stdout]      |
[INFO] [stdout] 3502 |         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] 3502 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3502 +         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] 3502 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3502 +         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`
[INFO] [stdout]     --> src/scalar.rs:3508:58
[INFO] [stdout]      |
[INFO] [stdout] 3508 |         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] 3508 |         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`
[INFO] [stdout]    --> src/scalar.rs:915:89
[INFO] [stdout]     |
[INFO] [stdout] 915 |                 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] 915 |                 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`
[INFO] [stdout]    --> src/scalar.rs:916:74
[INFO] [stdout]     |
[INFO] [stdout] 916 |                 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] 916 |                 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`
[INFO] [stdout]    --> src/scalar.rs:916:82
[INFO] [stdout]     |
[INFO] [stdout] 916 |                 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] 916 |                 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`
[INFO] [stdout]    --> src/scalar.rs:916:90
[INFO] [stdout]     |
[INFO] [stdout] 916 |                 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] 916 |                 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`
[INFO] [stdout]    --> src/scalar.rs:926:49
[INFO] [stdout]     |
[INFO] [stdout] 926 |             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] 926 |             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`
[INFO] [stdout]    --> src/scalar.rs:926:57
[INFO] [stdout]     |
[INFO] [stdout] 926 |             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] 926 |             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`
[INFO] [stdout]    --> src/scalar.rs:926:65
[INFO] [stdout]     |
[INFO] [stdout] 926 |             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] 926 |             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`
[INFO] [stdout]    --> src/scalar.rs:934:55
[INFO] [stdout]     |
[INFO] [stdout] 934 |                     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] 934 |                     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`
[INFO] [stdout]    --> src/scalar.rs:934:63
[INFO] [stdout]     |
[INFO] [stdout] 934 |                     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] 934 |                     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`
[INFO] [stdout]    --> src/scalar.rs:936:55
[INFO] [stdout]     |
[INFO] [stdout] 936 |                     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] 936 |                     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`
[INFO] [stdout]    --> src/scalar.rs:936:63
[INFO] [stdout]     |
[INFO] [stdout] 936 |                     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] 936 |                     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`
[INFO] [stdout]    --> src/scalar.rs:944:51
[INFO] [stdout]     |
[INFO] [stdout] 944 |                 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] 944 |                 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`
[INFO] [stdout]    --> src/scalar.rs:944:59
[INFO] [stdout]     |
[INFO] [stdout] 944 |                 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] 944 |                 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`
[INFO] [stdout]    --> src/scalar.rs:956:75
[INFO] [stdout]     |
[INFO] [stdout] 956 |                 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] 956 |                 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`
[INFO] [stdout]    --> src/scalar.rs:956:83
[INFO] [stdout]     |
[INFO] [stdout] 956 |                 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] 956 |                 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`
[INFO] [stdout]    --> src/scalar.rs:957:75
[INFO] [stdout]     |
[INFO] [stdout] 957 |                 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] 957 |                 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`
[INFO] [stdout]    --> src/scalar.rs:957:83
[INFO] [stdout]     |
[INFO] [stdout] 957 |                 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] 957 |                 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`
[INFO] [stdout]    --> src/scalar.rs:958:75
[INFO] [stdout]     |
[INFO] [stdout] 958 |                 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] 958 |                 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`
[INFO] [stdout]    --> src/scalar.rs:958:83
[INFO] [stdout]     |
[INFO] [stdout] 958 |                 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] 958 |                 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`
[INFO] [stdout]    --> src/scalar.rs:972:55
[INFO] [stdout]     |
[INFO] [stdout] 972 |                     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] 972 |                     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`
[INFO] [stdout]    --> src/scalar.rs:972:63
[INFO] [stdout]     |
[INFO] [stdout] 972 |                     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] 972 |                     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`
[INFO] [stdout]     --> src/scalar.rs:3508:69
[INFO] [stdout]      |
[INFO] [stdout] 3508 |         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] 3508 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3508 +         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] 3508 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3508 +         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`
[INFO] [stdout]     --> src/scalar.rs:3509:59
[INFO] [stdout]      |
[INFO] [stdout] 3509 |         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] 3509 |         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`
[INFO] [stdout]     --> src/scalar.rs:3509:70
[INFO] [stdout]      |
[INFO] [stdout] 3509 |         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] 3509 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3509 +         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] 3509 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3509 +         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`
[INFO] [stdout]     --> src/scalar.rs:3510:58
[INFO] [stdout]      |
[INFO] [stdout] 3510 |         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] 3510 |         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`
[INFO] [stdout]     --> src/scalar.rs:3510:69
[INFO] [stdout]      |
[INFO] [stdout] 3510 |         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] 3510 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3510 +         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] 3510 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3510 +         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`
[INFO] [stdout]     --> src/scalar.rs:3511:58
[INFO] [stdout]      |
[INFO] [stdout] 3511 |         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] 3511 |         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`
[INFO] [stdout]     --> src/scalar.rs:3511:69
[INFO] [stdout]      |
[INFO] [stdout] 3511 |         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] 3511 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3511 +         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] 3511 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3511 +         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`
[INFO] [stdout]     --> src/scalar.rs:3522:59
[INFO] [stdout]      |
[INFO] [stdout] 3522 |         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] 3522 |         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`
[INFO] [stdout]     --> src/scalar.rs:3522:70
[INFO] [stdout]      |
[INFO] [stdout] 3522 |         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] 3522 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3522 +         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] 3522 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3522 +         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`
[INFO] [stdout]     --> src/scalar.rs:3523:60
[INFO] [stdout]      |
[INFO] [stdout] 3523 |         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] 3523 |         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`
[INFO] [stdout]     --> src/scalar.rs:3523:71
[INFO] [stdout]      |
[INFO] [stdout] 3523 |         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] 3523 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3523 +         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] 3523 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3523 +         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`
[INFO] [stdout]     --> src/scalar.rs:3524:59
[INFO] [stdout]      |
[INFO] [stdout] 3524 |         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] 3524 |         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`
[INFO] [stdout]     --> src/scalar.rs:3524:70
[INFO] [stdout]      |
[INFO] [stdout] 3524 |         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] 3524 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3524 +         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] 3524 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3524 +         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`
[INFO] [stdout]     --> src/scalar.rs:3525:59
[INFO] [stdout]      |
[INFO] [stdout] 3525 |         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] 3525 |         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`
[INFO] [stdout]     --> src/scalar.rs:3525:70
[INFO] [stdout]      |
[INFO] [stdout] 3525 |         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] 3525 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3525 +         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] 3525 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3525 +         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`
[INFO] [stdout]     --> src/scalar.rs:3531:59
[INFO] [stdout]      |
[INFO] [stdout] 3531 |         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] 3531 |         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`
[INFO] [stdout]     --> src/scalar.rs:3532:59
[INFO] [stdout]      |
[INFO] [stdout] 3532 |         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] 3532 |         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`
[INFO] [stdout]     --> src/scalar.rs:3533:60
[INFO] [stdout]      |
[INFO] [stdout] 3533 |         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] 3533 |         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`
[INFO] [stdout]     --> src/scalar.rs:3534:60
[INFO] [stdout]      |
[INFO] [stdout] 3534 |         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] 3534 |         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`
[INFO] [stdout]     --> src/scalar.rs:3535:60
[INFO] [stdout]      |
[INFO] [stdout] 3535 |         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] 3535 |         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`
[INFO] [stdout]     --> src/scalar.rs:3536:60
[INFO] [stdout]      |
[INFO] [stdout] 3536 |         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] 3536 |         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`
[INFO] [stdout]     --> src/scalar.rs:3537:60
[INFO] [stdout]      |
[INFO] [stdout] 3537 |         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] 3537 |         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`
[INFO] [stdout]     --> src/scalar.rs:3538:60
[INFO] [stdout]      |
[INFO] [stdout] 3538 |         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] 3538 |         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`
[INFO] [stdout]     --> src/scalar.rs:3539:60
[INFO] [stdout]      |
[INFO] [stdout] 3539 |         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] 3539 |         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`
[INFO] [stdout]     --> src/scalar.rs:3540:60
[INFO] [stdout]      |
[INFO] [stdout] 3540 |         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] 3540 |         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`
[INFO] [stdout]     --> src/scalar.rs:3553:48
[INFO] [stdout]      |
[INFO] [stdout] 3553 |             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] 3553 |             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`
[INFO] [stdout]    --> src/scalar.rs:974:55
[INFO] [stdout]     |
[INFO] [stdout] 974 |                     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] 974 |                     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`
[INFO] [stdout]    --> src/scalar.rs:974:63
[INFO] [stdout]     |
[INFO] [stdout] 974 |                     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] 974 |                     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`
[INFO] [stdout]    --> src/scalar.rs:989:47
[INFO] [stdout]     |
[INFO] [stdout] 989 |             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] 989 |             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`
[INFO] [stdout]    --> src/scalar.rs:989:55
[INFO] [stdout]     |
[INFO] [stdout] 989 |             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] 989 |             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`
[INFO] [stdout]     --> src/scalar.rs:1001:51
[INFO] [stdout]      |
[INFO] [stdout] 1001 |                 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] 1001 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1015:57
[INFO] [stdout]      |
[INFO] [stdout] 1015 |                 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] 1015 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1015:65
[INFO] [stdout]      |
[INFO] [stdout] 1015 |                 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] 1015 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1017:57
[INFO] [stdout]      |
[INFO] [stdout] 1017 |                 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] 1017 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1017:65
[INFO] [stdout]      |
[INFO] [stdout] 1017 |                 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] 1017 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1020:52
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 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] 1020 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3553:64
[INFO] [stdout]      |
[INFO] [stdout] 3553 |             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] 3553 |             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`
[INFO] [stdout]     --> src/scalar.rs:3553:79
[INFO] [stdout]      |
[INFO] [stdout] 3553 |             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] 3553 |             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`
[INFO] [stdout]     --> src/scalar.rs:3556:48
[INFO] [stdout]      |
[INFO] [stdout] 3556 |             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] 3556 |             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`
[INFO] [stdout]     --> src/scalar.rs:3556:64
[INFO] [stdout]      |
[INFO] [stdout] 3556 |             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] 3556 |             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`
[INFO] [stdout]     --> src/scalar.rs:3556:79
[INFO] [stdout]      |
[INFO] [stdout] 3556 |             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] 3556 |             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`
[INFO] [stdout]     --> src/scalar.rs:3559:48
[INFO] [stdout]      |
[INFO] [stdout] 3559 |             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] 3559 |             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`
[INFO] [stdout]     --> src/scalar.rs:3559:64
[INFO] [stdout]      |
[INFO] [stdout] 3559 |             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] 3559 |             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`
[INFO] [stdout]     --> src/scalar.rs:3559:79
[INFO] [stdout]      |
[INFO] [stdout] 3559 |             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] 3559 |             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`
[INFO] [stdout]     --> src/scalar.rs:3562:48
[INFO] [stdout]      |
[INFO] [stdout] 3562 |             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] 3562 |             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`
[INFO] [stdout]     --> src/scalar.rs:3562:64
[INFO] [stdout]      |
[INFO] [stdout] 3562 |             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] 3562 |             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`
[INFO] [stdout]     --> src/scalar.rs:1020:65
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 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] 1020 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1020:73
[INFO] [stdout]      |
[INFO] [stdout] 1020 |                 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] 1020 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1022:51
[INFO] [stdout]      |
[INFO] [stdout] 1022 |                 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] 1022 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1028:51
[INFO] [stdout]      |
[INFO] [stdout] 1028 |                 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] 1028 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1028:59
[INFO] [stdout]      |
[INFO] [stdout] 1028 |                 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] 1028 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1030:51
[INFO] [stdout]      |
[INFO] [stdout] 1030 |                 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] 1030 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1030:59
[INFO] [stdout]      |
[INFO] [stdout] 1030 |                 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] 1030 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1037:28
[INFO] [stdout]      |
[INFO] [stdout] 1037 |                 ; 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] 1037 |                 ; fmov d0, X(<u8 as Into<_>>::into(src))
[INFO] [stdout]      |                              ++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1040:24
[INFO] [stdout]      |
[INFO] [stdout] 1040 |                 ; 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] 1040 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1045:53
[INFO] [stdout]      |
[INFO] [stdout] 1045 |             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] 1045 |             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`
[INFO] [stdout]     --> src/scalar.rs:3562:79
[INFO] [stdout]      |
[INFO] [stdout] 3562 |             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] 3562 |             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`
[INFO] [stdout]     --> src/scalar.rs:3565:48
[INFO] [stdout]      |
[INFO] [stdout] 3565 |             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] 3565 |             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`
[INFO] [stdout]     --> src/scalar.rs:3565:64
[INFO] [stdout]      |
[INFO] [stdout] 3565 |             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] 3565 |             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`
[INFO] [stdout]     --> src/scalar.rs:3565:79
[INFO] [stdout]      |
[INFO] [stdout] 3565 |             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] 3565 |             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`
[INFO] [stdout]     --> src/scalar.rs:3568:48
[INFO] [stdout]      |
[INFO] [stdout] 3568 |             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] 3568 |             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`
[INFO] [stdout]     --> src/scalar.rs:3568:64
[INFO] [stdout]      |
[INFO] [stdout] 3568 |             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] 3568 |             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`
[INFO] [stdout]     --> src/scalar.rs:3568:79
[INFO] [stdout]      |
[INFO] [stdout] 3568 |             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] 3568 |             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`
[INFO] [stdout]     --> src/scalar.rs:3571:48
[INFO] [stdout]      |
[INFO] [stdout] 3571 |             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] 3571 |             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`
[INFO] [stdout]     --> src/scalar.rs:3571:64
[INFO] [stdout]      |
[INFO] [stdout] 3571 |             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] 3571 |             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`
[INFO] [stdout]     --> src/scalar.rs:3571:79
[INFO] [stdout]      |
[INFO] [stdout] 3571 |             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] 3571 |             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`
[INFO] [stdout]     --> src/scalar.rs:1045:66
[INFO] [stdout]      |
[INFO] [stdout] 1045 |             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] 1045 |             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`
[INFO] [stdout]     --> src/scalar.rs:1049:52
[INFO] [stdout]      |
[INFO] [stdout] 1049 |             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] 1049 |             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`
[INFO] [stdout]     --> src/scalar.rs:1052:47
[INFO] [stdout]      |
[INFO] [stdout] 1052 |             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] 1052 |             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`
[INFO] [stdout]     --> src/scalar.rs:1068:23
[INFO] [stdout]      |
[INFO] [stdout] 1068 |                 ; 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] 1068 |                 ; cmp XSP(<u8 as Into<_>>::into(cond)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1069:24
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                 ; 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] 1069 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1069:32
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                 ; 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] 1069 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1069:45
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                 ; 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] 1069 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1087:47
[INFO] [stdout]      |
[INFO] [stdout] 1087 |             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] 1087 |             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`
[INFO] [stdout]     --> src/scalar.rs:1087:55
[INFO] [stdout]      |
[INFO] [stdout] 1087 |             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] 1087 |             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`
[INFO] [stdout]     --> src/scalar.rs:1106:51
[INFO] [stdout]      |
[INFO] [stdout] 1106 |                 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] 1106 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1121:51
[INFO] [stdout]      |
[INFO] [stdout] 1121 |                 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] 1121 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1157:56
[INFO] [stdout]      |
[INFO] [stdout] 1157 |                     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] 1157 |                     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`
[INFO] [stdout]     --> src/scalar.rs:1159:55
[INFO] [stdout]      |
[INFO] [stdout] 1159 |                     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] 1159 |                     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`
[INFO] [stdout]     --> src/scalar.rs:1180:51
[INFO] [stdout]      |
[INFO] [stdout] 1180 |                 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] 1180 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1182:52
[INFO] [stdout]      |
[INFO] [stdout] 1182 |                 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] 1182 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1448:47
[INFO] [stdout]      |
[INFO] [stdout] 1448 |             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] 1448 |             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`
[INFO] [stdout]     --> src/scalar.rs:1448:55
[INFO] [stdout]      |
[INFO] [stdout] 1448 |             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] 1448 |             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`
[INFO] [stdout]     --> src/scalar.rs:1452:23
[INFO] [stdout]      |
[INFO] [stdout] 1452 |                 ; 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] 1452 |                 ; cmp XSP(<u8 as Into<_>>::into(guard)), #0
[INFO] [stdout]      |                           ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1455:24
[INFO] [stdout]      |
[INFO] [stdout] 1455 |                 ; 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] 1455 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1455:32
[INFO] [stdout]      |
[INFO] [stdout] 1455 |                 ; 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] 1455 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:1455:45
[INFO] [stdout]      |
[INFO] [stdout] 1455 |                 ; 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] 1455 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:3574:48
[INFO] [stdout]      |
[INFO] [stdout] 3574 |             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] 3574 |             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`
[INFO] [stdout]     --> src/scalar.rs:3574:64
[INFO] [stdout]      |
[INFO] [stdout] 3574 |             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] 3574 |             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`
[INFO] [stdout]     --> src/scalar.rs:3574:79
[INFO] [stdout]      |
[INFO] [stdout] 3574 |             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] 3574 |             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`
[INFO] [stdout]     --> src/scalar.rs:3577:48
[INFO] [stdout]      |
[INFO] [stdout] 3577 |             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] 3577 |             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`
[INFO] [stdout]     --> src/scalar.rs:3577:64
[INFO] [stdout]      |
[INFO] [stdout] 3577 |             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] 3577 |             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`
[INFO] [stdout]     --> src/scalar.rs:3577:79
[INFO] [stdout]      |
[INFO] [stdout] 3577 |             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] 3577 |             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`
[INFO] [stdout]     --> src/scalar.rs:3580:48
[INFO] [stdout]      |
[INFO] [stdout] 3580 |             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] 3580 |             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`
[INFO] [stdout]     --> src/scalar.rs:3580:64
[INFO] [stdout]      |
[INFO] [stdout] 3580 |             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] 3580 |             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`
[INFO] [stdout]     --> src/scalar.rs:3580:79
[INFO] [stdout]      |
[INFO] [stdout] 3580 |             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] 3580 |             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`
[INFO] [stdout]     --> src/scalar.rs:3594:47
[INFO] [stdout]      |
[INFO] [stdout] 3594 |             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] 3594 |             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`
[INFO] [stdout]     --> src/scalar.rs:1472:52
[INFO] [stdout]      |
[INFO] [stdout] 1472 |             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] 1472 |             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`
[INFO] [stdout]     --> src/scalar.rs:3594:55
[INFO] [stdout]      |
[INFO] [stdout] 3594 |             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] 3594 |             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`
[INFO] [stdout]     --> src/scalar.rs:1475:43
[INFO] [stdout]      |
[INFO] [stdout] 1475 |         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] 1475 |         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`
[INFO] [stdout]     --> src/scalar.rs:3600:51
[INFO] [stdout]      |
[INFO] [stdout] 3600 |                 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] 3600 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1475:51
[INFO] [stdout]      |
[INFO] [stdout] 1475 |         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] 1475 |         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`
[INFO] [stdout]     --> src/scalar.rs:3691:32
[INFO] [stdout]      |
[INFO] [stdout] 3691 |                     ; 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] 3691 |                     ; mov x16, X(<u8 as Into<_>>::into(left))
[INFO] [stdout]      |                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1478:39
[INFO] [stdout]      |
[INFO] [stdout] 1478 |     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] 1478 |     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`
[INFO] [stdout]     --> src/scalar.rs:3692:27
[INFO] [stdout]      |
[INFO] [stdout] 3692 |                     ; 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] 3692 |                     ; 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`
[INFO] [stdout]     --> src/scalar.rs:1478:47
[INFO] [stdout]      |
[INFO] [stdout] 1478 |     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] 1478 |     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`
[INFO] [stdout]     --> src/scalar.rs:3692:36
[INFO] [stdout]      |
[INFO] [stdout] 3692 |                     ; 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] 3692 |                     ; 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`
[INFO] [stdout]     --> src/scalar.rs:1694:56
[INFO] [stdout]      |
[INFO] [stdout] 1694 |                 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] 1694 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3693:27
[INFO] [stdout]      |
[INFO] [stdout] 3693 |                     ; 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] 3693 |                     ; mov X(<u8 as Into<_>>::into(right)), x16
[INFO] [stdout]      |                             ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:3760:47
[INFO] [stdout]      |
[INFO] [stdout] 3760 |             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] 3760 |             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`
[INFO] [stdout]     --> src/scalar.rs:1762:39
[INFO] [stdout]      |
[INFO] [stdout] 1762 |     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] 1762 |     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`
[INFO] [stdout]     --> src/scalar.rs:3760:58
[INFO] [stdout]      |
[INFO] [stdout] 3760 |             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] 3760 |             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`
[INFO] [stdout]     --> src/scalar.rs:1796:60
[INFO] [stdout]      |
[INFO] [stdout] 1796 |             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] 1796 |             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`
[INFO] [stdout]     --> src/scalar.rs:3777:47
[INFO] [stdout]      |
[INFO] [stdout] 3777 |             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] 3777 |             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`
[INFO] [stdout]     --> src/scalar.rs:1797:59
[INFO] [stdout]      |
[INFO] [stdout] 1797 |             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] 1797 |             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`
[INFO] [stdout]     --> src/scalar.rs:3777:60
[INFO] [stdout]      |
[INFO] [stdout] 3777 |             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] 3777 |             dynasm!(ops ; .arch aarch64 ; mov X(register), X(<u8 as Into<_>>::into(source)));
[INFO] [stdout]      |                                                              ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:1798:59
[INFO] [stdout]      |
[INFO] [stdout] 1798 |             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] 1798 |             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`
[INFO] [stdout]     --> src/scalar.rs:1826:64
[INFO] [stdout]      |
[INFO] [stdout] 1826 |                 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] 1826 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1827:63
[INFO] [stdout]      |
[INFO] [stdout] 1827 |                 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] 1827 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1828:63
[INFO] [stdout]      |
[INFO] [stdout] 1828 |                 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] 1828 |                 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`
[INFO] [stdout]     --> src/scalar.rs:1878:39
[INFO] [stdout]      |
[INFO] [stdout] 1878 |     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] 1878 |     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`
[INFO] [stdout]     --> src/scalar.rs:2015:24
[INFO] [stdout]      |
[INFO] [stdout] 2015 |                 ; 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] 2015 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2018:24
[INFO] [stdout]      |
[INFO] [stdout] 2018 |                 ; 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] 2018 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2034:24
[INFO] [stdout]      |
[INFO] [stdout] 2034 |                 ; 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] 2034 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2048:24
[INFO] [stdout]      |
[INFO] [stdout] 2048 |                 ; 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] 2048 |                 ; 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`
[INFO] [stdout]     --> src/scalar.rs:2073:23
[INFO] [stdout]      |
[INFO] [stdout] 2073 |         ; 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] 2073 |         ; 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`
[INFO] [stdout]     --> src/scalar.rs:2074:23
[INFO] [stdout]      |
[INFO] [stdout] 2074 |         ; 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] 2074 |         ; 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`
[INFO] [stdout]     --> src/scalar.rs:2130:16
[INFO] [stdout]      |
[INFO] [stdout] 2130 |         ; 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] 2130 |         ; 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`
[INFO] [stdout]     --> src/scalar.rs:2133:16
[INFO] [stdout]      |
[INFO] [stdout] 2133 |         ; 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] 2133 |         ; 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`
[INFO] [stdout]     --> src/scalar.rs:2136:15
[INFO] [stdout]      |
[INFO] [stdout] 2136 |         ; 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] 2136 |         ; mov X(<u8 as Into<_>>::into(destination)), x30
[INFO] [stdout]      |                 ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:2504:43
[INFO] [stdout]      |
[INFO] [stdout] 2504 |         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] 2504 |         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`
[INFO] [stdout]     --> src/scalar.rs:2504:59
[INFO] [stdout]      |
[INFO] [stdout] 2504 |         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] 2504 |         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`
[INFO] [stdout]     --> src/scalar.rs:2513:47
[INFO] [stdout]      |
[INFO] [stdout] 2513 |             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] 2513 |             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`
[INFO] [stdout]     --> src/scalar.rs:2513:63
[INFO] [stdout]      |
[INFO] [stdout] 2513 |             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] 2513 |             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`
[INFO] [stdout]     --> src/scalar.rs:2513:72
[INFO] [stdout]      |
[INFO] [stdout] 2513 |             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] 2513 |             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`
[INFO] [stdout]     --> src/scalar.rs:2516:39
[INFO] [stdout]      |
[INFO] [stdout] 2516 |     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] 2516 |     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`
[INFO] [stdout]     --> src/scalar.rs:2516:55
[INFO] [stdout]      |
[INFO] [stdout] 2516 |     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] 2516 |     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`
[INFO] [stdout]     --> src/scalar.rs:3018:43
[INFO] [stdout]      |
[INFO] [stdout] 3018 |         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] 3018 |         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`
[INFO] [stdout]     --> src/scalar.rs:3018:59
[INFO] [stdout]      |
[INFO] [stdout] 3018 |         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] 3018 |         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`
[INFO] [stdout]     --> src/scalar.rs:3025:47
[INFO] [stdout]      |
[INFO] [stdout] 3025 |             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] 3025 |             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`
[INFO] [stdout]     --> src/scalar.rs:3025:63
[INFO] [stdout]      |
[INFO] [stdout] 3025 |             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] 3025 |             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`
[INFO] [stdout]     --> src/scalar.rs:3120:52
[INFO] [stdout]      |
[INFO] [stdout] 3120 |                 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] 3120 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3120:68
[INFO] [stdout]      |
[INFO] [stdout] 3120 |                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3120:68
[INFO] [stdout]      |
[INFO] [stdout] 3120 |                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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] 3120 -                 dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3120 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3123:52
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 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] 3123 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3123:68
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3123:68
[INFO] [stdout]      |
[INFO] [stdout] 3123 |                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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] 3123 -                 dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3123 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3126:51
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 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] 3126 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3126:67
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3126:67
[INFO] [stdout]      |
[INFO] [stdout] 3126 |                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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] 3126 -                 dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3126 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3129:51
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 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] 3129 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3129:67
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3129:67
[INFO] [stdout]      |
[INFO] [stdout] 3129 |                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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] 3129 -                 dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3129 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3134:48
[INFO] [stdout]      |
[INFO] [stdout] 3134 |         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] 3134 |         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`
[INFO] [stdout]     --> src/scalar.rs:3134:57
[INFO] [stdout]      |
[INFO] [stdout] 3134 |         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] 3134 |         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`
[INFO] [stdout]     --> src/scalar.rs:3171:52
[INFO] [stdout]      |
[INFO] [stdout] 3171 |                 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] 3171 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3171:63
[INFO] [stdout]      |
[INFO] [stdout] 3171 |                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3171:63
[INFO] [stdout]      |
[INFO] [stdout] 3171 |                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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] 3171 -                 dynasm!(ops ; .arch aarch64 ; strb W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3171 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3174:52
[INFO] [stdout]      |
[INFO] [stdout] 3174 |                 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] 3174 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3174:63
[INFO] [stdout]      |
[INFO] [stdout] 3174 |                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3174:63
[INFO] [stdout]      |
[INFO] [stdout] 3174 |                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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] 3174 -                 dynasm!(ops ; .arch aarch64 ; strh W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3174 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3177:51
[INFO] [stdout]      |
[INFO] [stdout] 3177 |                 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] 3177 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3177:62
[INFO] [stdout]      |
[INFO] [stdout] 3177 |                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3177:62
[INFO] [stdout]      |
[INFO] [stdout] 3177 |                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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] 3177 -                 dynasm!(ops ; .arch aarch64 ; str W(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3177 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3180:51
[INFO] [stdout]      |
[INFO] [stdout] 3180 |                 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] 3180 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3180:62
[INFO] [stdout]      |
[INFO] [stdout] 3180 |                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3180:62
[INFO] [stdout]      |
[INFO] [stdout] 3180 |                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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] 3180 -                 dynasm!(ops ; .arch aarch64 ; str X(source), [X(base), X(index), LSL #shift])
[INFO] [stdout] 3180 +                 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`
[INFO] [stdout]     --> src/scalar.rs:3185:48
[INFO] [stdout]      |
[INFO] [stdout] 3185 |         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] 3185 |         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`
[INFO] [stdout]     --> src/scalar.rs:3185:57
[INFO] [stdout]      |
[INFO] [stdout] 3185 |         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] 3185 |         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`
[INFO] [stdout]     --> src/scalar.rs:3467:58
[INFO] [stdout]      |
[INFO] [stdout] 3467 |         (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] 3467 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3468:58
[INFO] [stdout]      |
[INFO] [stdout] 3468 |         (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] 3468 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3469:58
[INFO] [stdout]      |
[INFO] [stdout] 3469 |         (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] 3469 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3470:58
[INFO] [stdout]      |
[INFO] [stdout] 3470 |         (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] 3470 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3471:57
[INFO] [stdout]      |
[INFO] [stdout] 3471 |         (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] 3471 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3472:57
[INFO] [stdout]      |
[INFO] [stdout] 3472 |         (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] 3472 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3473:57
[INFO] [stdout]      |
[INFO] [stdout] 3473 |         (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] 3473 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3474:57
[INFO] [stdout]      |
[INFO] [stdout] 3474 |         (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] 3474 |         (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`
[INFO] [stdout]     --> src/scalar.rs:3483:53
[INFO] [stdout]      |
[INFO] [stdout] 3483 |             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] 3483 |             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`
[INFO] [stdout]     --> src/scalar.rs:3484:53
[INFO] [stdout]      |
[INFO] [stdout] 3484 |             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] 3484 |             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`
[INFO] [stdout]     --> src/scalar.rs:3485:53
[INFO] [stdout]      |
[INFO] [stdout] 3485 |             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] 3485 |             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`
[INFO] [stdout]     --> src/scalar.rs:3486:53
[INFO] [stdout]      |
[INFO] [stdout] 3486 |             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] 3486 |             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`
[INFO] [stdout]     --> src/scalar.rs:3499:58
[INFO] [stdout]      |
[INFO] [stdout] 3499 |         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] 3499 |         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`
[INFO] [stdout]     --> src/scalar.rs:3499:74
[INFO] [stdout]      |
[INFO] [stdout] 3499 |         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] 3499 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3499 +         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] 3499 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; ldrb W(destination), [X(address)]),
[INFO] [stdout] 3499 +         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`
[INFO] [stdout]     --> src/scalar.rs:3500:59
[INFO] [stdout]      |
[INFO] [stdout] 3500 |         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] 3500 |         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`
[INFO] [stdout]     --> src/scalar.rs:3500:75
[INFO] [stdout]      |
[INFO] [stdout] 3500 |         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] 3500 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3500 +         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] 3500 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; ldrh W(destination), [X(address)]),
[INFO] [stdout] 3500 +         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`
[INFO] [stdout]     --> src/scalar.rs:3501:58
[INFO] [stdout]      |
[INFO] [stdout] 3501 |         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] 3501 |         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`
[INFO] [stdout]     --> src/scalar.rs:3501:74
[INFO] [stdout]      |
[INFO] [stdout] 3501 |         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] 3501 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3501 +         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] 3501 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; ldr W(destination), [X(address)]),
[INFO] [stdout] 3501 +         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`
[INFO] [stdout]     --> src/scalar.rs:3502:58
[INFO] [stdout]      |
[INFO] [stdout] 3502 |         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] 3502 |         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`
[INFO] [stdout]     --> src/scalar.rs:3502:74
[INFO] [stdout]      |
[INFO] [stdout] 3502 |         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] 3502 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3502 +         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] 3502 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; ldr X(destination), [X(address)]),
[INFO] [stdout] 3502 +         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`
[INFO] [stdout]     --> src/scalar.rs:3508:58
[INFO] [stdout]      |
[INFO] [stdout] 3508 |         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] 3508 |         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`
[INFO] [stdout]     --> src/scalar.rs:3508:69
[INFO] [stdout]      |
[INFO] [stdout] 3508 |         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] 3508 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3508 +         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] 3508 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; strb W(source), [X(address)]),
[INFO] [stdout] 3508 +         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`
[INFO] [stdout]     --> src/scalar.rs:3509:59
[INFO] [stdout]      |
[INFO] [stdout] 3509 |         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] 3509 |         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`
[INFO] [stdout]     --> src/scalar.rs:3509:70
[INFO] [stdout]      |
[INFO] [stdout] 3509 |         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] 3509 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3509 +         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] 3509 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; strh W(source), [X(address)]),
[INFO] [stdout] 3509 +         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`
[INFO] [stdout]     --> src/scalar.rs:3510:58
[INFO] [stdout]      |
[INFO] [stdout] 3510 |         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] 3510 |         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`
[INFO] [stdout]     --> src/scalar.rs:3510:69
[INFO] [stdout]      |
[INFO] [stdout] 3510 |         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] 3510 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3510 +         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] 3510 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; str W(source), [X(address)]),
[INFO] [stdout] 3510 +         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`
[INFO] [stdout]     --> src/scalar.rs:3511:58
[INFO] [stdout]      |
[INFO] [stdout] 3511 |         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] 3511 |         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`
[INFO] [stdout]     --> src/scalar.rs:3511:69
[INFO] [stdout]      |
[INFO] [stdout] 3511 |         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] 3511 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3511 +         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] 3511 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; str X(source), [X(address)]),
[INFO] [stdout] 3511 +         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`
[INFO] [stdout]     --> src/scalar.rs:3522:59
[INFO] [stdout]      |
[INFO] [stdout] 3522 |         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] 3522 |         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`
[INFO] [stdout]     --> src/scalar.rs:3522:70
[INFO] [stdout]      |
[INFO] [stdout] 3522 |         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] 3522 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3522 +         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] 3522 -         OpSize::S8 => dynasm!(ops ; .arch aarch64 ; stlrb W(source), [X(address)]),
[INFO] [stdout] 3522 +         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`
[INFO] [stdout]     --> src/scalar.rs:3523:60
[INFO] [stdout]      |
[INFO] [stdout] 3523 |         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] 3523 |         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`
[INFO] [stdout]     --> src/scalar.rs:3523:71
[INFO] [stdout]      |
[INFO] [stdout] 3523 |         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] 3523 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3523 +         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] 3523 -         OpSize::S16 => dynasm!(ops ; .arch aarch64 ; stlrh W(source), [X(address)]),
[INFO] [stdout] 3523 +         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`
[INFO] [stdout]     --> src/scalar.rs:3524:59
[INFO] [stdout]      |
[INFO] [stdout] 3524 |         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] 3524 |         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`
[INFO] [stdout]     --> src/scalar.rs:3524:70
[INFO] [stdout]      |
[INFO] [stdout] 3524 |         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] 3524 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3524 +         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] 3524 -         OpSize::S32 => dynasm!(ops ; .arch aarch64 ; stlr W(source), [X(address)]),
[INFO] [stdout] 3524 +         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`
[INFO] [stdout]     --> src/scalar.rs:3525:59
[INFO] [stdout]      |
[INFO] [stdout] 3525 |         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] 3525 |         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`
[INFO] [stdout]     --> src/scalar.rs:3525:70
[INFO] [stdout]      |
[INFO] [stdout] 3525 |         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] 3525 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3525 +         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] 3525 -         OpSize::S64 => dynasm!(ops ; .arch aarch64 ; stlr X(source), [X(address)]),
[INFO] [stdout] 3525 +         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`
[INFO] [stdout]     --> src/scalar.rs:3531:59
[INFO] [stdout]      |
[INFO] [stdout] 3531 |         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] 3531 |         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`
[INFO] [stdout]     --> src/scalar.rs:3532:59
[INFO] [stdout]      |
[INFO] [stdout] 3532 |         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] 3532 |         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`
[INFO] [stdout]     --> src/scalar.rs:3533:60
[INFO] [stdout]      |
[INFO] [stdout] 3533 |         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] 3533 |         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`
[INFO] [stdout]     --> src/scalar.rs:3534:60
[INFO] [stdout]      |
[INFO] [stdout] 3534 |         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] 3534 |         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`
[INFO] [stdout]     --> src/scalar.rs:3535:60
[INFO] [stdout]      |
[INFO] [stdout] 3535 |         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] 3535 |         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`
[INFO] [stdout]     --> src/scalar.rs:3536:60
[INFO] [stdout]      |
[INFO] [stdout] 3536 |         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] 3536 |         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`
[INFO] [stdout]     --> src/scalar.rs:3537:60
[INFO] [stdout]      |
[INFO] [stdout] 3537 |         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] 3537 |         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`
[INFO] [stdout]     --> src/scalar.rs:3538:60
[INFO] [stdout]      |
[INFO] [stdout] 3538 |         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] 3538 |         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`
[INFO] [stdout]     --> src/scalar.rs:3539:60
[INFO] [stdout]      |
[INFO] [stdout] 3539 |         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] 3539 |         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`
[INFO] [stdout]     --> src/scalar.rs:3540:60
[INFO] [stdout]      |
[INFO] [stdout] 3540 |         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] 3540 |         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`
[INFO] [stdout]     --> src/scalar.rs:3553:48
[INFO] [stdout]      |
[INFO] [stdout] 3553 |             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] 3553 |             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`
[INFO] [stdout]     --> src/scalar.rs:3553:64
[INFO] [stdout]      |
[INFO] [stdout] 3553 |             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] 3553 |             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`
[INFO] [stdout]     --> src/scalar.rs:3553:79
[INFO] [stdout]      |
[INFO] [stdout] 3553 |             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] 3553 |             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`
[INFO] [stdout]     --> src/scalar.rs:3556:48
[INFO] [stdout]      |
[INFO] [stdout] 3556 |             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] 3556 |             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`
[INFO] [stdout]     --> src/scalar.rs:3556:64
[INFO] [stdout]      |
[INFO] [stdout] 3556 |             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] 3556 |             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`
[INFO] [stdout]     --> src/scalar.rs:3556:79
[INFO] [stdout]      |
[INFO] [stdout] 3556 |             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] 3556 |             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`
[INFO] [stdout]     --> src/scalar.rs:3559:48
[INFO] [stdout]      |
[INFO] [stdout] 3559 |             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] 3559 |             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`
[INFO] [stdout]     --> src/scalar.rs:3559:64
[INFO] [stdout]      |
[INFO] [stdout] 3559 |             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] 3559 |             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`
[INFO] [stdout]     --> src/scalar.rs:3559:79
[INFO] [stdout]      |
[INFO] [stdout] 3559 |             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] 3559 |             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`
[INFO] [stdout]     --> src/scalar.rs:3562:48
[INFO] [stdout]      |
[INFO] [stdout] 3562 |             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] 3562 |             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`
[INFO] [stdout]     --> src/scalar.rs:3562:64
[INFO] [stdout]      |
[INFO] [stdout] 3562 |             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] 3562 |             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`
[INFO] [stdout]     --> src/scalar.rs:3562:79
[INFO] [stdout]      |
[INFO] [stdout] 3562 |             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] 3562 |             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`
[INFO] [stdout]     --> src/scalar.rs:3565:48
[INFO] [stdout]      |
[INFO] [stdout] 3565 |             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] 3565 |             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`
[INFO] [stdout]     --> src/scalar.rs:3565:64
[INFO] [stdout]      |
[INFO] [stdout] 3565 |             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] 3565 |             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`
[INFO] [stdout]     --> src/scalar.rs:3565:79
[INFO] [stdout]      |
[INFO] [stdout] 3565 |             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] 3565 |             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`
[INFO] [stdout]     --> src/scalar.rs:3568:48
[INFO] [stdout]      |
[INFO] [stdout] 3568 |             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] 3568 |             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`
[INFO] [stdout]     --> src/scalar.rs:3568:64
[INFO] [stdout]      |
[INFO] [stdout] 3568 |             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] 3568 |             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`
[INFO] [stdout]     --> src/scalar.rs:3568:79
[INFO] [stdout]      |
[INFO] [stdout] 3568 |             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] 3568 |             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`
[INFO] [stdout]     --> src/scalar.rs:3571:48
[INFO] [stdout]      |
[INFO] [stdout] 3571 |             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] 3571 |             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`
[INFO] [stdout]     --> src/scalar.rs:3571:64
[INFO] [stdout]      |
[INFO] [stdout] 3571 |             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] 3571 |             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`
[INFO] [stdout]     --> src/scalar.rs:3571:79
[INFO] [stdout]      |
[INFO] [stdout] 3571 |             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] 3571 |             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`
[INFO] [stdout]     --> src/scalar.rs:3574:48
[INFO] [stdout]      |
[INFO] [stdout] 3574 |             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] 3574 |             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`
[INFO] [stdout]     --> src/scalar.rs:3574:64
[INFO] [stdout]      |
[INFO] [stdout] 3574 |             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] 3574 |             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`
[INFO] [stdout]     --> src/scalar.rs:3574:79
[INFO] [stdout]      |
[INFO] [stdout] 3574 |             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] 3574 |             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`
[INFO] [stdout]     --> src/scalar.rs:3577:48
[INFO] [stdout]      |
[INFO] [stdout] 3577 |             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] 3577 |             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`
[INFO] [stdout]     --> src/scalar.rs:3577:64
[INFO] [stdout]      |
[INFO] [stdout] 3577 |             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] 3577 |             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`
[INFO] [stdout]     --> src/scalar.rs:3577:79
[INFO] [stdout]      |
[INFO] [stdout] 3577 |             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] 3577 |             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`
[INFO] [stdout]     --> src/scalar.rs:3580:48
[INFO] [stdout]      |
[INFO] [stdout] 3580 |             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] 3580 |             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`
[INFO] [stdout]     --> src/scalar.rs:3580:64
[INFO] [stdout]      |
[INFO] [stdout] 3580 |             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] 3580 |             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`
[INFO] [stdout]     --> src/scalar.rs:3580:79
[INFO] [stdout]      |
[INFO] [stdout] 3580 |             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] 3580 |             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`
[INFO] [stdout]     --> src/scalar.rs:3594:47
[INFO] [stdout]      |
[INFO] [stdout] 3594 |             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] 3594 |             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`
[INFO] [stdout]     --> src/scalar.rs:3594:55
[INFO] [stdout]      |
[INFO] [stdout] 3594 |             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] 3594 |             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`
[INFO] [stdout]     --> src/scalar.rs:3600:51
[INFO] [stdout]      |
[INFO] [stdout] 3600 |                 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] 3600 |                 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`
[INFO] [stdout]     --> src/scalar.rs:3691:32
[INFO] [stdout]      |
[INFO] [stdout] 3691 |                     ; 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] 3691 |                     ; mov x16, X(<u8 as Into<_>>::into(left))
[INFO] [stdout]      |                                  ++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:3692:27
[INFO] [stdout]      |
[INFO] [stdout] 3692 |                     ; 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] 3692 |                     ; 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`
[INFO] [stdout]     --> src/scalar.rs:3692:36
[INFO] [stdout]      |
[INFO] [stdout] 3692 |                     ; 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] 3692 |                     ; 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`
[INFO] [stdout]     --> src/scalar.rs:3693:27
[INFO] [stdout]      |
[INFO] [stdout] 3693 |                     ; 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] 3693 |                     ; mov X(<u8 as Into<_>>::into(right)), x16
[INFO] [stdout]      |                             ++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/scalar.rs:3760:47
[INFO] [stdout]      |
[INFO] [stdout] 3760 |             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] 3760 |             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`
[INFO] [stdout]     --> src/scalar.rs:3760:58
[INFO] [stdout]      |
[INFO] [stdout] 3760 |             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] 3760 |             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`
[INFO] [stdout]     --> src/scalar.rs:3777:47
[INFO] [stdout]      |
[INFO] [stdout] 3777 |             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] 3777 |             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`
[INFO] [stdout]     --> src/scalar.rs:3777:60
[INFO] [stdout]      |
[INFO] [stdout] 3777 |             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] 3777 |             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 279 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: could not compile `celox-backend-arm64` (lib test) due to 279 previous errors
[INFO] running `Command { std: "docker" "inspect" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d", kill_on_drop: false }`
[INFO] [stdout] 7ca5637cd86e00dc34c9935906bf0758a8a337ea6c2934e1722ae8b2caa73e9d
